@composer-app/mcp 0.0.1-beta.2 → 0.0.1-beta.3

package/dist/cli.js

@@ -4,16 +4,824 @@ import {
   logError,
   startMcpHttpServer,
   startMcpServer
-} from "./chunk-SZ67UYAY.js";
+} from "./chunk-VVYEIOFH.js";
 
-// src/cli.ts
+// src/setup.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as os from "os";
 import { execFile } from "child_process";
 import { promisify } from "util";
-import fs from "fs/promises";
-import path from "path";
-import os from "os";
 import { fileURLToPath } from "url";
-var exec = promisify(execFile);
+
+// src/setup-ui.ts
+import * as readline from "readline";
+var ESC = "\x1B[";
+var seq = {
+  RESET: `${ESC}0m`,
+  BOLD: `${ESC}1m`,
+  DIM: `${ESC}2m`,
+  ORANGE: `${ESC}38;5;208m`,
+  // 256-color orange ≈ #E16900
+  GRAY: `${ESC}90m`,
+  HIDE: `${ESC}?25l`,
+  SHOW: `${ESC}?25h`,
+  CLEAR_RIGHT: `${ESC}K`,
+  CLEAR_DOWN: `${ESC}0J`
+};
+var write = (s) => {
+  process.stdout.write(s);
+};
+var up = (n) => n > 0 ? `${ESC}${n}A` : "";
+var paint = (s, code) => `${code}${s}${seq.RESET}`;
+var orange = (s) => paint(s, seq.ORANGE);
+var bold = (s) => paint(s, seq.BOLD);
+var dim = (s) => paint(s, seq.DIM);
+var gray = (s) => paint(s, seq.GRAY);
+var BANNER = [
+  " \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \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\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557 ",
+  "\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557",
+  "\u2588\u2588\u2551     \u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2554\u2588\u2588\u2588\u2588\u2554\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D",
+  "\u2588\u2588\u2551     \u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2588\u2588\u2554\u255D\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u255D \u2588\u2588\u2551   \u2588\u2588\u2551\u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557",
+  "\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551 \u255A\u2550\u255D \u2588\u2588\u2551\u2588\u2588\u2551     \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2551",
+  " \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D     \u255A\u2550\u255D\u255A\u2550\u255D      \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D"
+];
+function printIntro() {
+  write("\n");
+  for (const line of BANNER) write(`  ${orange(line)}
+`);
+  write("\n");
+  write(
+    `  ${bold("Realtime collaborative markdown")} for you and your AI agents.
+`
+  );
+  write(`  Same doc, live \u2014 comments, suggestions, edits. No copy-paste.
+`);
+  write("\n");
+}
+function section(title, opts = {}) {
+  if (opts.first) {
+    if (opts.rule !== false) {
+      const width = Math.max(10, (process.stdout.columns ?? 72) - 4);
+      write(`  ${gray("\u2500".repeat(width))}
+
+
+`);
+    }
+  } else {
+    write("\n\n");
+  }
+  write(`${orange("\u25B8")} ${bold(title)}
+`);
+  write("\n");
+}
+function note(lines) {
+  for (const line of lines) write(`  ${dim(line)}
+`);
+  write("\n");
+}
+function success(msg) {
+  write(`  ${orange("\u2713")} ${msg}
+`);
+}
+function failure(msg) {
+  write(`  ${paint("\u2717", `${ESC}31m`)} ${msg}
+`);
+}
+function skipped(msg) {
+  write(`  ${gray("\xB7")} ${dim(msg)}
+`);
+}
+function isInteractive() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+async function withRawStdin(handle) {
+  return new Promise((resolve) => {
+    const stdin = process.stdin;
+    readline.emitKeypressEvents(stdin);
+    stdin.setRawMode(true);
+    stdin.resume();
+    write(seq.HIDE);
+    const cleanup = () => {
+      stdin.removeListener("keypress", onKey);
+      stdin.setRawMode(false);
+      stdin.pause();
+      write(seq.SHOW);
+    };
+    const onKey = (_str, key) => {
+      if (key?.ctrl && key.name === "c") {
+        cleanup();
+        write("\n");
+        process.exit(130);
+      }
+      if (handle(key) === "done") {
+        cleanup();
+        resolve();
+      }
+    };
+    stdin.on("keypress", onKey);
+  });
+}
+var POINTER = "\u276F";
+var CHECKED = "\u25C9";
+var UNCHECKED = "\u25EF";
+function clamp(n, lo, hi) {
+  return Math.max(lo, Math.min(hi, n));
+}
+function clearWidget(height) {
+  write(up(height));
+  write(seq.CLEAR_DOWN);
+}
+async function select(question, options, opts = {}) {
+  if (options.length === 0) return { kind: "skip" };
+  const defaultIndex = opts.defaultIndex ?? 0;
+  const canGoBack = opts.canGoBack ?? false;
+  const height = 1 + 1 + options.length + 1 + 1;
+  let cursor = clamp(defaultIndex, 0, options.length - 1);
+  const helpText = canGoBack ? "\u2191/\u2193 navigate \xB7 enter confirm \xB7 b back \xB7 q skip" : "\u2191/\u2193 navigate \xB7 enter confirm \xB7 q skip";
+  const render = () => {
+    let out = "";
+    out += `  ${bold(question)}${seq.CLEAR_RIGHT}
+`;
+    out += `${seq.CLEAR_RIGHT}
+`;
+    for (let i = 0; i < options.length; i++) {
+      const opt = options[i];
+      const active = i === cursor;
+      const pointer = active ? orange(POINTER) : " ";
+      const label = active ? bold(opt.label) : opt.label;
+      const hint = opt.hint ? dim(`  ${opt.hint}`) : "";
+      out += `    ${pointer} ${label}${hint}${seq.CLEAR_RIGHT}
+`;
+    }
+    out += `${seq.CLEAR_RIGHT}
+`;
+    out += `    ${gray(helpText)}${seq.CLEAR_RIGHT}
+`;
+    return out;
+  };
+  write(render());
+  let outcome = { kind: "skip" };
+  await withRawStdin((key) => {
+    if (key.name === "up" || key.name === "k") {
+      cursor = (cursor - 1 + options.length) % options.length;
+    } else if (key.name === "down" || key.name === "j") {
+      cursor = (cursor + 1) % options.length;
+    } else if (key.name === "return") {
+      outcome = { kind: "ok", value: options[cursor].value };
+      return "done";
+    } else if (canGoBack && key.name === "b") {
+      outcome = { kind: "back" };
+      return "done";
+    } else if (key.name === "q" || key.name === "escape") {
+      outcome = { kind: "skip" };
+      return "done";
+    } else {
+      return "continue";
+    }
+    write(up(height) + render());
+    return "continue";
+  });
+  clearWidget(height);
+  return outcome;
+}
+async function multiselect(question, options, opts = {}) {
+  if (options.length === 0) return { kind: "ok", value: [] };
+  const canGoBack = opts.canGoBack ?? false;
+  const checks = (opts.defaultSelected ?? options.map(() => true)).slice();
+  let cursor = 0;
+  const height = 1 + 1 + options.length + 1 + 1;
+  const helpText = canGoBack ? "\u2191/\u2193 navigate \xB7 space toggle \xB7 a all \xB7 enter confirm \xB7 b back \xB7 q skip" : "\u2191/\u2193 navigate \xB7 space toggle \xB7 a all \xB7 enter confirm \xB7 q skip";
+  const render = () => {
+    let out = "";
+    out += `  ${bold(question)}${seq.CLEAR_RIGHT}
+`;
+    out += `${seq.CLEAR_RIGHT}
+`;
+    for (let i = 0; i < options.length; i++) {
+      const opt = options[i];
+      const active = i === cursor;
+      const pointer = active ? orange(POINTER) : " ";
+      const box = checks[i] ? orange(CHECKED) : gray(UNCHECKED);
+      const label = active ? bold(opt.label) : opt.label;
+      const hint = opt.hint ? dim(`  ${opt.hint}`) : "";
+      out += `    ${pointer} ${box} ${label}${hint}${seq.CLEAR_RIGHT}
+`;
+    }
+    out += `${seq.CLEAR_RIGHT}
+`;
+    out += `    ${gray(helpText)}${seq.CLEAR_RIGHT}
+`;
+    return out;
+  };
+  write(render());
+  let outcome = { kind: "skip" };
+  await withRawStdin((key) => {
+    if (key.name === "up" || key.name === "k") {
+      cursor = (cursor - 1 + options.length) % options.length;
+    } else if (key.name === "down" || key.name === "j") {
+      cursor = (cursor + 1) % options.length;
+    } else if (key.name === "space") {
+      checks[cursor] = !checks[cursor];
+    } else if (key.name === "a") {
+      const allOn = checks.every((c) => c);
+      for (let i = 0; i < checks.length; i++) checks[i] = !allOn;
+    } else if (key.name === "return") {
+      outcome = {
+        kind: "ok",
+        value: options.filter((_, i) => checks[i]).map((o) => o.value)
+      };
+      return "done";
+    } else if (canGoBack && key.name === "b") {
+      outcome = { kind: "back" };
+      return "done";
+    } else if (key.name === "q" || key.name === "escape") {
+      outcome = { kind: "skip" };
+      return "done";
+    } else {
+      return "continue";
+    }
+    write(up(height) + render());
+    return "continue";
+  });
+  clearWidget(height);
+  return outcome;
+}
+async function confirm(question, opts = {}) {
+  const defaultYes = opts.defaultYes ?? true;
+  const r = await select(
+    question,
+    [
+      { value: true, label: "Yes" },
+      { value: false, label: "No" }
+    ],
+    { defaultIndex: defaultYes ? 0 : 1, canGoBack: opts.canGoBack }
+  );
+  return r;
+}
+
+// src/setup.ts
+var execP = promisify(execFile);
+var MCP_NAME = "composer-mcp";
+var MCP_COMMAND = "npx";
+var MCP_ARGS = ["-y", "@composer-app/mcp@latest", "mcp"];
+var HINT_MARKER = "`composer-mcp` tools";
+var HINT_BLOCK = `
+## Composer
+
+- When generating markdown the user may want to review or iterate on (plans, writing, skills, docs), offer to send it to Composer via the \`composer-mcp\` tools without being asked.
+`;
+var HOME = os.homedir();
+var HARNESSES = [
+  {
+    id: "claude-code",
+    name: "Claude Code",
+    configDir: path.join(HOME, ".claude"),
+    cli: "claude",
+    userRuleFile: path.join(HOME, ".claude", "CLAUDE.md"),
+    async registerMcp(env) {
+      const args = ["mcp", "add", "--scope", "user", MCP_NAME];
+      for (const [k, v] of Object.entries(env)) args.push("-e", `${k}=${v}`);
+      args.push("--", MCP_COMMAND, ...MCP_ARGS);
+      await execP("claude", args);
+    }
+  },
+  {
+    id: "codex",
+    name: "OpenAI Codex",
+    configDir: path.join(HOME, ".codex"),
+    cli: "codex",
+    userRuleFile: path.join(HOME, ".codex", "AGENTS.md"),
+    async registerMcp(env) {
+      await appendCodexToml(env);
+    }
+  },
+  {
+    id: "cursor",
+    name: "Cursor",
+    configDir: path.join(HOME, ".cursor"),
+    userRuleFile: null,
+    async registerMcp(env) {
+      await writeMcpJsonConfig(path.join(HOME, ".cursor", "mcp.json"), env);
+    }
+  },
+  {
+    id: "gemini",
+    name: "Gemini CLI",
+    configDir: path.join(HOME, ".gemini"),
+    cli: "gemini",
+    userRuleFile: path.join(HOME, ".gemini", "GEMINI.md"),
+    async registerMcp(env) {
+      await writeMcpJsonConfig(
+        path.join(HOME, ".gemini", "settings.json"),
+        env
+      );
+    }
+  },
+  {
+    id: "windsurf",
+    name: "Windsurf",
+    configDir: path.join(HOME, ".codeium", "windsurf"),
+    userRuleFile: null,
+    async registerMcp(env) {
+      await writeMcpJsonConfig(
+        path.join(HOME, ".codeium", "windsurf", "mcp_config.json"),
+        env
+      );
+    }
+  }
+];
+async function pathExists(p) {
+  try {
+    await fs.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function commandAvailable(name) {
+  try {
+    if (process.platform === "win32") {
+      await execP("where", [name]);
+    } else {
+      await execP("sh", ["-c", `command -v ${name}`]);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function detectHarnesses() {
+  const results = await Promise.all(
+    HARNESSES.map(async (h) => {
+      if (await pathExists(h.configDir)) return h;
+      if (h.cli && await commandAvailable(h.cli)) return h;
+      return null;
+    })
+  );
+  return results.filter((h) => h !== null);
+}
+async function writeMcpJsonConfig(filePath, env) {
+  let config = {};
+  try {
+    const raw = await fs.readFile(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object") {
+      config = parsed;
+    }
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  const servers = config.mcpServers ?? {};
+  servers[MCP_NAME] = { command: MCP_COMMAND, args: MCP_ARGS, env };
+  config.mcpServers = servers;
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, JSON.stringify(config, null, 2) + "\n", "utf8");
+}
+async function appendCodexToml(env) {
+  const filePath = path.join(HOME, ".codex", "config.toml");
+  let existing = "";
+  try {
+    existing = await fs.readFile(filePath, "utf8");
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  const header = `[mcp_servers.${MCP_NAME}]`;
+  if (existing.includes(header)) return;
+  const argsList = MCP_ARGS.map((a) => `"${tomlEscape(a)}"`).join(", ");
+  const envPairs = Object.entries(env).map(([k, v]) => `"${tomlEscape(k)}" = "${tomlEscape(v)}"`).join(", ");
+  const block = `
+${header}
+command = "${MCP_COMMAND}"
+args = [${argsList}]
+env = { ${envPairs} }
+`;
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  const sep = existing.length === 0 || existing.endsWith("\n") ? "" : "\n";
+  await fs.writeFile(filePath, existing + sep + block, "utf8");
+}
+function tomlEscape(s) {
+  return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+async function appendHint(filePath) {
+  let existing = "";
+  let existed = true;
+  try {
+    existing = await fs.readFile(filePath, "utf8");
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+    existed = false;
+  }
+  if (existing.includes(HINT_MARKER)) return "already-present";
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  const sep = existing.length === 0 ? "" : existing.endsWith("\n") ? "" : "\n";
+  await fs.writeFile(filePath, existing + sep + HINT_BLOCK, "utf8");
+  return existed ? "appended" : "created";
+}
+async function addClaudePermission() {
+  const filePath = path.join(HOME, ".claude", "settings.json");
+  let settings = {};
+  try {
+    const raw = await fs.readFile(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object") {
+      settings = parsed;
+    }
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  const permissions = settings.permissions ?? {};
+  const allow = Array.isArray(permissions.allow) ? permissions.allow : [];
+  const entry = `mcp__${MCP_NAME}`;
+  if (allow.includes(entry)) return "already-present";
+  allow.push(entry);
+  permissions.allow = allow;
+  settings.permissions = permissions;
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  return "added";
+}
+async function copyClaudeSkill() {
+  const skillDir = path.join(HOME, ".claude", "skills", "composer");
+  const skillPath = path.join(skillDir, "SKILL.md");
+  await fs.mkdir(skillDir, { recursive: true });
+  const pkgRoot = fileURLToPath(new URL("..", import.meta.url));
+  const skillSource = path.join(pkgRoot, "skill", "SKILL.md");
+  const skillContent = await fs.readFile(skillSource, "utf8");
+  await fs.writeFile(skillPath, skillContent);
+  return skillPath;
+}
+function shouldInstallSkill(plan) {
+  return plan.registrations.some((h) => h.id === "claude-code");
+}
+function emptyPlan() {
+  return {
+    registrations: [],
+    hintFiles: [],
+    addPermissions: false
+  };
+}
+function planHasWork(plan) {
+  return plan.registrations.length > 0 || plan.hintFiles.length > 0 || plan.addPermissions || shouldInstallSkill(plan);
+}
+var registerStep = async (state, canGoBack) => {
+  section("Register the MCP server", { first: true, rule: state.rule });
+  note([
+    "Gives your agent(s) access to Composer's tools \u2014 create docs, leave",
+    "comments, post suggestions, watch for @mentions."
+  ]);
+  const choices = state.detected.map((h) => ({
+    value: h.id,
+    label: h.name,
+    hint: "detected"
+  }));
+  const previouslyPicked = new Set(state.plan.registrations.map((h) => h.id));
+  const r = await multiselect(
+    "Which harness(es) should Composer register with?",
+    choices,
+    {
+      canGoBack,
+      defaultSelected: state.detected.map(
+        (h) => previouslyPicked.size === 0 ? true : previouslyPicked.has(h.id)
+      )
+    }
+  );
+  if (r.kind === "back") return "back";
+  if (r.kind === "skip") {
+    state.plan.registrations = [];
+    skipped("no harnesses registered");
+    return "prompted";
+  }
+  state.plan.registrations = state.detected.filter(
+    (h) => r.value.includes(h.id)
+  );
+  if (state.plan.registrations.length === 0) {
+    skipped("no harnesses registered");
+  } else {
+    success(
+      `planned: ${state.plan.registrations.map((h) => h.name).join(", ")}`
+    );
+  }
+  return "prompted";
+};
+var scopeStep = async (state, canGoBack) => {
+  section("Add the 'offer Composer' rule");
+  note([
+    "Adds a line to your agent's rules file (CLAUDE.md, AGENTS.md, etc.)",
+    "so it proactively offers to send generated markdown \u2014 plans, writing,",
+    "docs \u2014 to Composer instead of waiting for you to ask."
+  ]);
+  const r = await select(
+    "Where should the rule go?",
+    [
+      { value: "user", label: "User-level", hint: "applies to all your projects" },
+      { value: "project", label: "Project-level", hint: process.cwd() }
+    ],
+    { canGoBack, defaultIndex: state.scope === "project" ? 1 : 0 }
+  );
+  if (r.kind === "back") return "back";
+  if (r.kind === "skip") {
+    state.scope = null;
+    state.plan.hintFiles = [];
+    skipped("rule file unchanged");
+    return "prompted";
+  }
+  state.scope = r.value;
+  state.plan.hintFiles = [];
+  return "prompted";
+};
+var userTargetsStep = async (state, canGoBack) => {
+  if (state.scope !== "user") return "skipped";
+  const targets = state.detected.filter((h) => h.userRuleFile);
+  if (targets.length === 0) {
+    skipped(
+      "none of the detected harnesses have a user-level rule-file convention"
+    );
+    return "skipped";
+  }
+  const choices = targets.map((h) => ({
+    value: h.userRuleFile,
+    label: h.userRuleFile.replace(HOME, "~"),
+    hint: h.name
+  }));
+  const r = await multiselect("Which rule file(s) should I update?", choices, {
+    canGoBack,
+    defaultSelected: choices.map(() => true)
+  });
+  if (r.kind === "back") return "back";
+  if (r.kind === "skip") {
+    state.plan.hintFiles = [];
+    skipped("no rule files updated");
+    return "prompted";
+  }
+  state.plan.hintFiles = r.value;
+  if (r.value.length > 0) {
+    success(
+      `planned: ${r.value.map((f) => f.replace(HOME, "~")).join(", ")}`
+    );
+  } else {
+    skipped("no rule files updated");
+  }
+  return "prompted";
+};
+var projectTargetStep = async (state, canGoBack) => {
+  if (state.scope !== "project") return "skipped";
+  const cwd = process.cwd();
+  const candidates = [
+    "AGENTS.md",
+    "CLAUDE.md",
+    "GEMINI.md",
+    ".cursorrules",
+    ".windsurfrules"
+  ];
+  const existing = [];
+  for (const name of candidates) {
+    if (await pathExists(path.join(cwd, name))) existing.push(name);
+  }
+  let target = null;
+  if (existing.length === 1) {
+    target = path.join(cwd, existing[0]);
+  } else if (existing.length > 1) {
+    const r = await select(
+      "Multiple rule files found \u2014 which should I update?",
+      existing.map((name) => ({ value: name, label: name })),
+      { canGoBack }
+    );
+    if (r.kind === "back") return "back";
+    if (r.kind === "skip") {
+      state.plan.hintFiles = [];
+      skipped("no rule file updated");
+      return "prompted";
+    }
+    target = path.join(cwd, r.value);
+  } else {
+    const r = await confirm(
+      `No rule file found in ${cwd}. Create ${bold("AGENTS.md")}?`,
+      { canGoBack }
+    );
+    if (r.kind === "back") return "back";
+    if (r.kind === "skip" || r.value === false) {
+      state.plan.hintFiles = [];
+      skipped("no rule file created");
+      return "prompted";
+    }
+    target = path.join(cwd, "AGENTS.md");
+  }
+  state.plan.hintFiles = target ? [target] : [];
+  if (target) success(`planned: ${target}`);
+  return "prompted";
+};
+var COMPOSER_TOOLS = [
+  ["composer_create_room", "create a new collaborative doc"],
+  ["composer_join_room", "join an existing doc by share URL"],
+  ["composer_attach_room", "refresh an attached doc's snapshot"],
+  ["composer_next_event", "watch for @mentions and replies"],
+  ["composer_get_section", "read a section's markdown"],
+  ["composer_get_full_doc", "read the entire doc as markdown"],
+  ["composer_add_comment", "post a comment on selected text"],
+  ["composer_reply_comment", "reply to a comment thread"],
+  ["composer_add_suggestion", "propose a text replacement"],
+  ["composer_reply_suggestion", "reply to a suggestion thread"],
+  ["composer_resolve_thread", "mark a thread resolved"]
+];
+function printComposerTools() {
+  const w = (s) => process.stdout.write(s);
+  w("\n");
+  w(`  ${dim("These tools will be pre-approved:")}
+
+`);
+  for (const [name, desc] of COMPOSER_TOOLS) {
+    w(`    ${orange("\u2022")} ${bold(name)}  ${dim("\u2014 " + desc)}
+`);
+  }
+  w("\n");
+}
+var permissionsStep = async (state, canGoBack) => {
+  if (!state.plan.registrations.some((h) => h.id === "claude-code"))
+    return "skipped";
+  section("Allow Composer permissions");
+  note([
+    "Skips Claude Code's per-tool permission prompts. Revoke anytime from",
+    `${gray("~/.claude/settings.json")}.`
+  ]);
+  printComposerTools();
+  const r = await confirm("Allow all Composer permissions?", {
+    canGoBack,
+    defaultYes: state.plan.addPermissions
+  });
+  if (r.kind === "back") return "back";
+  if (r.kind === "skip") {
+    state.plan.addPermissions = false;
+    skipped("permissions unchanged");
+    return "prompted";
+  }
+  state.plan.addPermissions = r.value;
+  if (r.value) success("planned: allow all Composer tools");
+  else skipped("permissions unchanged");
+  return "prompted";
+};
+function renderPlan(plan) {
+  const lines = [];
+  if (plan.registrations.length > 0) {
+    lines.push(`  ${bold("Register MCP server with:")}`);
+    for (const h of plan.registrations) {
+      lines.push(`    ${orange("\u2022")} ${h.name}`);
+    }
+  }
+  if (plan.hintFiles.length > 0) {
+    lines.push(`  ${bold("Append Composer hint to:")}`);
+    for (const f of plan.hintFiles) {
+      lines.push(`    ${orange("\u2022")} ${f.replace(HOME, "~")}`);
+    }
+  }
+  if (plan.addPermissions) {
+    lines.push(`  ${bold("Pre-approve permissions:")}`);
+    lines.push(
+      `    ${orange("\u2022")} mcp__${MCP_NAME} in ~/.claude/settings.json`
+    );
+  }
+  if (shouldInstallSkill(plan)) {
+    lines.push(`  ${bold("Install Claude skill:")}`);
+    lines.push(`    ${orange("\u2022")} ~/.claude/skills/composer/SKILL.md`);
+  }
+  return lines.join("\n");
+}
+async function executePlan(plan, env) {
+  for (const h of plan.registrations) {
+    try {
+      await h.registerMcp(env);
+      success(`registered with ${h.name}`);
+    } catch (err) {
+      failure(`${h.name}: ${err.message}`);
+    }
+  }
+  for (const file of plan.hintFiles) {
+    try {
+      const result = await appendHint(file);
+      success(`${file.replace(HOME, "~")} ${dim(`(${result})`)}`);
+    } catch (err) {
+      failure(`${file}: ${err.message}`);
+    }
+  }
+  if (plan.addPermissions) {
+    try {
+      const result = await addClaudePermission();
+      success(`permissions.allow mcp__${MCP_NAME} ${dim(`(${result})`)}`);
+    } catch (err) {
+      failure(`settings.json: ${err.message}`);
+    }
+  }
+  if (shouldInstallSkill(plan)) {
+    try {
+      const skillPath = await copyClaudeSkill();
+      success(`skill installed ${dim(`(${skillPath.replace(HOME, "~")})`)}`);
+    } catch (err) {
+      failure(`skill copy: ${err.message}`);
+    }
+  }
+}
+async function runSetup(opts) {
+  const env = {
+    COMPOSER_SERVER_HOST: process.env.COMPOSER_SERVER_HOST ?? "usecomposer.app",
+    COMPOSER_APP_BASE: process.env.COMPOSER_APP_BASE ?? "https://usecomposer.app"
+  };
+  if (!isInteractive() && !opts.yes) {
+    console.log(
+      "composer-mcp setup needs an interactive terminal, or `--yes` to accept defaults."
+    );
+    return;
+  }
+  printIntro();
+  if (opts.dryRun) {
+    note([
+      `${bold(orange("DRY RUN"))} \u2014 no files will be written, no commands will run.`
+    ]);
+  }
+  const detected = opts.all ? HARNESSES : await detectHarnesses();
+  if (detected.length === 0) {
+    console.log(
+      "  No supported AI harness detected. Install Claude Code, Codex, Cursor,\n  Gemini CLI, or Windsurf first, then re-run setup. Or pass --all to\n  configure an undetected harness manually.\n"
+    );
+    return;
+  }
+  if (opts.all) {
+    note([`All harnesses: ${detected.map((h) => bold(h.name)).join(", ")}`]);
+  } else {
+    note([`Detected: ${detected.map((h) => bold(h.name)).join(", ")}`]);
+  }
+  const state = {
+    detected,
+    scope: null,
+    rule: opts.rule,
+    plan: {
+      ...emptyPlan(),
+      // Seed permissions to `true` so the prompt defaults to Yes and
+      // `--yes` mode picks it up for free. Gated on actual Claude
+      // registration at apply time.
+      addPermissions: true
+    }
+  };
+  if (opts.yes) {
+    state.scope = "user";
+    state.plan.registrations = detected;
+    state.plan.hintFiles = detected.map((h) => h.userRuleFile).filter((f) => Boolean(f));
+  } else {
+    const steps = [
+      registerStep,
+      scopeStep,
+      userTargetsStep,
+      projectTargetStep,
+      permissionsStep
+    ];
+    let i = 0;
+    const history = [];
+    while (i < steps.length) {
+      const canGoBack = history.length > 0;
+      const outcome = await steps[i](state, canGoBack);
+      if (outcome === "back") {
+        if (history.length === 0) continue;
+        i = history.pop();
+        continue;
+      }
+      if (outcome === "prompted") history.push(i);
+      i++;
+    }
+  }
+  section("Review");
+  if (!planHasWork(state.plan)) {
+    note(["Nothing to do \u2014 you skipped every step."]);
+    console.log();
+    return;
+  }
+  console.log(renderPlan(state.plan));
+  console.log();
+  if (opts.dryRun) {
+    console.log(
+      `  ${orange("done")} \u2014 ${bold("dry run complete")}, nothing was written.`
+    );
+    console.log();
+    return;
+  }
+  if (!opts.yes) {
+    const go = await confirm("Apply these changes?", { defaultYes: true });
+    if (go.kind !== "ok" || go.value !== true) {
+      console.log();
+      console.log(`  ${gray("cancelled")} \u2014 nothing was written.`);
+      console.log();
+      return;
+    }
+  }
+  await loadOrCreateIdentity(path.join(HOME, ".composer-mcp"));
+  section("Applying");
+  await executePlan(state.plan, env);
+  console.log();
+  console.log(
+    `  ${orange("done")} \u2014 restart your agent, then paste a share prompt from any Composer doc.`
+  );
+  console.log();
+}
+
+// src/cli.ts
 var DEFAULT_HTTP_PORT = 3456;
 function resolveHttpPort() {
   const argv = process.argv.slice(3);
@@ -38,54 +846,24 @@ async function main() {
   const cmd = process.argv[2];
   if (cmd === "mcp") return startMcpServer();
   if (cmd === "http") return startMcpHttpServer({ port: resolveHttpPort() });
-  if (cmd === "setup") return setup();
+  if (cmd === "setup") {
+    const argv = process.argv.slice(3);
+    const dryRun = argv.some((a) => a === "--dry-run" || a === "-n");
+    const yes = argv.some((a) => a === "--yes" || a === "-y");
+    const noRule = argv.some((a) => a === "--no-rule");
+    const all = argv.some((a) => a === "--all" || a === "-a");
+    return runSetup({ dryRun, yes, rule: !noRule, all });
+  }
   console.log(`composer-mcp
   setup   Register the MCP server with your agent
+          flags: --yes / -y      accept defaults everywhere, no prompts
+                 --dry-run / -n  show what would happen without writing anything
+                 --all / -a      show every known harness, skip detection
+                 --no-rule       skip the horizontal rule before the first step
   mcp     Run as an MCP server over stdio (invoked by the host CLI)
   http    Run as an MCP server over HTTP (for local dev + HMR)
           flags: --port N  (or COMPOSER_MCP_PORT env; default ${DEFAULT_HTTP_PORT})`);
 }
-async function setup() {
-  const dir = path.join(os.homedir(), ".composer-mcp");
-  await loadOrCreateIdentity(dir);
-  const serverHost = process.env.COMPOSER_SERVER_HOST ?? "usecomposer.app";
-  const appBase = process.env.COMPOSER_APP_BASE ?? "https://usecomposer.app";
-  try {
-    await exec("claude", [
-      "mcp",
-      "add",
-      "--scope",
-      "user",
-      "composer-mcp",
-      "-e",
-      `COMPOSER_SERVER_HOST=${serverHost}`,
-      "-e",
-      `COMPOSER_APP_BASE=${appBase}`,
-      "--",
-      "npx",
-      "-y",
-      "@composer-app/mcp@latest",
-      "mcp"
-    ]);
-    console.log("\u2713 Registered composer-mcp with agent");
-  } catch (e) {
-    console.error(
-      "\u2717 Could not register with agent:",
-      e.message
-    );
-    process.exit(1);
-  }
-  const skillDir = path.join(os.homedir(), ".claude", "skills", "composer");
-  await fs.mkdir(skillDir, { recursive: true });
-  const pkgRoot = fileURLToPath(new URL("..", import.meta.url));
-  const skillSource = path.join(pkgRoot, "skill", "SKILL.md");
-  const skillContent = await fs.readFile(skillSource, "utf8");
-  await fs.writeFile(path.join(skillDir, "SKILL.md"), skillContent);
-  console.log(`\u2713 Wrote skill to ${skillDir}/SKILL.md`);
-  console.log(
-    "\nRestart your agent, then paste a share prompt from any Composer doc."
-  );
-}
 main().catch((e) => {
   logError("cli main() rejected", e);
   console.error(e);