@100xprompt/brain 0.0.0-stage → 0.1.0

package/src/memory/mcp-install.ts

@@ -0,0 +1,401 @@
+import { PACKAGE, selfArgs, stableBun } from "../self.ts"
+import { chmodSync, copyFileSync, existsSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs"
+import { dirname, join } from "node:path"
+import { runMcpServer } from "./mcp-server.ts"
+import type { ProjectKey } from "./types.ts"
+
+// `brain mcp serve | install | uninstall | status`. The installer writes one entry named "brain" into each tool's
+// user-level MCP config, the way hooks.ts does for hooks: merged with the person's own file, the original backed up
+// first under <home>/.brain/backups/, idempotent, removed exactly by uninstall, other entries never touched, and a
+// file that cannot be parsed is left alone and reported. Formats and paths follow Chitta's installer registry
+// (src/install/platforms.ts), reimplemented here: brain does not import Chitta.
+
+type Json = Record<string, any>
+
+const NAME = "brain"
+
+export interface McpTool {
+  id: string
+  label: string
+  /** Config file, relative to home (macOS/Linux/Windows differences are resolved when the table is built). */
+  file: string
+  /** Folder or file that exists once the tool has run on this machine, relative to home. */
+  probe: string[]
+  format: "json" | "toml"
+  /** Where the entries live in the JSON file. */
+  key?: string
+  entry?: (command: string, args: string[]) => Json
+}
+
+const plain = (command: string, args: string[]): Json => ({ command, args })
+
+function vscodeUser(): string {
+  return process.platform === "darwin" ? "Library/Application Support/Code/User" : process.platform === "win32" ? "AppData/Roaming/Code/User" : ".config/Code/User"
+}
+
+export const MCP_TOOLS: McpTool[] = [
+  { id: "claude-code", label: "Claude Code", file: ".claude.json", probe: [".claude.json", ".claude"], format: "json", key: "mcpServers", entry: plain },
+  { id: "codex", label: "Codex", file: ".codex/config.toml", probe: [".codex"], format: "toml" },
+  { id: "cursor", label: "Cursor", file: ".cursor/mcp.json", probe: [".cursor"], format: "json", key: "mcpServers", entry: plain },
+  { id: "gemini", label: "Gemini CLI", file: ".gemini/settings.json", probe: [".gemini"], format: "json", key: "mcpServers", entry: plain },
+  {
+    id: "opencode",
+    label: "OpenCode",
+    file: ".config/opencode/opencode.json",
+    probe: [".config/opencode"],
+    format: "json",
+    key: "mcp",
+    entry: (command, args) => ({ type: "local", command: [command, ...args], enabled: true }),
+  },
+  { id: "vscode", label: "VS Code", file: `${vscodeUser()}/mcp.json`, probe: [vscodeUser()], format: "json", key: "servers", entry: (command, args) => ({ type: "stdio", command, args }) },
+]
+
+export interface McpChange {
+  tool: string
+  path: string
+  action: "installed" | "already-installed" | "removed" | "not-installed" | "skipped"
+  why?: string
+}
+
+interface Opts {
+  /** The cli.ts the entry runs (default: this brain's own, absolute). */
+  cli?: string
+  dryRun?: boolean
+}
+
+/** The entry's arguments after bun: this brain's cli.ts (or, run through bunx, the pinned package), then `mcp serve`. */
+const argsFor = (cli?: string) => [...(cli ? selfArgs(cli) : selfArgs()), "mcp", "serve"]
+
+// ---- files ----
+
+type Loaded = { config: Json; indent: string } | { error: string }
+
+function loadJson(path: string): Loaded {
+  if (!existsSync(path)) return { config: {}, indent: "  " }
+  let text: string
+  try {
+    text = readFileSync(path, "utf8")
+  } catch (e) {
+    return { error: `cannot read it (${(e as Error).message})` }
+  }
+  if (!text.trim()) return { config: {}, indent: "  " }
+  try {
+    const v = JSON.parse(text)
+    if (!v || typeof v !== "object" || Array.isArray(v)) return { error: "it is not a JSON object; left as it is" }
+    return { config: v, indent: text.match(/\n([ \t]+)"/)?.[1] ?? "  " }
+  } catch {
+    return { error: "it is not plain JSON (comments?); left as it is" }
+  }
+}
+
+const backupPath = (home: string, tool: string, path: string) => join(home, ".brain", "backups", `mcp-${tool}-${path.split("/").pop()}`)
+
+/** Atomic write through a symlink, keeping the file's mode; the original is copied once to <home>/.brain/backups/. */
+function writeFile(home: string, tool: string, path: string, text: string) {
+  const real = existsSync(path) ? realpathSync(path) : path
+  mkdirSync(dirname(real), { recursive: true })
+  const backup = backupPath(home, tool, path)
+  if (existsSync(real) && !existsSync(backup)) {
+    mkdirSync(dirname(backup), { recursive: true, mode: 0o700 })
+    copyFileSync(real, backup)
+    chmodSync(backup, 0o600)
+  }
+  let mode: number | undefined
+  try {
+    mode = statSync(real).mode & 0o777
+  } catch {
+    // New file: default mode.
+  }
+  const tmp = `${real}.brain-tmp`
+  rmSync(tmp, { force: true })
+  writeFileSync(tmp, text, mode === undefined ? {} : { mode })
+  if (mode !== undefined) chmodSync(tmp, mode)
+  renameSync(tmp, real)
+}
+
+/** An entry is ours when it runs `... mcp serve` through a cli.ts, or through the brain package (`bun x @100xprompt/brain@...`). */
+function isOurs(entry: unknown): boolean {
+  const e = entry as Json
+  if (!e || typeof e !== "object") return false
+  const argv: unknown[] = Array.isArray(e.command) ? e.command : [e.command, ...(Array.isArray(e.args) ? e.args : [])]
+  const s = argv.filter((x): x is string => typeof x === "string")
+  const runs = s[s.length - 3] ?? ""
+  return s.length >= 3 && s.slice(-2).join(" ") === "mcp serve" && (/cli\.ts$/.test(runs) || runs === PACKAGE || runs.startsWith(`${PACKAGE}@`))
+}
+
+const tomlString = (s: string) => JSON.stringify(s)
+
+/**
+ * The bun to start the server with: its absolute path, because a tool started from a desktop launcher often has no
+ * ~/.bun/bin on its PATH and a bare "bun" would not start. BRAIN_BUN overrides it (tests pin "bun").
+ */
+export function bunCommand(): string {
+  return stableBun()
+}
+
+function tomlBlock(command: string, args: string[]): string {
+  return `[mcp_servers.${NAME}]\ncommand = ${tomlString(command)}\nargs = [${args.map(tomlString).join(", ")}]\n`
+}
+
+/** The brain's table in a TOML file: its [mcp_servers.brain] header through the line before the next other header. */
+function findTomlBlock(text: string): { start: number; end: number } | undefined {
+  const re = /^[ \t]*\[mcp_servers\.brain\][ \t]*(#.*)?$/m
+  const m = re.exec(text)
+  if (!m) return undefined
+  const start = m.index
+  const after = start + m[0].length
+  const next = /^[ \t]*\[(?!mcp_servers\.brain[.\]])/m
+  const rest = text.slice(after)
+  const n = next.exec(rest)
+  return { start, end: n ? after + n.index : text.length }
+}
+
+function parseToml(text: string): Json | undefined {
+  try {
+    return Bun.TOML.parse(text) as Json
+  } catch {
+    return undefined
+  }
+}
+
+// ---- install / uninstall / status ----
+
+/**
+ * Where a tool keeps this config. Claude Code reads its global config from $CLAUDE_CONFIG_DIR/.claude.json when that is set
+ * (a custom config folder), not from ~/.claude.json: writing to the home copy would silently do nothing for those people.
+ */
+function configPath(t: McpTool, home: string): string {
+  const custom = t.id === "claude-code" ? process.env.CLAUDE_CONFIG_DIR : undefined
+  return custom ? join(custom, ".claude.json") : join(home, t.file)
+}
+
+/** Whether the tool has run here (its config or folder exists). */
+function hasRun(t: McpTool, home: string): boolean {
+  if (t.id === "claude-code" && process.env.CLAUDE_CONFIG_DIR && existsSync(process.env.CLAUDE_CONFIG_DIR)) return true
+  return t.probe.some((p) => existsSync(join(home, p)))
+}
+
+function prepare(tool: string, home: string): { t: McpTool; path: string } | McpChange {
+  const t = MCP_TOOLS.find((x) => x.id === tool)
+  if (!t) return { tool, path: "", action: "skipped", why: `no MCP installer for "${tool}"; available: ${MCP_TOOLS.map((x) => x.id).join(", ")}` }
+  const path = configPath(t, home)
+  if (!hasRun(t, home)) return { tool: t.id, path, action: "skipped", why: `${t.label} has not run on this machine (no ~/${t.probe[0]})` }
+  return { t, path }
+}
+
+function currentJson(t: McpTool, config: Json): { entry: unknown } | { error: string } {
+  const c = config[t.key!]
+  if (c === undefined) return { entry: undefined }
+  if (!c || typeof c !== "object" || Array.isArray(c)) return { error: `"${t.key}" is not an object; left as it is` }
+  return { entry: c[NAME] }
+}
+
+export function installMcp(tools: string[], home: string, opts: Opts = {}): McpChange[] {
+  const out: McpChange[] = []
+  const args = argsFor(opts.cli)
+  for (const tool of [...new Set(tools)]) {
+    const p = prepare(tool, home)
+    if (!("t" in p)) {
+      out.push(p)
+      continue
+    }
+    const { t, path } = p
+    const done = (action: McpChange["action"], why?: string): McpChange => ({ tool: t.id, path, action, ...(why ? { why } : {}) })
+    try {
+      if (t.format === "toml") {
+        const text = existsSync(path) ? readFileSync(path, "utf8") : ""
+        const parsed = text.trim() ? parseToml(text) : {}
+        if (!parsed) {
+          out.push(done("skipped", "it is not valid TOML; left as it is"))
+          continue
+        }
+        const existing = parsed.mcp_servers?.[NAME]
+        if (existing && !isOurs(existing)) {
+          out.push(done("skipped", `it already has an mcp_servers.${NAME} that is not this brain's; left as it is`))
+          continue
+        }
+        // Dotted keys or an inline table for mcp_servers cannot take a [mcp_servers.brain] header (a strict TOML parser, like
+        // Codex's, rejects the mix; Bun's is lenient, so the check is on the text).
+        if (/^[ \t]*mcp_servers[ \t]*[.=]/m.test(text)) {
+          out.push(done("skipped", "the file defines mcp_servers with dotted keys or an inline table, which this cannot extend safely; left as it is"))
+          continue
+        }
+        const bun = bunCommand()
+        const block = tomlBlock(bun, args)
+        const at = findTomlBlock(text)
+        if (at && text.slice(at.start, at.end).trimEnd() === block.trimEnd()) {
+          out.push(done("already-installed"))
+          continue
+        }
+        if (opts.dryRun) {
+          out.push(done(at ? "installed" : "not-installed", at ? "would update it" : "would add it"))
+          continue
+        }
+        const tail = at ? text.slice(at.end) : ""
+        const next = at ? `${text.slice(0, at.start)}${block}${tail ? "\n" : ""}${tail}` : `${text}${text && !text.endsWith("\n") ? "\n" : ""}${text.trim() ? "\n" : ""}${block}`
+        // The result must parse and say what we meant; otherwise (dotted keys, inline tables elsewhere) leave the file alone.
+        const check = parseToml(next)
+        if (!check || check.mcp_servers?.[NAME]?.command !== bun) {
+          out.push(done("skipped", "the file defines mcp_servers in a way this cannot extend safely; left as it is"))
+          continue
+        }
+        writeFile(home, t.id, path, next)
+        out.push(done("installed", at ? "updated it in place" : undefined))
+        continue
+      }
+      const loaded = loadJson(path)
+      if ("error" in loaded) {
+        out.push(done("skipped", loaded.error))
+        continue
+      }
+      const cur = currentJson(t, loaded.config)
+      if ("error" in cur) {
+        out.push(done("skipped", cur.error))
+        continue
+      }
+      if (cur.entry !== undefined && !isOurs(cur.entry)) {
+        out.push(done("skipped", `it already has an entry named "${NAME}" that is not this brain's; left as it is`))
+        continue
+      }
+      const fresh = t.entry!(bunCommand(), args)
+      if (cur.entry !== undefined && JSON.stringify(cur.entry) === JSON.stringify(fresh)) {
+        out.push(done("already-installed"))
+        continue
+      }
+      if (opts.dryRun) {
+        out.push(done(cur.entry !== undefined ? "installed" : "not-installed", cur.entry !== undefined ? "would update it" : "would add it"))
+        continue
+      }
+      loaded.config[t.key!] ??= {}
+      loaded.config[t.key!][NAME] = fresh
+      writeFile(home, t.id, path, `${JSON.stringify(loaded.config, null, loaded.indent)}\n`)
+      out.push(done("installed", cur.entry !== undefined ? "updated it in place" : undefined))
+    } catch (e) {
+      out.push(done("skipped", (e as Error).message))
+    }
+  }
+  return out
+}
+
+export function uninstallMcp(tools: string[], home: string, opts: Opts = {}): McpChange[] {
+  const out: McpChange[] = []
+  for (const tool of [...new Set(tools)]) {
+    const p = prepare(tool, home)
+    if (!("t" in p)) {
+      out.push(p)
+      continue
+    }
+    const { t, path } = p
+    const done = (action: McpChange["action"], why?: string): McpChange => ({ tool: t.id, path, action, ...(why ? { why } : {}) })
+    const noBackup = !existsSync(backupPath(home, t.id, path))
+    try {
+      if (t.format === "toml") {
+        if (!existsSync(path)) {
+          out.push(done("not-installed"))
+          continue
+        }
+        const text = readFileSync(path, "utf8")
+        if (!parseToml(text)) {
+          out.push(done("skipped", "it is not valid TOML; left as it is"))
+          continue
+        }
+        const at = findTomlBlock(text)
+        if (!at || !isOurs(parseToml(text)?.mcp_servers?.[NAME])) {
+          out.push(done("not-installed"))
+          continue
+        }
+        if (opts.dryRun) {
+          out.push(done("installed", "would remove it"))
+          continue
+        }
+        // Take the blank line that separated the block from what came before, so repeated cycles do not grow the file.
+        const before = text.slice(0, at.start).replace(/\n\n$/, "\n")
+        const next = `${before}${text.slice(at.end)}`
+        if (!next.trim() && noBackup) unlinkSync(path)
+        else writeFile(home, t.id, path, next)
+        out.push(done("removed"))
+        continue
+      }
+      const loaded = loadJson(path)
+      if ("error" in loaded) {
+        out.push(done("skipped", loaded.error))
+        continue
+      }
+      const cur = currentJson(t, loaded.config)
+      if ("error" in cur) {
+        out.push(done("skipped", cur.error))
+        continue
+      }
+      if (cur.entry === undefined || !isOurs(cur.entry)) {
+        out.push(done("not-installed", cur.entry === undefined ? undefined : `an entry named "${NAME}" exists but is not this brain's; left as it is`))
+        continue
+      }
+      if (opts.dryRun) {
+        out.push(done("installed", "would remove it"))
+        continue
+      }
+      const config = loaded.config
+      delete config[t.key!][NAME]
+      if (!Object.keys(config[t.key!]).length) delete config[t.key!]
+      if (!Object.keys(config).length && noBackup) unlinkSync(path)
+      else writeFile(home, t.id, path, `${JSON.stringify(config, null, loaded.indent)}\n`)
+      out.push(done("removed"))
+    } catch (e) {
+      out.push(done("skipped", (e as Error).message))
+    }
+  }
+  return out
+}
+
+/** Read-only: for each tool, whether the entry is in its config. */
+export function statusMcp(home: string): McpChange[] {
+  return MCP_TOOLS.map((t) => {
+    const path = configPath(t, home)
+    if (!hasRun(t, home)) return { tool: t.id, path, action: "skipped" as const, why: `${t.label} has not run on this machine` }
+    if (t.format === "toml") {
+      if (!existsSync(path)) return { tool: t.id, path, action: "not-installed" as const }
+      const parsed = parseToml(readFileSync(path, "utf8"))
+      if (!parsed) return { tool: t.id, path, action: "skipped" as const, why: "it is not valid TOML" }
+      return { tool: t.id, path, action: isOurs(parsed.mcp_servers?.[NAME]) ? ("installed" as const) : ("not-installed" as const) }
+    }
+    const loaded = loadJson(path)
+    if ("error" in loaded) return { tool: t.id, path, action: "skipped" as const, why: loaded.error }
+    const cur = currentJson(t, loaded.config)
+    if ("error" in cur) return { tool: t.id, path, action: "skipped" as const, why: cur.error }
+    return { tool: t.id, path, action: isOurs(cur.entry) ? ("installed" as const) : ("not-installed" as const) }
+  })
+}
+
+// ---- the command ----
+
+const flag = (args: string[], name: string) => {
+  const i = args.indexOf(name)
+  return i >= 0 ? args[i + 1] : undefined
+}
+
+export async function mcpCommand(args: string[], home: string): Promise<number> {
+  const [action, ...rest] = args
+  const say = (s: string) => console.log(s)
+  if (action === "serve") {
+    // stdout belongs to the protocol: nothing else may be printed here.
+    const p = flag(rest, "--project")
+    const project: ProjectKey | undefined = p ? { id: p, label: p.split("/").pop() || p } : undefined
+    await runMcpServer({ home, ...(project ? { project } : {}) })
+    return 0
+  }
+  if (action === "install" || action === "uninstall" || action === "status") {
+    const tool = flag(rest, "--tool")
+    const ids = tool ? [tool] : MCP_TOOLS.map((t) => t.id)
+    const dryRun = rest.includes("--dry-run")
+    const changes = action === "install" ? installMcp(ids, home, { dryRun }) : action === "uninstall" ? uninstallMcp(ids, home, { dryRun }) : tool ? statusMcp(home).filter((c) => c.tool === tool) : statusMcp(home)
+    if (!changes.length) {
+      say(`no tool "${tool}"; available: ${MCP_TOOLS.map((t) => t.id).join(", ")}`)
+      return 1
+    }
+    for (const c of changes) say(`${c.tool}: ${c.action}${c.path ? ` (${c.path})` : ""}${c.why ? ` - ${c.why}` : ""}`)
+    if (action === "install" && !dryRun && changes.some((c) => c.action === "installed")) say("restart the tool for it to pick up the brain MCP server")
+    return tool && changes.every((c) => c.action === "skipped") ? 1 : 0
+  }
+  say("usage: brain mcp serve [--project <id>] | install|uninstall|status [--tool <id>] [--dry-run]")
+  return action ? 1 : 0
+}