@morphllm/morph-setup 1.0.0

package/README.md

@@ -0,0 +1,33 @@
+# @morphllm/morph-setup
+
+One-line installer for Morph MCP and bundled skills.
+
+## Install
+
+```bash
+npx -y @morphllm/morph-setup
+```
+
+The CLI will guide you through selecting which apps to install to.
+
+### With API Key
+
+```bash
+npx -y @morphllm/morph-setup --morph-api-key <your-key>
+```
+
+Or set the environment variable:
+
+```bash
+MORPH_API_KEY=<your-key> npx -y @morphllm/morph-setup
+```
+
+### Non-interactive
+
+```bash
+npx -y @morphllm/morph-setup -y
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,1107 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import chalk from "chalk";
+import * as p from "@clack/prompts";
+import path3 from "path";
+import { fileURLToPath } from "url";
+import { createRequire } from "module";
+
+// src/source-parser.ts
+import { isAbsolute, resolve } from "path";
+function isLocalPath(input) {
+  return isAbsolute(input) || input.startsWith("./") || input.startsWith("../") || input === "." || input === ".." || // Windows absolute paths like C:\ or D:\
+  /^[a-zA-Z]:[/\\]/.test(input);
+}
+function isDirectSkillUrl(input) {
+  if (!input.startsWith("http://") && !input.startsWith("https://")) {
+    return false;
+  }
+  if (!input.toLowerCase().endsWith("/skill.md")) {
+    return false;
+  }
+  if (input.includes("github.com/") && !input.includes("raw.githubusercontent.com")) {
+    if (!input.includes("/blob/") && !input.includes("/raw/")) {
+      return false;
+    }
+  }
+  if (input.includes("gitlab.com/") && !input.includes("/-/raw/")) {
+    return false;
+  }
+  return true;
+}
+function parseSource(input) {
+  if (isLocalPath(input)) {
+    const resolvedPath = resolve(input);
+    return {
+      type: "local",
+      url: resolvedPath,
+      // Store resolved path in url for consistency
+      localPath: resolvedPath
+    };
+  }
+  if (isDirectSkillUrl(input)) {
+    return {
+      type: "direct-url",
+      url: input
+    };
+  }
+  const githubTreeWithPathMatch = input.match(/github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)\/(.+)/);
+  if (githubTreeWithPathMatch) {
+    const [, owner, repo, ref, subpath] = githubTreeWithPathMatch;
+    return {
+      type: "github",
+      url: `https://github.com/${owner}/${repo}.git`,
+      ref,
+      subpath
+    };
+  }
+  const githubTreeMatch = input.match(/github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)$/);
+  if (githubTreeMatch) {
+    const [, owner, repo, ref] = githubTreeMatch;
+    return {
+      type: "github",
+      url: `https://github.com/${owner}/${repo}.git`,
+      ref
+    };
+  }
+  const githubRepoMatch = input.match(/github\.com\/([^/]+)\/([^/]+)/);
+  if (githubRepoMatch) {
+    const [, owner, repo] = githubRepoMatch;
+    const cleanRepo = repo.replace(/\.git$/, "");
+    return {
+      type: "github",
+      url: `https://github.com/${owner}/${cleanRepo}.git`
+    };
+  }
+  const gitlabTreeWithPathMatch = input.match(
+    /gitlab\.com\/([^/]+)\/([^/]+)\/-\/tree\/([^/]+)\/(.+)/
+  );
+  if (gitlabTreeWithPathMatch) {
+    const [, owner, repo, ref, subpath] = gitlabTreeWithPathMatch;
+    return {
+      type: "gitlab",
+      url: `https://gitlab.com/${owner}/${repo}.git`,
+      ref,
+      subpath
+    };
+  }
+  const gitlabTreeMatch = input.match(/gitlab\.com\/([^/]+)\/([^/]+)\/-\/tree\/([^/]+)$/);
+  if (gitlabTreeMatch) {
+    const [, owner, repo, ref] = gitlabTreeMatch;
+    return {
+      type: "gitlab",
+      url: `https://gitlab.com/${owner}/${repo}.git`,
+      ref
+    };
+  }
+  const gitlabRepoMatch = input.match(/gitlab\.com\/([^/]+)\/([^/]+)/);
+  if (gitlabRepoMatch) {
+    const [, owner, repo] = gitlabRepoMatch;
+    const cleanRepo = repo.replace(/\.git$/, "");
+    return {
+      type: "gitlab",
+      url: `https://gitlab.com/${owner}/${cleanRepo}.git`
+    };
+  }
+  const shorthandMatch = input.match(/^([^/]+)\/([^/]+)(?:\/(.+))?$/);
+  if (shorthandMatch && !input.includes(":") && !input.startsWith(".") && !input.startsWith("/")) {
+    const [, owner, repo, subpath] = shorthandMatch;
+    return {
+      type: "github",
+      url: `https://github.com/${owner}/${repo}.git`,
+      subpath
+    };
+  }
+  return {
+    type: "git",
+    url: input
+  };
+}
+
+// src/git.ts
+import simpleGit from "simple-git";
+import { join, normalize, resolve as resolve2, sep } from "path";
+import { mkdtemp, rm } from "fs/promises";
+import { tmpdir } from "os";
+async function cloneRepo(url, ref) {
+  const tempDir = await mkdtemp(join(tmpdir(), "add-skill-"));
+  const git = simpleGit();
+  const cloneOptions = ref ? ["--depth", "1", "--branch", ref] : ["--depth", "1"];
+  await git.clone(url, tempDir, cloneOptions);
+  return tempDir;
+}
+async function cleanupTempDir(dir) {
+  const normalizedDir = normalize(resolve2(dir));
+  const normalizedTmpDir = normalize(resolve2(tmpdir()));
+  if (!normalizedDir.startsWith(normalizedTmpDir + sep) && normalizedDir !== normalizedTmpDir) {
+    throw new Error("Attempted to clean up directory outside of temp directory");
+  }
+  await rm(dir, { recursive: true, force: true });
+}
+
+// src/skills.ts
+import { readdir, readFile, stat } from "fs/promises";
+import { join as join2, basename, dirname } from "path";
+import matter from "gray-matter";
+var SKIP_DIRS = ["node_modules", ".git", "dist", "build", "__pycache__"];
+async function hasSkillMd(dir) {
+  try {
+    const skillPath = join2(dir, "SKILL.md");
+    const stats = await stat(skillPath);
+    return stats.isFile();
+  } catch {
+    return false;
+  }
+}
+async function parseSkillMd(skillMdPath) {
+  try {
+    const content = await readFile(skillMdPath, "utf-8");
+    const { data } = matter(content);
+    if (!data.name || !data.description) {
+      return null;
+    }
+    return {
+      name: data.name,
+      description: data.description,
+      path: dirname(skillMdPath),
+      rawContent: content,
+      metadata: data.metadata
+    };
+  } catch {
+    return null;
+  }
+}
+async function findSkillDirs(dir, depth = 0, maxDepth = 5) {
+  const skillDirs = [];
+  if (depth > maxDepth) return skillDirs;
+  try {
+    if (await hasSkillMd(dir)) {
+      skillDirs.push(dir);
+    }
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if ((entry.isDirectory() || entry.isSymbolicLink()) && !SKIP_DIRS.includes(entry.name)) {
+        const subDirs = await findSkillDirs(join2(dir, entry.name), depth + 1, maxDepth);
+        skillDirs.push(...subDirs);
+      }
+    }
+  } catch {
+  }
+  return skillDirs;
+}
+async function discoverSkills(basePath, subpath) {
+  const skills = [];
+  const seenNames = /* @__PURE__ */ new Set();
+  const searchPath = subpath ? join2(basePath, subpath) : basePath;
+  if (await hasSkillMd(searchPath)) {
+    const skill = await parseSkillMd(join2(searchPath, "SKILL.md"));
+    if (skill) {
+      skills.push(skill);
+      return skills;
+    }
+  }
+  const prioritySearchDirs = [
+    searchPath,
+    join2(searchPath, "skills"),
+    join2(searchPath, "skills/.curated"),
+    join2(searchPath, "skills/.experimental"),
+    join2(searchPath, "skills/.system"),
+    join2(searchPath, ".agent/skills"),
+    join2(searchPath, ".agents/skills"),
+    join2(searchPath, ".claude/skills"),
+    join2(searchPath, ".cline/skills"),
+    join2(searchPath, ".codex/skills"),
+    join2(searchPath, ".commandcode/skills"),
+    join2(searchPath, ".cursor/skills"),
+    join2(searchPath, ".github/skills"),
+    join2(searchPath, ".goose/skills"),
+    join2(searchPath, ".kilocode/skills"),
+    join2(searchPath, ".kiro/skills"),
+    join2(searchPath, ".neovate/skills"),
+    join2(searchPath, ".opencode/skills"),
+    join2(searchPath, ".openhands/skills"),
+    join2(searchPath, ".pi/skills"),
+    join2(searchPath, ".qoder/skills"),
+    join2(searchPath, ".roo/skills"),
+    join2(searchPath, ".trae/skills"),
+    join2(searchPath, ".windsurf/skills"),
+    join2(searchPath, ".zencoder/skills")
+  ];
+  for (const dir of prioritySearchDirs) {
+    try {
+      const entries = await readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory() || entry.isSymbolicLink()) {
+          const skillDir = join2(dir, entry.name);
+          if (await hasSkillMd(skillDir)) {
+            const skill = await parseSkillMd(join2(skillDir, "SKILL.md"));
+            if (skill && !seenNames.has(skill.name)) {
+              skills.push(skill);
+              seenNames.add(skill.name);
+            }
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  if (skills.length === 0) {
+    const allSkillDirs = await findSkillDirs(searchPath);
+    for (const skillDir of allSkillDirs) {
+      const skill = await parseSkillMd(join2(skillDir, "SKILL.md"));
+      if (skill && !seenNames.has(skill.name)) {
+        skills.push(skill);
+        seenNames.add(skill.name);
+      }
+    }
+  }
+  return skills;
+}
+function getSkillDisplayName(skill) {
+  return skill.name || basename(skill.path);
+}
+
+// src/installer.ts
+import { mkdir, cp, readdir as readdir2, symlink, lstat, rm as rm2, readlink, writeFile } from "fs/promises";
+import { join as join4, basename as basename2, normalize as normalize2, resolve as resolve3, sep as sep2, relative } from "path";
+import { homedir as homedir2, platform } from "os";
+
+// src/agents.ts
+import { homedir } from "os";
+import { join as join3 } from "path";
+import { existsSync } from "fs";
+var home = homedir();
+var agents = {
+  amp: {
+    name: "amp",
+    displayName: "Amp",
+    skillsDir: ".agents/skills",
+    globalSkillsDir: join3(home, ".config/agents/skills"),
+    detectInstalled: async () => {
+      return existsSync(join3(home, ".config/amp"));
+    }
+  },
+  antigravity: {
+    name: "antigravity",
+    displayName: "Antigravity",
+    skillsDir: ".agent/skills",
+    globalSkillsDir: join3(home, ".gemini/antigravity/skills"),
+    detectInstalled: async () => {
+      return existsSync(join3(process.cwd(), ".agent")) || existsSync(join3(home, ".gemini/antigravity"));
+    }
+  },
+  "claude-code": {
+    name: "claude-code",
+    displayName: "Claude Code",
+    skillsDir: ".claude/skills",
+    globalSkillsDir: join3(home, ".claude/skills"),
+    detectInstalled: async () => {
+      return existsSync(join3(home, ".claude"));
+    }
+  },
+  codex: {
+    name: "codex",
+    displayName: "Codex",
+    skillsDir: ".codex/skills",
+    globalSkillsDir: join3(home, ".codex/skills"),
+    detectInstalled: async () => {
+      return existsSync(join3(home, ".codex"));
+    }
+  },
+  cursor: {
+    name: "cursor",
+    displayName: "Cursor",
+    skillsDir: ".cursor/skills",
+    globalSkillsDir: join3(home, ".cursor/skills"),
+    detectInstalled: async () => {
+      return existsSync(join3(home, ".cursor"));
+    }
+  },
+  opencode: {
+    name: "opencode",
+    displayName: "OpenCode",
+    skillsDir: ".opencode/skills",
+    globalSkillsDir: join3(home, ".config/opencode/skills"),
+    detectInstalled: async () => {
+      return existsSync(join3(home, ".config/opencode")) || existsSync(join3(home, ".claude/skills"));
+    }
+  },
+  windsurf: {
+    name: "windsurf",
+    displayName: "Windsurf",
+    skillsDir: ".windsurf/skills",
+    globalSkillsDir: join3(home, ".codeium/windsurf/skills"),
+    detectInstalled: async () => {
+      return existsSync(join3(home, ".codeium/windsurf"));
+    }
+  }
+};
+async function detectInstalledAgents() {
+  const installed = [];
+  for (const [type, config] of Object.entries(agents)) {
+    if (await config.detectInstalled()) {
+      installed.push(type);
+    }
+  }
+  return installed;
+}
+
+// src/installer.ts
+var AGENTS_DIR = ".agents";
+var SKILLS_SUBDIR = "skills";
+var AGENTS_THAT_SHOULD_NOT_GET_SYMLINKS = /* @__PURE__ */ new Set(["cursor"]);
+function sanitizeName(name) {
+  let sanitized = name.replace(/[\/\\:\0]/g, "");
+  sanitized = sanitized.replace(/^[.\s]+|[.\s]+$/g, "");
+  sanitized = sanitized.replace(/^\.+/, "");
+  if (!sanitized || sanitized.length === 0) {
+    sanitized = "unnamed-skill";
+  }
+  if (sanitized.length > 255) {
+    sanitized = sanitized.substring(0, 255);
+  }
+  return sanitized;
+}
+function isPathSafe(basePath, targetPath) {
+  const normalizedBase = normalize2(resolve3(basePath));
+  const normalizedTarget = normalize2(resolve3(targetPath));
+  return normalizedTarget.startsWith(normalizedBase + sep2) || normalizedTarget === normalizedBase;
+}
+function getCanonicalSkillsDir(global, cwd) {
+  const baseDir = global ? homedir2() : cwd || process.cwd();
+  return join4(baseDir, AGENTS_DIR, SKILLS_SUBDIR);
+}
+async function createSymlink(target, linkPath) {
+  try {
+    try {
+      const stats = await lstat(linkPath);
+      if (stats.isSymbolicLink()) {
+        const existingTarget = await readlink(linkPath);
+        if (resolve3(existingTarget) === resolve3(target)) {
+          return true;
+        }
+        await rm2(linkPath);
+      } else {
+        await rm2(linkPath, { recursive: true });
+      }
+    } catch (err) {
+      if (err && typeof err === "object" && "code" in err && err.code === "ELOOP") {
+        try {
+          await rm2(linkPath, { force: true });
+        } catch {
+        }
+      }
+    }
+    const linkDir = join4(linkPath, "..");
+    await mkdir(linkDir, { recursive: true });
+    const relativePath = relative(linkDir, target);
+    const symlinkType = platform() === "win32" ? "junction" : void 0;
+    await symlink(relativePath, linkPath, symlinkType);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function installSkillForAgent(skill, agentType, options = {}) {
+  const agent = agents[agentType];
+  const isGlobal = options.global ?? false;
+  const cwd = options.cwd || process.cwd();
+  const rawSkillName = skill.name || basename2(skill.path);
+  const skillName = sanitizeName(rawSkillName);
+  const canonicalBase = getCanonicalSkillsDir(isGlobal, cwd);
+  const canonicalDir = join4(canonicalBase, skillName);
+  const agentBase = isGlobal ? agent.globalSkillsDir : join4(cwd, agent.skillsDir);
+  const agentDir = join4(agentBase, skillName);
+  const installMode = options.mode ?? "symlink";
+  if (!isPathSafe(canonicalBase, canonicalDir)) {
+    return {
+      success: false,
+      path: agentDir,
+      mode: installMode,
+      error: "Invalid skill name: potential path traversal detected"
+    };
+  }
+  if (!isPathSafe(agentBase, agentDir)) {
+    return {
+      success: false,
+      path: agentDir,
+      mode: installMode,
+      error: "Invalid skill name: potential path traversal detected"
+    };
+  }
+  try {
+    if (installMode === "copy") {
+      await mkdir(agentDir, { recursive: true });
+      await copyDirectory(skill.path, agentDir);
+      return {
+        success: true,
+        path: agentDir,
+        mode: "copy"
+      };
+    }
+    await mkdir(canonicalDir, { recursive: true });
+    await copyDirectory(skill.path, canonicalDir);
+    const symlinkCreated = AGENTS_THAT_SHOULD_NOT_GET_SYMLINKS.has(agentType) ? false : await createSymlink(canonicalDir, agentDir);
+    if (!symlinkCreated) {
+      try {
+        await rm2(agentDir, { recursive: true, force: true });
+      } catch {
+      }
+      await mkdir(agentDir, { recursive: true });
+      await copyDirectory(skill.path, agentDir);
+      return {
+        success: true,
+        path: agentDir,
+        canonicalPath: canonicalDir,
+        mode: "symlink",
+        symlinkFailed: true
+      };
+    }
+    return {
+      success: true,
+      path: agentDir,
+      canonicalPath: canonicalDir,
+      mode: "symlink"
+    };
+  } catch (error) {
+    return {
+      success: false,
+      path: agentDir,
+      mode: installMode,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+var EXCLUDE_FILES = /* @__PURE__ */ new Set(["README.md", "metadata.json"]);
+var isExcluded = (name) => {
+  if (EXCLUDE_FILES.has(name)) return true;
+  if (name.startsWith("_")) return true;
+  return false;
+};
+async function copyDirectory(src, dest) {
+  await mkdir(dest, { recursive: true });
+  const entries = await readdir2(src, { withFileTypes: true });
+  for (const entry of entries) {
+    if (isExcluded(entry.name)) {
+      continue;
+    }
+    const srcPath = join4(src, entry.name);
+    const destPath = join4(dest, entry.name);
+    if (entry.isDirectory()) {
+      await copyDirectory(srcPath, destPath);
+    } else {
+      await cp(srcPath, destPath);
+    }
+  }
+}
+async function isSkillInstalled(skillName, agentType, options = {}) {
+  const agent = agents[agentType];
+  const sanitized = sanitizeName(skillName);
+  const targetBase = options.global ? agent.globalSkillsDir : join4(options.cwd || process.cwd(), agent.skillsDir);
+  const skillDir = join4(targetBase, sanitized);
+  if (!isPathSafe(targetBase, skillDir)) {
+    return false;
+  }
+  try {
+    const st = await lstat(skillDir);
+    if (AGENTS_THAT_SHOULD_NOT_GET_SYMLINKS.has(agentType) && st.isSymbolicLink()) {
+      return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/mcp-install.ts
+import fs from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import path2 from "path";
+import JSON5 from "json5";
+import { execFile } from "child_process";
+import { promisify } from "util";
+
+// src/mcp-client-paths.ts
+import { homedir as homedir3, platform as platform2 } from "os";
+import path from "path";
+function expandHome(p2) {
+  if (p2.startsWith("~/") || p2 === "~") {
+    return path.join(homedir3(), p2.slice(1));
+  }
+  return p2;
+}
+function getWindsurfConfigPath() {
+  const os = platform2();
+  if (os === "darwin" || os === "linux") {
+    return expandHome("~/.codeium/windsurf/mcp_config.json");
+  }
+  if (os === "win32") {
+    const appData = process.env.APPDATA;
+    if (!appData) return null;
+    return path.join(appData, "Codeium", "Windsurf", "mcp_config.json");
+  }
+  return null;
+}
+function getClaudeCodeUserConfigPath() {
+  return path.join(homedir3(), ".claude.json");
+}
+function getAmpSettingsPath() {
+  const os = platform2();
+  if (os === "darwin" || os === "linux") {
+    return path.join(homedir3(), ".config", "amp", "settings.json");
+  }
+  if (os === "win32") {
+    return path.join(homedir3(), ".config", "amp", "settings.json");
+  }
+  return null;
+}
+function getAntigravityMcpConfigPath() {
+  return path.join(homedir3(), ".gemini", "antigravity", "mcp_config.json");
+}
+function getCodexConfigTomlPath() {
+  return path.join(homedir3(), ".codex", "config.toml");
+}
+var MCP_CLIENT_SPECS = {
+  amp: {
+    id: "amp",
+    label: "Amp",
+    getPaths: () => ({ userConfigPath: getAmpSettingsPath() })
+  },
+  antigravity: {
+    id: "antigravity",
+    label: "Antigravity",
+    getPaths: () => ({ userConfigPath: getAntigravityMcpConfigPath() })
+  },
+  codex: {
+    id: "codex",
+    label: "Codex",
+    getPaths: () => ({ userConfigPath: getCodexConfigTomlPath() })
+  },
+  opencode: {
+    id: "opencode",
+    label: "OpenCode",
+    getPaths: () => ({ userConfigPath: expandHome("~/.config/opencode/opencode.json") })
+  },
+  cursor: {
+    id: "cursor",
+    label: "Cursor",
+    getPaths: () => ({ userConfigPath: expandHome("~/.cursor/mcp.json") })
+  },
+  "claude-code": {
+    id: "claude-code",
+    label: "Claude Code",
+    getPaths: () => ({ userConfigPath: getClaudeCodeUserConfigPath() })
+  },
+  windsurf: {
+    id: "windsurf",
+    label: "Windsurf",
+    getPaths: () => ({ userConfigPath: getWindsurfConfigPath() })
+  }
+};
+
+// src/mcp-install.ts
+var execFileAsync = promisify(execFile);
+function isObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+async function ensureDirForFile(filePath) {
+  await fs.mkdir(path2.dirname(filePath), { recursive: true });
+}
+async function readJsonish(filePath) {
+  const raw = await fs.readFile(filePath, "utf-8");
+  if (raw.trim().length === 0) return null;
+  return JSON5.parse(raw);
+}
+async function writeJson(filePath, data) {
+  await ensureDirForFile(filePath);
+  await fs.writeFile(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+function tomlEscapeString(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
+}
+function buildCodexMorphBlock(input) {
+  const lines = [];
+  lines.push("[mcp_servers.morph-mcp]");
+  lines.push('command = "npx"');
+  lines.push('args = ["-y", "@morphllm/morphmcp"]');
+  lines.push("enabled = true");
+  const env = [];
+  if (input.apiKey) env.push(`MORPH_API_KEY = "${tomlEscapeString(input.apiKey)}"`);
+  if (input.enabledTools) env.push(`ENABLED_TOOLS = "${tomlEscapeString(input.enabledTools)}"`);
+  if (env.length > 0) {
+    lines.push(`env = { ${env.join(", ")} }`);
+  }
+  return lines;
+}
+async function installToCodexConfigToml(configPath, input) {
+  let raw = "";
+  try {
+    raw = await fs.readFile(configPath, "utf-8");
+  } catch (err) {
+    const code = err?.code;
+    if (code !== "ENOENT") throw err;
+  }
+  const existingLines = raw.length > 0 ? raw.split(/\r?\n/) : [];
+  const blockLines = buildCodexMorphBlock(input);
+  const header = "[mcp_servers.morph-mcp]";
+  const start = existingLines.findIndex((l) => l.trim() === header);
+  let nextLines;
+  if (start >= 0) {
+    let end = start + 1;
+    while (end < existingLines.length && !/^\s*\[/.test(existingLines[end])) end++;
+    nextLines = [
+      ...existingLines.slice(0, start),
+      ...blockLines,
+      ...existingLines.slice(end)
+    ];
+  } else {
+    nextLines = existingLines.slice();
+    if (nextLines.length > 0 && nextLines[nextLines.length - 1]?.trim() !== "") {
+      nextLines.push("");
+    }
+    nextLines.push(...blockLines);
+  }
+  const out = nextLines.join("\n").replace(/\n*$/, "\n");
+  await ensureDirForFile(configPath);
+  await fs.writeFile(configPath, out, "utf-8");
+}
+function mergeMorphEnv(existing, input) {
+  const existingEnv = existing && isObject(existing.env) ? existing.env : void 0;
+  const env = {};
+  if (existingEnv) {
+    for (const [k, v] of Object.entries(existingEnv)) {
+      if (typeof v === "string") env[k] = v;
+    }
+  }
+  if (input.apiKey) env.MORPH_API_KEY = input.apiKey;
+  if (input.enabledTools) env.ENABLED_TOOLS = input.enabledTools;
+  return Object.keys(env).length > 0 ? env : void 0;
+}
+async function installToMcpServersJson(configPath, input, options) {
+  const key = options?.key ?? "morph-mcp";
+  let data;
+  try {
+    data = await readJsonish(configPath) ?? { mcpServers: {} };
+  } catch (err) {
+    const code = err?.code;
+    if (code === "ENOENT") {
+      data = { mcpServers: {} };
+    } else {
+      throw err;
+    }
+  }
+  const obj = isObject(data) ? data : {};
+  if (!isObject(obj.mcpServers)) obj.mcpServers = {};
+  const servers = obj.mcpServers;
+  const existing = isObject(servers[key]) ? servers[key] : void 0;
+  const env = mergeMorphEnv(existing, input);
+  servers[key] = {
+    ...existing ?? {},
+    command: "npx",
+    args: ["-y", "@morphllm/morphmcp"],
+    ...env ? { env } : {}
+  };
+  await writeJson(configPath, obj);
+}
+async function installToClaudeCodeUserConfig(configPath, input) {
+  let data;
+  try {
+    data = await readJsonish(configPath) ?? { mcpServers: {} };
+  } catch (err) {
+    const code = err?.code;
+    if (code === "ENOENT") {
+      data = { mcpServers: {} };
+    } else {
+      throw err;
+    }
+  }
+  const obj = isObject(data) ? data : {};
+  if (!isObject(obj.mcpServers)) obj.mcpServers = {};
+  const servers = obj.mcpServers;
+  const key = "morph-mcp";
+  const existing = isObject(servers[key]) ? servers[key] : void 0;
+  const env = mergeMorphEnv(existing, input);
+  servers[key] = {
+    ...existing ?? {},
+    type: "stdio",
+    command: "npx",
+    args: ["-y", "@morphllm/morphmcp"],
+    ...env ? { env } : {}
+  };
+  await writeJson(configPath, obj);
+}
+async function installToOpenCodeConfig(configPath, input) {
+  let data;
+  try {
+    data = await readJsonish(configPath) ?? {};
+  } catch (err) {
+    const code = err?.code;
+    if (code === "ENOENT") {
+      data = {};
+    } else {
+      throw err;
+    }
+  }
+  const obj = isObject(data) ? data : {};
+  if (!isObject(obj.mcp)) obj.mcp = {};
+  const mcp = obj.mcp;
+  const key = "morph-mcp";
+  const existing = isObject(mcp[key]) ? mcp[key] : void 0;
+  const existingEnv = existing && isObject(existing.environment) ? existing.environment : void 0;
+  const environment = {};
+  if (existingEnv) {
+    for (const [k, v] of Object.entries(existingEnv)) {
+      if (typeof v === "string") environment[k] = v;
+    }
+  }
+  if (input.apiKey) environment.MORPH_API_KEY = input.apiKey;
+  if (input.enabledTools) environment.ENABLED_TOOLS = input.enabledTools;
+  mcp[key] = {
+    ...existing ?? {},
+    type: "local",
+    command: ["npx", "-y", "@morphllm/morphmcp"],
+    enabled: true,
+    ...Object.keys(environment).length > 0 ? { environment } : {}
+  };
+  await writeJson(configPath, obj);
+}
+async function tryAmpCliAddMorphMcp() {
+  try {
+    await execFileAsync("amp", ["mcp", "add", "morph-mcp", "--", "npx", "-y", "@morphllm/morphmcp"], {
+      windowsHide: true
+    });
+  } catch {
+  }
+}
+async function installToAmpSettings(configPath, input) {
+  await tryAmpCliAddMorphMcp();
+  let data;
+  try {
+    data = await readJsonish(configPath) ?? {};
+  } catch (err) {
+    const code = err?.code;
+    if (code === "ENOENT") {
+      data = {};
+    } else {
+      throw err;
+    }
+  }
+  const obj = isObject(data) ? data : {};
+  const key = "amp.mcpServers";
+  if (!isObject(obj[key])) obj[key] = {};
+  const servers = obj[key];
+  const serverKey = "morph-mcp";
+  const existing = isObject(servers[serverKey]) ? servers[serverKey] : void 0;
+  const env = mergeMorphEnv(existing, input);
+  servers[serverKey] = {
+    ...existing ?? {},
+    command: "npx",
+    args: ["-y", "@morphllm/morphmcp"],
+    ...env ? { env } : {}
+  };
+  await writeJson(configPath, obj);
+}
+function getMcpClientConfigPath(client) {
+  return MCP_CLIENT_SPECS[client].getPaths().userConfigPath;
+}
+function listSupportedMcpClients() {
+  return Object.keys(MCP_CLIENT_SPECS).map((id) => ({
+    id,
+    label: MCP_CLIENT_SPECS[id].label,
+    configPath: getMcpClientConfigPath(id)
+  }));
+}
+function detectMcpClients() {
+  const detected = [];
+  for (const id of Object.keys(MCP_CLIENT_SPECS)) {
+    const configPath = getMcpClientConfigPath(id);
+    if (!configPath) continue;
+    if (existsSync2(path2.dirname(configPath))) detected.push(id);
+  }
+  return detected;
+}
+async function installMorphMcpToClient(client, input) {
+  const configPath = getMcpClientConfigPath(client);
+  if (!configPath) {
+    return { success: false, client, error: "Unsupported on this OS (no config path)." };
+  }
+  try {
+    switch (client) {
+      case "amp":
+        await installToAmpSettings(configPath, input);
+        break;
+      case "antigravity":
+      case "cursor":
+      case "windsurf":
+        await installToMcpServersJson(configPath, input);
+        break;
+      case "claude-code":
+        await installToClaudeCodeUserConfig(configPath, input);
+        break;
+      case "opencode":
+        await installToOpenCodeConfig(configPath, input);
+        break;
+      case "codex":
+        await installToCodexConfigToml(configPath, input);
+        break;
+    }
+    return { success: true, client, configPath };
+  } catch (err) {
+    return {
+      success: false,
+      client,
+      configPath,
+      error: err instanceof Error ? err.message : "Unknown error"
+    };
+  }
+}
+
+// src/telemetry.ts
+var TELEMETRY_URL = "https://add-skill.vercel.sh/t";
+var cliVersion = null;
+function isCI() {
+  return !!(process.env.CI || process.env.GITHUB_ACTIONS || process.env.GITLAB_CI || process.env.CIRCLECI || process.env.TRAVIS || process.env.BUILDKITE || process.env.JENKINS_URL || process.env.TEAMCITY_VERSION);
+}
+function isEnabled() {
+  return !process.env.DISABLE_TELEMETRY && !process.env.DO_NOT_TRACK;
+}
+function setVersion(version) {
+  cliVersion = version;
+}
+function track(data) {
+  if (!isEnabled()) return;
+  try {
+    const params = new URLSearchParams();
+    if (cliVersion) {
+      params.set("v", cliVersion);
+    }
+    if (isCI()) {
+      params.set("ci", "1");
+    }
+    for (const [key, value] of Object.entries(data)) {
+      if (value !== void 0 && value !== null) {
+        params.set(key, String(value));
+      }
+    }
+    fetch(`${TELEMETRY_URL}?${params.toString()}`).catch(() => {
+    });
+  } catch {
+  }
+}
+
+// src/index.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path3.dirname(__filename);
+var require2 = createRequire(import.meta.url);
+var MORPH_ASCII_LINES = [
+  "\u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557  \u2588\u2588\u2557         ",
+  "\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2551         ",
+  "\u2588\u2588\u2554\u2588\u2588\u2588\u2588\u2554\u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551         ",
+  "\u2588\u2588\u2551\u255A\u2588\u2588\u2554\u255D\u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u255D \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551         ",
+  "\u2588\u2588\u2551 \u255A\u2550\u255D \u2588\u2588\u2551\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2557\u2588\u2588\u2557\u2588\u2588\u2557",
+  "\u255A\u2550\u255D     \u255A\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D     \u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D\u255A\u2550\u255D\u255A\u2550\u255D"
+];
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function showMorphSplash() {
+  const LINE_DELAY_MS = 60;
+  const CHAR_DELAY_MS = 1;
+  const isTTY = process.stdout.isTTY;
+  process.stdout.write("\n");
+  for (const line of MORPH_ASCII_LINES) {
+    if (isTTY) {
+      for (const char of line) {
+        process.stdout.write(chalk.greenBright(char));
+        if (CHAR_DELAY_MS > 0) await sleep(CHAR_DELAY_MS);
+      }
+      process.stdout.write("\n");
+      await sleep(LINE_DELAY_MS);
+    } else {
+      process.stdout.write(chalk.greenBright(line) + "\n");
+    }
+  }
+  if (isTTY) await sleep(1e3);
+  process.stdout.write("\n");
+}
+function getBundledSkillsDir() {
+  return path3.resolve(__dirname, "..", "skills");
+}
+function getAllAgentTypes() {
+  return Object.keys(agents);
+}
+async function selectAgents(opts) {
+  const allAgents = getAllAgentTypes();
+  if (opts.cliAgents.length > 0) return opts.cliAgents;
+  if (opts.yes) return allAgents;
+  const detected = await detectInstalledAgents();
+  const initial = detected.length > 0 ? detected : allAgents;
+  const res = await p.multiselect({
+    message: "Choose which agents to install skills into",
+    options: allAgents.map((id) => ({
+      value: id,
+      label: agents[id].displayName,
+      hint: detected.includes(id) ? "detected" : void 0
+    })),
+    initialValues: initial,
+    required: true
+  });
+  if (p.isCancel(res)) process.exit(0);
+  return res;
+}
+async function selectMcpClients(opts) {
+  const supported = listSupportedMcpClients();
+  const detected = detectMcpClients();
+  if (opts.yes) {
+    return detected.length > 0 ? detected : supported.map((c) => c.id);
+  }
+  const res = await p.multiselect({
+    message: "Choose which apps to install the MCP into",
+    options: supported.map((c) => ({
+      value: c.id,
+      label: c.label,
+      hint: detected.includes(c.id) ? "detected" : void 0
+    })),
+    initialValues: detected.length > 0 ? detected : supported.map((c) => c.id),
+    required: true
+  });
+  if (p.isCancel(res)) process.exit(0);
+  return res;
+}
+async function getMorphMcpInput(opts) {
+  const envApiKey = process.env.MORPH_API_KEY;
+  const effectiveApiKey = opts.cliApiKey ?? envApiKey;
+  const effectiveEnabledTools = "edit_file,warpgrep_codebase_search";
+  if (opts.yes) {
+    return { apiKey: effectiveApiKey, enabledTools: effectiveEnabledTools };
+  }
+  const apiKey = effectiveApiKey ?? await p.password({
+    message: "MORPH_API_KEY (optional, press enter to skip)",
+    mask: "*"
+  });
+  if (p.isCancel(apiKey)) process.exit(0);
+  return {
+    apiKey: typeof apiKey === "string" && apiKey.trim() ? apiKey.trim() : void 0,
+    enabledTools: effectiveEnabledTools
+  };
+}
+async function loadSkills(source) {
+  if (!source) {
+    const skillsDir = getBundledSkillsDir();
+    const skills2 = await discoverSkills(skillsDir);
+    return { skills: skills2, sourceId: "bundled" };
+  }
+  const parsed = parseSource(source);
+  if (parsed.type === "local") {
+    const skills2 = await discoverSkills(parsed.localPath, parsed.subpath);
+    return { skills: skills2, sourceId: parsed.localPath };
+  }
+  if (parsed.type === "direct-url") {
+    throw new Error("Direct SKILL.md URLs are not supported in this build.");
+  }
+  const tempDir = await cloneRepo(parsed.url, parsed.ref);
+  const skills = await discoverSkills(tempDir, parsed.subpath);
+  return { skills, tempDir, sourceId: parsed.url };
+}
+async function installBundledSkills(params) {
+  const skillsDir = getBundledSkillsDir();
+  const skills = await discoverSkills(skillsDir);
+  if (skills.length === 0) {
+    p.log.warn(`No bundled skills found at ${chalk.dim(skillsDir)}.`);
+    return;
+  }
+  p.log.info(chalk.greenBright(`Installing ${skills.length} bundled skills to all chosen agents...`));
+  for (const agentType of params.targetAgents) {
+    for (const skill of skills) {
+      const already = await isSkillInstalled(getSkillDisplayName(skill), agentType, {
+        global: params.global
+      });
+      if (already) continue;
+      await installSkillForAgent(skill, agentType, { global: params.global, mode: "symlink" });
+    }
+  }
+}
+async function installMcp(params) {
+  if (params.clients.length === 0) return;
+  p.log.info(chalk.greenBright(`Installing Morph MCP to ${params.clients.length} chosen app(s)...`));
+  for (const client of params.clients) {
+    const res = await installMorphMcpToClient(client, params.input);
+    if (res.success) {
+      p.log.success(`${client}${res.configPath ? chalk.dim(` \u2192 ${res.configPath}`) : ""}`);
+    } else {
+      p.log.warn(`${client}${res.error ? chalk.dim(`: ${res.error}`) : ""}`);
+    }
+  }
+}
+async function main() {
+  const pkg = require2("../package.json");
+  setVersion(pkg.version);
+  await showMorphSplash();
+  const program = new Command().name("morph-setup").description("Install Morph MCP and bundled skills onto coding agents").argument("[source]", "Optional skills source (repo/path). Bundled skills are always installed.").option("--morph-api-key <key>", "MORPH_API_KEY to write into MCP config (overrides env)").option("-g, --global", "Install skills globally (default)").option("--project", "Install skills to the current project instead of global").option("-a, --agent <agents...>", "Target specific agents (repeatable)").option("-s, --skill <skills...>", "Install specific skills by name (only affects <source> skills)").option("-l, --list", "List available skills without installing").option("-y, --yes", "Skip all confirmation prompts").version(pkg.version);
+  const argv = process.argv.slice();
+  if (argv[2] === "--") argv.splice(2, 1);
+  program.parse(argv);
+  const opts = program.opts();
+  const source = program.args[0];
+  const yes = !!opts.yes;
+  const global = opts.project ? false : true;
+  p.intro(chalk.greenBright(" Morph MCP Install "));
+  const mcpClients = await selectMcpClients({ yes });
+  const mcpInput = await getMorphMcpInput({
+    yes,
+    cliApiKey: opts.morphApiKey
+  });
+  const cliAgents = (opts.agent ?? []).map((a) => a);
+  const targetAgents = await selectAgents({ yes, cliAgents });
+  if (opts.list) {
+    const bundled = await discoverSkills(getBundledSkillsDir());
+    p.log.info(chalk.greenBright("Bundled skills:"));
+    for (const s of bundled) p.log.info(`- ${getSkillDisplayName(s)}`);
+    if (source) {
+      const { skills, tempDir } = await loadSkills(source);
+      try {
+        p.log.info(chalk.greenBright(`
+Skills from ${source}:`));
+        for (const s of skills) p.log.info(`- ${getSkillDisplayName(s)}`);
+      } finally {
+        if (tempDir) await cleanupTempDir(tempDir);
+      }
+    }
+    p.outro("Done.");
+    return;
+  }
+  const skillsFromSource = source ? await loadSkills(source) : null;
+  try {
+    await installMcp({ clients: mcpClients, input: mcpInput });
+    await installBundledSkills({ targetAgents, global, yes });
+    if (skillsFromSource) {
+      const requested = new Set(opts.skill ?? []);
+      const extraSkills = requested.size > 0 ? skillsFromSource.skills.filter((s) => requested.has(getSkillDisplayName(s))) : skillsFromSource.skills;
+      if (extraSkills.length > 0) {
+        p.log.info(
+          chalk.greenBright(`Installing ${extraSkills.length} skill(s) from source to chosen agents...`)
+        );
+        for (const agentType of targetAgents) {
+          for (const skill of extraSkills) {
+            const already = await isSkillInstalled(getSkillDisplayName(skill), agentType, { global });
+            if (already) continue;
+            await installSkillForAgent(skill, agentType, { global, mode: "symlink" });
+          }
+        }
+      }
+    }
+    track({
+      event: "install",
+      source: skillsFromSource?.sourceId ?? "bundled",
+      skills: "bundled",
+      agents: targetAgents.join(","),
+      ...global ? { global: "1" } : {}
+    });
+    p.outro(chalk.greenBright("All done."));
+  } finally {
+    if (skillsFromSource?.tempDir) {
+      await cleanupTempDir(skillsFromSource.tempDir);
+    }
+  }
+}
+await main();

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "@morphllm/morph-setup",
+  "version": "1.0.0",
+  "description": "Install Morph MCP and bundled skills onto coding agents",
+  "type": "module",
+  "bin": {
+    "morph-setup": "./dist/index.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "skills",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsx src/index.ts",
+    "test": "tsx scripts/execute-tests.ts",
+    "prepublishOnly": "npm run build",
+    "format": "prettier --write 'src/**/*.ts' 'scripts/**/*.ts' 'tests/**/*.ts'",
+    "format:check": "prettier --check 'src/**/*.ts' 'scripts/**/*.ts' 'tests/**/*.ts'",
+    "prepare": "husky"
+  },
+  "lint-staged": {
+    "src/**/*.ts": "prettier --write",
+    "scripts/**/*.ts": "prettier --write",
+    "tests/**/*.ts": "prettier --write"
+  },
+  "keywords": [
+    "cli",
+    "agent-skills",
+    "skills",
+    "ai-agents",
+    "amp",
+    "antigravity",
+    "claude-code",
+    "clawdbot",
+    "cline",
+    "codex",
+    "command-code",
+    "cursor",
+    "droid",
+    "gemini-cli",
+    "github-copilot",
+    "goose",
+    "kilo",
+    "kiro-cli",
+    "mcpjam",
+    "opencode",
+    "openhands",
+    "pi",
+    "qoder",
+    "qwen-code",
+    "roo",
+    "trae",
+    "windsurf",
+    "zencoder",
+    "neovate"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vercel-labs/add-skill.git"
+  },
+  "homepage": "https://github.com/vercel-labs/add-skill#readme",
+  "bugs": {
+    "url": "https://github.com/vercel-labs/add-skill/issues"
+  },
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@clack/prompts": "^0.9.1",
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "gray-matter": "^4.0.3",
+    "json5": "^2.2.3",
+    "simple-git": "^3.27.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.2.7",
+    "prettier": "^3.8.1",
+    "tsup": "^8.3.5",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "packageManager": "pnpm@10.17.1"
+}