get-skill 1.0.21 → 1.3.8

package/README.md

@@ -5,15 +5,15 @@
 # get-skill
 
 [![npm version](https://img.shields.io/npm/v/get-skill.svg)](https://www.npmjs.com/package/get-skill)
-[![license](https://img.shields.io/npm/l/get-skill.svg)](#license)
+[![license](https://img.shields.io/npm/l/get-skill.svg)](https://github.com/skillmds/skillmd/blob/main/LICENSE)
+[![source](https://img.shields.io/badge/source-skillmds%2Fskillmd-blue?logo=github)](https://github.com/skillmds/skillmd)
 
-Get any [Agent Skill](https://docs.claude.com/en/docs/agents-and-tools/agent-skills) (`SKILL.md`) into your agent, from the [SkillMD](https://skillmd.com) registry — 860,000+ skills, each linted, security-scanned and content-pinned.
+Tools for working with [Agent Skills](https://docs.claude.com/en/docs/agents-and-tools/agent-skills) (`SKILL.md`) from the [SkillMD](https://skillmd.com) registry. One package, two binaries:
 
-```bash
-npx get-skill add anthropic/pdf
-```
+- **`skillmd`** — a CLI to lint, scan, search, install, and publish skills.
+- **`get-skill`** — the same CLI, and an MCP server exposing the registry to MCP clients (Claude Code, Claude Desktop, Cursor, …).
 
-> `get-skill` is the same package as [`skillmds`](https://www.npmjs.com/package/skillmds), published under a second, easier-to-remember name. Same build, same version. Either one works.
+Both validate `SKILL.md` with the same engine ([`@skillmds/core`](https://www.npmjs.com/package/@skillmds/core)), so the CLI and the registry apply identical rules. Source lives at [github.com/skillmds/skillmd](https://github.com/skillmds/skillmd).
 
 ## Install
 
@@ -21,70 +21,138 @@ npx get-skill add anthropic/pdf
 npm i -g get-skill
 ```
 
-That gives you three commands off one build:
-
-- **`get-skill`** — everything, in one word. `get-skill <command>` runs the CLI; bare `get-skill` starts the MCP server when an MCP client launches it, or the interactive menu in a terminal.
-- **`skillmd`** — the CLI on its own.
-- **`skillmds`** — the MCP server on its own.
-
-No install needed to try it:
+This installs both the `get-skill` and `skillmd` commands. To run the CLI without installing:
 
 ```bash
-npx get-skill search pdf
 npx get-skill lint .
 ```
 
-## CLI
+**Which binary runs what.** `get-skill` with any argument runs the CLI. `get-skill` with no arguments starts the **MCP server** when stdin is piped (how an MCP client launches it), and opens the interactive CLI menu when there's a terminal attached. `skillmd` is always the CLI.
+
+## CLI: `skillmd`
 
 | Command | Description |
 |---|---|
-| `get-skill add <source>` | Install a skill (registry slug, GitHub repo, or local path). Lints before writing. |
-| `get-skill search <query>` | Search the registry. |
-| `get-skill lint [path]` (`check`) | Validate `SKILL.md` files; print diagnostics and a quality score. |
-| `get-skill scan [path]` | Report scripts, network calls, and secret access. |
-| `get-skill list` (`ls`) | List installed skills. |
-| `get-skill remove <names...>` (`rm`) | Remove installed skills. |
-| `get-skill update [names...]` | Update installed skills from the registry. |
-| `get-skill init [name]` | Create a `SKILL.md` from a template. |
-| `get-skill rules [id]` | List lint rules, or show one. |
-| `get-skill publish [path]` (`submit`) | Publish to the registry. Exits non-zero on lint errors. |
-| `get-skill login` / `logout` | Store or remove a token. |
-
-All commands accept `--json`.
+| `skillmd lint [path]` | Validate `SKILL.md` files; print diagnostics and a quality score. |
+| `skillmd scan [path]` | Report scripts, network calls, and secret access. |
+| `skillmd rules [id]` | List lint rules, or show one. |
+| `skillmd init [name]` | Create a `SKILL.md` from a template. |
+| `skillmd search <query>` | Search the registry. |
+| `skillmd info <slug>` | Show a skill's registry record: verification, security flags, provenance, rating. |
+| `skillmd add <source>` | Install a skill (registry slug, GitHub source, gist, or local path). Lints before writing. |
+| `skillmd list` (`ls`) | List installed skills with their scope, agents, link mode and source. |
+| `skillmd remove [names...]` (`rm`) | Remove installed skills, or unlink them from specific agents. |
+| `skillmd update [names...]` | Update installed skills from the source recorded in the lock file. |
+| `skillmd check [names...]` | Report which installed skills have updates (`update --check`). |
+| `skillmd publish [path]` (`submit`) | Publish to the registry. Exits non-zero on lint errors. |
+| `skillmd login` / `logout` | Store or remove a token. |
+
+> `check` is a command of its own since 1.2.0. It used to be an alias of `lint` — scripts that ran `skillmd check .` to validate a skill should now run `skillmd lint .`.
+
+### lint
+
+```bash
+skillmd lint ./my-skill
+skillmd lint . --format sarif > skillmd.sarif
+skillmd lint . --strict
+skillmd lint . --fix
+```
+
+Formats: `text` (default), `json`, `sarif` (GitHub Code Scanning), `github` (Actions annotations).
+Exit codes: `0` clean, `1` errors (or warnings with `--strict` / `--fail-on-warning`).
 
 ### add
 
 ```bash
-get-skill add anthropic/pdf                 # registry slug (verified-only by default)
-get-skill add owner/repo                    # GitHub repo
-get-skill add ./path                        # local
-get-skill add anthropic/pdf -a claude-code -g
-get-skill add some/skill --deny executes_scripts
-get-skill add some/skill --skip-lint
+skillmd add anthropic/pdf                      # registry slug
+skillmd add owner/repo                          # GitHub repo
+skillmd add owner/repo/skills/pdf#main          # a subfolder at a ref
+skillmd add owner/repo@pdf                      # one skill inside a repo or pack
+skillmd add https://github.com/owner/repo/tree/v2/skills/pdf
+skillmd add https://gist.github.com/user/0123456789abcdef
+skillmd add ./path                              # local directory
+skillmd add owner/repo --list                   # what's in there? install nothing
+skillmd add anthropic/pdf -a claude-code cursor -g
+skillmd add anthropic/pdf --mode copy           # no links; real files per agent
+skillmd add some/skill --deny executes_scripts
+skillmd add some/skill --skip-lint
 ```
 
-### lint
+Sources: a registry slug `owner/name`; a GitHub repo, subdirectory, ref (`#ref`) or named skill (`@skill`), including `tree/` and `blob/` URLs; `github:`/`gh:` to force the GitHub reading of a bare `owner/name`; a gist URL; or a local path. `--ref <ref>` overrides the ref on any GitHub source. GitLab and `git@` sources aren't supported — clone them and install from the path.
+
+**Where skills land.** One canonical copy, linked into each agent you chose:
+
+| Scope | Flag | Canonical copy | Agent links | Lock file |
+| --- | --- | --- | --- | --- |
+| **Project** | `-p`, `--project` | `.agents/skills/<name>` | `./<agent-dir>/skills/<name>` | `skills-lock.json` (commit it) |
+| **Global** | `-g`, `--global` | `~/.agents/skills/<name>` | `~/<agent-dir>/skills/<name>` | `~/.skillmd/lock.json` |
+
+Each agent link is a junction on Windows and a symlink elsewhere, so updating the canonical copy updates every agent at once; `--mode copy` writes real files instead. A project install only touches agents the project already uses (or the ones you name with `-a`), so `add -p` never invents a folder for an agent you don't run.
+
+In a terminal, `add` asks for the scope (**Project** / **Global**) and then which detected agents to link into, remembering your agent choice for next time. Off a terminal the scope is auto-detected — see [Non-interactive use](#non-interactive-use).
+
+Re-installing the same skill from the same source is fine. Replacing a skill that came from a *different* source, or a directory the lock file doesn't know about, needs `--force`.
+
+### list / remove / update / check
 
 ```bash
-get-skill lint ./my-skill
-get-skill lint . --format sarif > skillmd.sarif
-get-skill lint . --strict
-get-skill lint . --fix
+skillmd list                       # everything installed, project and global
+skillmd list -p -a claude-code     # just this project, just one agent
+skillmd remove pdf                 # unlink from every agent, delete the copy
+skillmd remove pdf -a cursor       # unlink from Cursor only; copy stays
+skillmd remove --all -g -y         # clear your user-level skills
+skillmd check                      # which skills have updates?
+skillmd update                     # refresh them from their recorded sources
+skillmd update pdf -g
 ```
 
-Formats: `text` (default), `json`, `sarif` (GitHub Code Scanning), `github` (Actions annotations).
-Exit codes: `0` clean, `1` errors (or warnings with `--strict` / `--fail-on-warning`), `2` usage error.
+`list` shows name · scope · agents · mode · source. Skills installed by hand or by an older CLI have no lock entry and are tagged `untracked`: `update` skips them and tells you to re-run `skillmd add` once to start tracking them.
+
+`update` re-fetches the full bundle from the source recorded in the lock file, re-lints it, and skips skills whose recorded commit hasn't moved. `check` is `update --check`: it reports and writes nothing.
+
+`remove` with no names opens a picker, and confirms before deleting unless you pass `-y`.
+
+### Non-interactive use
+
+Every command works without a terminal, and none of them will ever block on a prompt when there isn't one.
+
+```bash
+skillmd add anthropic/pdf -y --json
+skillmd list --json
+skillmd check --json
+```
+
+- **`--json` requires `-y`** on `add`, and prints exactly one document on stdout; human text and warnings go to stderr, so `skillmd add … --json | jq` is always valid JSON. The `add` document is `{ ok, scope, installed: [{ name, canonical, targets, skipped, digest }], blocked, warnings }`.
+- **Scope auto-detection.** With `-y`, `--json`, piped stdin, or inside a host agent (Claude Code, Cursor, Codex, Gemini CLI, or any CI), `add` picks **project** when the working directory carries `.git`, `package.json`, `pyproject.toml`, `Cargo.toml`, `go.mod`, `AGENTS.md`, `CLAUDE.md`, `skills-lock.json` or an agent dot-dir, and **global** otherwise. It says which it picked. Pass `-p` or `-g` to decide yourself.
+- **Piped with neither `-y` nor a scope flag exits 1** with a hint rather than guessing where to write.
+- **Exit codes.** `0` success; `1` anything that failed — lint errors, a blocked or denied skill, nothing removed, an update that couldn't be applied, or a prompt that was required but impossible. `login`, `logout` and `init` also exit 1 off a TTY, naming the flags to pass instead.
+- **Tokens.** Prefer `skillmd login` or `SKILLMD_TOKEN` over `--token`: a token on the command line is visible in your shell history and in every process listing on the machine, and the CLI warns about it. A stored token is bound to the API base it was saved for and is never sent anywhere else. An `http://` API base is refused unless you add `--insecure-http`.
+
+### What the CLI sends
+
+Installing a skill **from the registry** sends one fire-and-forget request so the skill's install count on skillmd.com stays accurate:
+
+```
+POST https://api.skillmd.com/api/skills/<owner>/<name>/install
+{"via":"cli"}
+```
+
+That is the whole payload — no identifiers, no paths, no machine information — and the install succeeds whether or not it goes through. Installs from GitHub, gists and local paths send nothing. To turn it off:
+
+```bash
+export SKILLMD_NO_TELEMETRY=1   # or the cross-tool DO_NOT_TRACK=1
+```
 
 ### publish
 
 ```bash
-get-skill login                # store a token from your skillmd.com account
-get-skill publish ./my-skill   # blocked on lint errors
-get-skill publish ./my-skill --dry-run
-get-skill publish ./my-skill --force   # publish despite warnings; never bypasses errors
+skillmd login                # store a token from your skillmd.com account
+skillmd publish ./my-skill   # blocked on lint errors
+skillmd publish ./my-skill --dry-run
+skillmd publish ./my-skill --force   # publish despite warnings; never bypasses errors
 ```
 
-## MCP server
+## MCP server: `get-skill`
 
 Claude Code:
 
@@ -102,12 +170,24 @@ Other MCP clients:
 }
 ```
 
-Tools: `skillmd_search`, `skillmd_get`, `skillmd_install`, `skillmd_trending`, `skillmd_recommend`, `skillmd_list_saved`, `skillmd_lint`. `skillmd_install` writes a skill's `SKILL.md` and never executes scripts.
+Tools: `skillmd_search`, `skillmd_get`, `skillmd_install`, `skillmd_trending`, `skillmd_recommend`, `skillmd_list_saved`, `skillmd_lint`.
+
+`skillmd_install` runs the same installer as the CLI — it validates the skill, writes one canonical copy and links it into the chosen agents — and takes `scope` (`project` | `global`), `agents`, `mode` (`link` | `copy`), `force` and `deny`. It never executes scripts. The old `dest` parameter is deprecated and is accepted only when it points at a known agent skills directory; use `scope` + `agents` instead.
+
+### Remote server (no install)
 
-The CLI and the registry validate `SKILL.md` with the same engine, so they apply identical rules.
+SkillMD also hosts a remote MCP server over streamable HTTP — point any client that supports remote servers at:
+
+```
+https://api.skillmd.com/mcp
+```
+
+No auth required. It exposes `skillmd_search`, `skillmd_get`, `skillmd_download`, `skillmd_trending`, and `skillmd_recommend` (`skillmd_download` returns file contents for the client to write, instead of writing to disk).
 
 ## Find skills on skillmd.com
 
+The registry behind these tools is [skillmd.com](https://skillmd.com): 1,000,000+ Agent Skills, each linted, security-scanned and content-pinned.
+
 - [Search all skills](https://skillmd.com/search) · [browse by category](https://skillmd.com/categories) · [by publisher](https://skillmd.com/publishers)
 - Install guides per agent: [Claude Code](https://skillmd.com/agents/claude-code) · [Cursor](https://skillmd.com/agents/cursor) · [Codex](https://skillmd.com/agents/codex) · [all 60+ agents](https://skillmd.com/agents)
 - [The SKILL.md format](https://skillmd.com/docs/format) · [CLI docs](https://skillmd.com/docs/cli) · [MCP docs](https://skillmd.com/docs/mcp) · [registry stats](https://skillmd.com/stats)
@@ -121,8 +201,8 @@ Resolution order, highest first:
 | Token | `--token` → `SKILLMD_TOKEN` → `~/.skillmd/config.json` |
 | API base | `--api` → `SKILLMD_API` → default registry |
 
-`SKILLMD_TOKEN` enables `skillmd_list_saved`, personalized recommendations, and publishing.
+`SKILLMD_TOKEN` enables `skillmd_list_saved`, personalized recommendations, and publishing. A stored token records the API base it belongs to and is only ever sent there. `SKILLMD_NO_TELEMETRY=1` (or `DO_NOT_TRACK=1`) disables the install-count ping described above.
 
 ## License
 
-MIT
+[MIT](https://github.com/skillmds/skillmd/blob/main/LICENSE)

package/bin/skillmd-mcp.mjs

@@ -1,331 +1,3 @@
 #!/usr/bin/env node
-// SkillMD MCP server (stdio). Wraps the public SkillMD API so any MCP-capable agent
-// can search, fetch, install, and discover Agent Skills by name or task.
-//
-//   claude mcp add skillmd -- npx -y skillmds
-//
-// Env:
-//   SKILLMD_API   override API base (default https://api.skillmd.com)
-//   SKILLMD_TOKEN  personal access token (enables skillmd_list_saved / personalized recommend)
-
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-import { mkdir, writeFile } from "node:fs/promises";
-import { readFileSync } from "node:fs";
-import { createHash } from "node:crypto";
-import { homedir } from "node:os";
-import { join, resolve, dirname, sep } from "node:path";
-import { stringify as stringifyYaml } from "yaml";
-
-const VERSION = (() => {
-  try {
-    return JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
-  } catch {
-    return "0.0.0";
-  }
-})();
-// Shared validation engine, bundled into ./vendor at publish time (npm run build).
-// Falls back gracefully if the vendor build is absent (e.g. running from source).
-let lint = null;
-try {
-  ({ lint } = await import("../vendor/index.js"));
-} catch {
-  /* skillmd_lint will report that validation is unavailable */
-}
-
-const API = process.env.SKILLMD_API || "https://api.skillmd.com";
-const TOKEN = process.env.SKILLMD_TOKEN || "";
-
-// Companion files not in R2 carry a registry-supplied source_url. Ingest only
-// pins these to GitHub raw hosts, so anything else is a hostile/compromised
-// registry response — refuse to fetch it (client-side SSRF guard).
-const ALLOWED_SOURCE_HOSTS = new Set(["raw.githubusercontent.com", "gist.githubusercontent.com"]);
-function isAllowedSourceUrl(u) {
-  try {
-    const parsed = new URL(u);
-    return parsed.protocol === "https:" && ALLOWED_SOURCE_HOSTS.has(parsed.hostname.toLowerCase());
-  } catch {
-    return false;
-  }
-}
-
-async function api(path, init = {}) {
-  const headers = { accept: "application/json", ...(init.headers || {}) };
-  if (TOKEN) headers.authorization = `Bearer ${TOKEN}`;
-  const res = await fetch(API + path, { ...init, headers });
-  if (!res.ok) throw new Error(`SkillMD API ${res.status} on ${path}: ${await res.text().catch(() => "")}`);
-  return res.json();
-}
-const text = (obj) => ({ content: [{ type: "text", text: typeof obj === "string" ? obj : JSON.stringify(obj, null, 2) }] });
-
-// The public API returns site-oriented fields (ratings, counters, avatars,
-// ranker internals) that are noise for an agent picking a skill. Strip them
-// from every list-returning tool so results stay compact and rankable only
-// on what matters to the caller.
-const OMIT_FIELDS = new Set([
-  "type",
-  "verified",
-  "avg_rating",
-  "rating_count",
-  "install_count",
-  "save_count",
-  "owner_avatar",
-  "confident",
-  "category_slug",
-]);
-const trimItems = (items) => (items ?? []).map((s) => Object.fromEntries(Object.entries(s).filter(([k]) => !OMIT_FIELDS.has(k))));
-
-const TOOLS = [
-  {
-    name: "skillmd_search",
-    description: "Search SkillMD for Agent Skills by name, description, or task. Returns matching skills with their owner/name slug and install snippets.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        query: { type: "string", description: "Natural-language query or keywords" },
-        category: { type: "string", description: "Filter by category slug (e.g. devops, data, security)" },
-        verified_only: { type: "boolean", description: "Only verified skills" },
-        type: { type: "string", enum: ["single", "pack"], description: "single file or pack" },
-        min_rating: { type: "number", description: "Minimum average rating 0-5" },
-        limit: { type: "number", description: "Max results (default 20)" },
-      },
-      required: ["query"],
-    },
-  },
-  {
-    name: "skillmd_get",
-    description: "Fetch a single skill by slug (owner/name), including its SKILL.md body, provenance, license and security flags.",
-    inputSchema: { type: "object", properties: { slug: { type: "string", description: "owner/name, e.g. anthropic/pdf" } }, required: ["slug"] },
-  },
-  {
-    name: "skillmd_install",
-    description:
-      "Install a skill by slug: writes its SKILL.md into the agent's skills directory. Never executes any scripts. Any skill installs; the response reports its security flags (docs_only / network_calls / executes_scripts / reads_secrets) as information.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        slug: { type: "string", description: "owner/name, e.g. anthropic/pdf" },
-        dest: { type: "string", description: "Target skills dir. Default ~/.claude/skills" },
-      },
-      required: ["slug"],
-    },
-  },
-  {
-    name: "skillmd_trending",
-    description: "Top skills on the SkillMD leaderboard. range: '30d' or 'all'.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        range: { type: "string", enum: ["30d", "all"], description: "Time window (default all)" },
-        category: { type: "string", description: "Optional category slug" },
-        limit: { type: "number", description: "Max results (default 20)" },
-      },
-    },
-  },
-  {
-    name: "skillmd_recommend",
-    description: "Recommend skills. If based_on is given, suggests skills similar to it (same category); otherwise returns trending.",
-    inputSchema: {
-      type: "object",
-      properties: { based_on: { type: "string", description: "A slug to base recommendations on" }, limit: { type: "number" } },
-    },
-  },
-  {
-    name: "skillmd_list_saved",
-    description: "List the signed-in user's saved skills. Requires SKILLMD_TOKEN to be set.",
-    inputSchema: { type: "object", properties: {} },
-  },
-  {
-    name: "skillmd_lint",
-    description:
-      "Validate a SKILL.md against the SkillMD spec and return diagnostics, security flags, and a quality score (0-100). Pass raw SKILL.md content, or a registry slug (owner/name) to fetch and lint.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        content: { type: "string", description: "Raw SKILL.md content to validate" },
-        slug: { type: "string", description: "Registry slug owner/name to fetch and validate" },
-      },
-    },
-  },
-];
-
-// KEEP IN SYNC with apps/cli/src/api.ts (reconstructSkillMd / skillMdFor) —
-// duplicated because the MCP bin ships as a standalone script; no automated
-// check enforces this.
-function reconstructSkillMd(skill) {
-  // Verbatim when the author shipped frontmatter; a frontmatter-less upstream
-  // SKILL.md gets the registry's name/description prepended so it parses.
-  if (skill.raw_md && /^\uFEFF?\s*---\r?\n/.test(skill.raw_md)) return skill.raw_md;
-  const fm = { name: skill.slug.split("/")[1] || skill.title, description: String(skill.description).replace(/\n/g, " ") };
-  if (skill.license) fm.license = skill.license;
-  return `---\n${stringifyYaml(fm)}---\n${skill.raw_md || skill.body_md || ""}`;
-}
-
-async function handleCall(name, args) {
-  switch (name) {
-    case "skillmd_search": {
-      const p = new URLSearchParams({ q: args.query, limit: String(args.limit ?? 20) });
-      if (args.category) p.set("category", args.category);
-      if (args.verified_only) p.set("verified", "true");
-      if (args.type) p.set("type", args.type);
-      if (args.min_rating != null) p.set("min_rating", String(args.min_rating));
-      const r = await api(`/api/search?${p}`);
-      return text(trimItems(r.items));
-    }
-    case "skillmd_get": {
-      const [owner, slugName] = String(args.slug).split("/");
-      const r = await api(`/api/skills/${owner}/${slugName}`);
-      return text(r);
-    }
-    case "skillmd_trending": {
-      const p = new URLSearchParams({ range: args.range ?? "all", limit: String(args.limit ?? 20) });
-      if (args.category) p.set("category", args.category);
-      const r = await api(`/api/leaderboard?${p}`);
-      return text(trimItems(r.items));
-    }
-    case "skillmd_recommend": {
-      if (args.based_on) {
-        const [owner, slugName] = String(args.based_on).split("/");
-        const base = await api(`/api/skills/${owner}/${slugName}`).catch(() => null);
-        if (base?.category_slug) {
-          const r = await api(`/api/leaderboard?range=all&limit=${args.limit ?? 10}&category=${base.category_slug}`);
-          return text(trimItems(r.items).filter((s) => s.slug !== args.based_on));
-        }
-      }
-      const r = await api(`/api/leaderboard?range=30d&limit=${args.limit ?? 10}`);
-      return text(trimItems(r.items));
-    }
-    case "skillmd_list_saved": {
-      if (!TOKEN) return text("Set SKILLMD_TOKEN (a SkillMD personal access token) to list your saved skills.");
-      const r = await api(`/api/favorites`);
-      return text(r.items ?? []);
-    }
-    case "skillmd_lint": {
-      if (!lint) return text("Validation engine unavailable — run `npm run build` in the skillmds package.");
-      let raw = args.content;
-      let slug;
-      let verified = false;
-      if (!raw && args.slug) {
-        const [owner, slugName] = String(args.slug).split("/");
-        const skill = await api(`/api/skills/${owner}/${slugName}`);
-        raw = reconstructSkillMd(skill);
-        slug = slugName;
-        verified = !!skill.verified;
-      }
-      if (!raw) return text("Provide `content` (raw SKILL.md) or `slug` (owner/name).");
-      const result = lint(raw, { ...(slug ? { slug } : {}), verified });
-      return text({ ok: result.ok, score: result.score, diagnostics: result.diagnostics, security: result.security });
-    }
-    case "skillmd_install": {
-      const [owner, slugName] = String(args.slug).split("/");
-      // Defense in depth: slugName becomes a directory name below — refuse
-      // anything outside the registry's slugify alphabet (path separators,
-      // "..", etc.) before touching the network or filesystem.
-      if (!/^[a-z0-9][a-z0-9-]*$/.test(slugName ?? "")) {
-        return text(`Refused: invalid skill name "${slugName}" — expected a lowercase slug.`);
-      }
-      const skill = await api(`/api/skills/${owner}/${slugName}`);
-      const flags = skill.security_flags ?? [];
-      // Verification never gates installs — any skill installs; flags are
-      // reported in the response as information, not a wall.
-      const raw = reconstructSkillMd(skill); // returns raw_md verbatim when the registry has it
-      if (lint) {
-        const result = lint(raw, { slug: slugName });
-        if (!result.ok) {
-          const errors = result.diagnostics.filter((d) => d.severity === "error");
-          return text(`Refused: ${args.slug} failed validation (${errors.map((d) => `${d.id}: ${d.message}`).join("; ")}). Not installed.`);
-        }
-      }
-      const baseDir = args.dest ? resolve(args.dest) : join(homedir(), ".claude", "skills");
-      const dir = join(baseDir, slugName);
-      await mkdir(dir, { recursive: true });
-      const root = resolve(dir);
-
-      // Zip-slip guard: refuse any path that resolves outside the skill's dir.
-      const writeSafe = async (relPath, contents) => {
-        const fp = resolve(dir, relPath);
-        if (fp !== root && !fp.startsWith(root + sep)) throw new Error(`unsafe path: ${relPath}`);
-        await mkdir(dirname(fp), { recursive: true });
-        await writeFile(fp, contents);
-      };
-
-      let written = 1;
-      let note = "";
-      if (skill.type === "pack") {
-        // Pull the full pack (SKILL.md + companion files) in one call. The JSON
-        // bundle avoids adding an unzip dependency to this standalone binary.
-        try {
-          const bundle = await api(`/api/skills/${owner}/${slugName}/bundle?format=json`);
-          // Resolve + integrity-check every file BEFORE writing any, so a
-          // tampered pack refuses cleanly instead of leaving a partial install.
-          const resolved = [];
-          for (const f of bundle.files ?? []) {
-            if (f.path.includes("..") || f.path.startsWith("/")) continue;
-            let buf;
-            if (f.content_base64 != null) {
-              buf = Buffer.from(f.content_base64, "base64");
-              // R2 files are content-addressed; verify the bytes match the
-              // registry's sha256. Files without one (the reconstructed inline
-              // SKILL.md) carry no hash and are skipped.
-              if (f.sha256) {
-                const got = createHash("sha256").update(buf).digest("hex");
-                if (got !== f.sha256) {
-                  const err = new Error(`integrity check failed for "${f.path}"`);
-                  err.integrity = true;
-                  throw err;
-                }
-              }
-            } else if (f.source_url && isAllowedSourceUrl(f.source_url)) {
-              const r = await fetch(f.source_url).catch(() => null);
-              if (!r || !r.ok) continue;
-              buf = Buffer.from(await r.arrayBuffer());
-            } else continue;
-            resolved.push({ path: f.path, contents: f.path === "SKILL.md" ? raw : buf });
-          }
-          for (const f of resolved) await writeSafe(f.path, f.contents);
-          written = resolved.length || 1;
-          if (!resolved.some((f) => f.path === "SKILL.md")) await writeSafe("SKILL.md", raw);
-        } catch (e) {
-          if (e && e.integrity) return text(`Refused: ${args.slug} failed integrity verification — ${e.message}. Not installed.`);
-          await writeSafe("SKILL.md", raw);
-          note = ` NOTE: pack assets could not be fetched — only SKILL.md was written. For the full pack run: npx skillmds add ${args.slug}`;
-        }
-      } else {
-        await writeSafe("SKILL.md", raw);
-      }
-      api(`/api/skills/${owner}/${slugName}/install`, { method: "POST", body: JSON.stringify({ via: "mcp" }) }).catch(() => {});
-      return text(`Installed ${args.slug} → ${dir} (${written} file${written === 1 ? "" : "s"}; security: ${flags.join(", ") || "unscanned"})${note}`);
-    }
-    default:
-      throw new Error(`Unknown tool: ${name}`);
-  }
-}
-
-async function startMcpServer() {
-  const server = new Server({ name: "skillmd", version: VERSION }, { capabilities: { tools: {} } });
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
-  server.setRequestHandler(CallToolRequestSchema, async (req) => {
-    try {
-      return await handleCall(req.params.name, req.params.arguments ?? {});
-    } catch (e) {
-      return { isError: true, content: [{ type: "text", text: String(e?.message || e) }] };
-    }
-  });
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-  console.error("skillmd MCP server running (stdio)");
-}
-
-// This binary is invoked three ways:
-//   - `skillmds <anything>`       → run the CLI. commander owns argv, so known
-//     commands run and unknown commands get a proper "unknown command" error
-//     instead of silently starting an MCP server.
-//   - `skillmds` in a terminal    → run the CLI (opens the interactive menu)
-//   - `skillmds` over piped stdio → start the MCP server (how MCP clients launch it;
-//     they always connect stdin as a pipe, never a TTY, and pass no args)
-if (process.argv.length > 2 || process.stdin.isTTY) {
-  await import("../dist/cli.js"); // the CLI parses process.argv itself
-} else {
-  await startMcpServer();
-}
+// SkillMD MCP server (stdio) + CLI dispatch. Source: src/mcp/index.ts.
+import("../dist/mcp.js");

package/bin/skillmd.mjs

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
-// The `skillmd` CLI, shipped inside the `skillmds` package.
+// The `skillmd` CLI, shipped inside the `get-skill` package.
 import("../dist/cli.js");