aether-code 0.11.1 → 0.12.0

package/README.md

@@ -78,12 +78,27 @@ aether balance        # check credits
 Configure servers with one command — no JSON editing:
 
 ```bash
-aether mcp add filesystem -- npx -y @modelcontextprotocol/server-filesystem /data
+# Browse the curated registry
+aether mcp search browser
+aether mcp search             # everything available
+
+# One-command install for well-known servers (interactive prompts for any required values)
+aether mcp install filesystem      # prompts for the path
+aether mcp install playwright      # no inputs needed — just installs
+aether mcp install github          # prompts for your GitHub token
+aether mcp install postgres        # prompts for connection string
+
+# Manual install for anything else (e.g. local Python servers like IDA Pro)
 aether mcp add ida --env IDA_PATH=/opt/ida -- python -m ida_pro_mcp
-aether mcp add playwright -- npx -y @playwright/mcp
+aether mcp add roblox -- npx -y robloxstudio-mcp
+
+# Inspect + manage
 aether mcp list
+aether mcp remove ida
 ```
 
+Built-in registry covers the official MCP servers (filesystem, github, gitlab, postgres, sqlite, puppeteer, playwright, slack, google-drive, fetch, memory, everart). For Python-based or community servers, use `aether mcp add` with the full command.
+
 On the next `aether` launch you'll see:
 
 ```

package/bin/aether-code.js

@@ -16,9 +16,17 @@ import { fetchBalance, AetherError } from "../src/api.js";
 import { writeConfigFile, getConfig, CONFIG_PATH } from "../src/config.js";
 import { loadMcpConfig, MCPManager } from "../src/mcp.js";
 import { addServer, removeServer, listServers } from "../src/mcp-cli.js";
+import {
+  MCP_REGISTRY,
+  findRegistryEntry,
+  resolveEntry,
+  searchRegistry,
+  suggestSimilar,
+} from "../src/mcp-registry.js";
+import readline from "node:readline";
 import { c, errorLine, divider } from "../src/render.js";
 
-const VERSION = "0.11.1";
+const VERSION = "0.12.0";
 
 /**
  * Try to start MCP servers from ~/.aether/mcp.json. Returns a started
@@ -65,7 +73,7 @@ ${c.bold("SUBCOMMANDS")}
   ${c.cyan("logout")}                               Clear saved API key
   ${c.cyan("balance")}                              Show plan + credit balance
   ${c.cyan("config")} show|set|set-base|path        Manage config file
-  ${c.cyan("mcp")} list|add|remove                  Manage MCP server connections
+  ${c.cyan("mcp")} list|search|install|add|remove   Manage MCP server connections
 
 ${c.bold("EXAMPLES")}
   aether                               # interactive REPL
@@ -348,12 +356,100 @@ async function handleMcp(rest) {
     return;
   }
 
+  if (sub === "search" || sub === "find") {
+    const query = rest.slice(1).join(" ").trim();
+    const results = searchRegistry(query);
+    if (results.length === 0) {
+      console.log(c.gray(`No MCP servers in the registry match "${query}".`));
+      console.log(c.gray("Browse the full list: ") + c.cyan("aether mcp search"));
+      return;
+    }
+    console.log(
+      c.bold(query ? `MCP servers matching "${query}":` : `Available MCP servers (${results.length}):`),
+    );
+    for (const e of results) {
+      const sourceTag = e.source === "official"
+        ? c.gray("(official)")
+        : c.yellow("(community)");
+      console.log(`  ${c.cyan(e.id.padEnd(16))} ${sourceTag}  ${e.description}`);
+    }
+    console.log("");
+    console.log(c.gray("Install one with: ") + c.cyan("aether mcp install <name>"));
+    return;
+  }
+
+  if (sub === "install" || sub === "get") {
+    const name = rest[1];
+    if (!name) {
+      die(
+        "aether mcp install: missing <name>.\n" +
+          "Try `aether mcp search` to see what's available.",
+      );
+    }
+    const entry = findRegistryEntry(name);
+    if (!entry) {
+      const suggestions = suggestSimilar(name);
+      let msg = `aether mcp install: unknown server "${name}".`;
+      if (suggestions.length > 0) {
+        msg += `\nDid you mean: ${suggestions.map((s) => c.cyan(s)).join(", ")}?`;
+      } else {
+        msg += `\nTry \`aether mcp search\` to browse the registry.`;
+      }
+      die(msg);
+    }
+    // Prompt for any required values (placeholders in args + env)
+    const allRequired = [...(entry.requires ?? []), ...(entry.requiresEnv ?? [])];
+    const values = {};
+    if (allRequired.length > 0) {
+      console.log(c.gray(`Installing ${c.cyan(entry.id)} — needs ${allRequired.length} input${allRequired.length === 1 ? "" : "s"}:`));
+      for (const key of allRequired) {
+        const promptText = entry.prompts?.[key] ?? key;
+        // eslint-disable-next-line no-await-in-loop -- sequential prompts are intentional
+        values[key] = await promptUser(`  ${promptText}: `);
+        if (!values[key]) die(`Cancelled — "${key}" is required.`);
+      }
+    }
+    let resolved;
+    try {
+      resolved = resolveEntry(entry, values);
+    } catch (e) {
+      die(e.message);
+    }
+    try {
+      const added = addServer({
+        name: entry.id,
+        command: resolved.command,
+        args: resolved.args,
+        env: resolved.env,
+      });
+      console.log(`${c.green("✓")} Installed MCP server "${c.cyan(entry.id)}".`);
+      console.log(c.gray(`  ${added.command}${added.args ? " " + added.args.join(" ") : ""}`));
+      console.log(c.gray("Restart aether (or run `aether`) to attach it."));
+    } catch (e) {
+      die(e.message || String(e));
+    }
+    return;
+  }
+
   die(
     `aether mcp: unknown subcommand "${sub}".\n` +
-      "Try one of: list, add, remove.",
+      "Try one of: list, add, install, search, remove.",
   );
 }
 
+function promptUser(question) {
+  if (!process.stdin.isTTY) {
+    return Promise.reject(new Error("Interactive prompt unavailable (non-TTY)"));
+  }
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
 main().catch((err) => {
   console.error(errorLine(err.message || String(err)));
   if (process.env.DEBUG) console.error(err);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aether-code",
-  "version": "0.11.1",
+  "version": "0.12.0",
   "description": "Uncensored AI coding agent for your terminal — Claude Code alternative with MCP support. Reads code, writes files, runs commands. Drives IDA Pro, Roblox Studio, Wireshark, Blender, and any MCP server. No refusal layer.",
   "homepage": "https://trynoguard.com",
   "repository": {
@@ -23,7 +23,7 @@
     "node": ">=18"
   },
   "scripts": {
-    "lint": "node --check bin/aether-code.js src/agent.js src/api.js src/config.js src/render.js src/tools.js src/diff.js src/repl.js src/mcp.js src/mcp-cli.js src/skills.js",
+    "lint": "node --check bin/aether-code.js src/agent.js src/api.js src/config.js src/render.js src/tools.js src/diff.js src/repl.js src/mcp.js src/mcp-cli.js src/mcp-registry.js src/skills.js",
     "test": "node --test \"test/**/*.test.js\""
   },
   "keywords": [

package/src/mcp-registry.js

@@ -0,0 +1,266 @@
+// Curated registry of well-known MCP servers users can install with
+// `aether mcp install <name>` instead of typing the full npx command.
+//
+// Conservative inclusion criteria:
+//   1. Published to npm under a known scope (@modelcontextprotocol/*,
+//      @playwright/*, etc.) OR widely-cited community packages
+//   2. stdio transport (which is all MCPManager supports today)
+//   3. Installable via npx -y with no separate global install step
+//
+// We DON'T include servers that need a local binary (IDA Pro, Ghidra,
+// Wireshark) because the install path is environment-specific — those
+// users need to read each project's README anyway, so `mcp install` won't
+// save them work. The README shows their `mcp add` commands instead.
+//
+// Adding a new entry: confirm the package exists on npm, confirm the
+// stdio entrypoint runs cleanly with `npx -y <pkg>`, then drop in here.
+
+/**
+ * Each entry has:
+ *   id           — kebab-case name used as the MCP server name in config
+ *                 (must satisfy /^[a-z0-9_-]{1,40}$/i per mcp.js validator)
+ *   command      — base spawn command (typically "npx")
+ *   args         — array of args; entries wrapped in `{placeholder}` get
+ *                 substituted from user-provided inputs
+ *   requires     — array of placeholder names the user must supply
+ *   prompts      — { placeholder: "interactive prompt text shown to user" }
+ *   description  — one-line summary shown by `mcp list`/`mcp search`
+ *   tags         — keywords for `mcp search` matching
+ *   source       — "official" (anthropic / first-party orgs), "community"
+ */
+export const MCP_REGISTRY = [
+  {
+    id: "filesystem",
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-filesystem", "{path}"],
+    requires: ["path"],
+    prompts: { path: "Allowed filesystem path (the server will be sandboxed here)" },
+    description: "Read/write/list files under a whitelisted directory",
+    tags: ["files", "fs", "disk", "filesystem", "local"],
+    source: "official",
+  },
+  {
+    id: "github",
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-github"],
+    requires: [],
+    env: { GITHUB_PERSONAL_ACCESS_TOKEN: "{token}" },
+    requiresEnv: ["token"],
+    prompts: { token: "GitHub personal access token (https://github.com/settings/tokens — repo scope)" },
+    description: "Browse + edit GitHub repos, issues, PRs",
+    tags: ["github", "git", "repo", "issues", "pull request", "pr"],
+    source: "official",
+  },
+  {
+    id: "gitlab",
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-gitlab"],
+    requires: [],
+    env: { GITLAB_PERSONAL_ACCESS_TOKEN: "{token}", GITLAB_API_URL: "{url}" },
+    requiresEnv: ["token", "url"],
+    prompts: {
+      token: "GitLab personal access token (api scope)",
+      url: "GitLab API URL (default: https://gitlab.com/api/v4)",
+    },
+    description: "Browse + edit GitLab projects, issues, MRs",
+    tags: ["gitlab", "git", "repo", "issues", "merge request", "mr"],
+    source: "official",
+  },
+  {
+    id: "postgres",
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-postgres", "{connection}"],
+    requires: ["connection"],
+    prompts: { connection: "Postgres connection string (postgresql://user:pass@host:port/db)" },
+    description: "Query Postgres databases (read-only by default)",
+    tags: ["postgres", "postgresql", "database", "db", "sql"],
+    source: "official",
+  },
+  {
+    id: "sqlite",
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-sqlite", "{db_path}"],
+    requires: ["db_path"],
+    prompts: { db_path: "Path to the SQLite database file" },
+    description: "Query SQLite databases",
+    tags: ["sqlite", "database", "db", "sql"],
+    source: "official",
+  },
+  {
+    id: "puppeteer",
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-puppeteer"],
+    requires: [],
+    description: "Drive a headless browser via Puppeteer (navigate, screenshot, fill forms, scrape)",
+    tags: ["browser", "headless", "scrape", "puppeteer", "automation", "chrome"],
+    source: "official",
+  },
+  {
+    id: "playwright",
+    command: "npx",
+    args: ["-y", "@playwright/mcp"],
+    requires: [],
+    description: "Drive Chrome/Firefox/WebKit via Playwright (more capable than puppeteer)",
+    tags: ["browser", "playwright", "scrape", "automation", "chromium", "firefox", "webkit"],
+    source: "official",
+  },
+  {
+    id: "slack",
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-slack"],
+    requires: [],
+    env: { SLACK_BOT_TOKEN: "{bot_token}", SLACK_TEAM_ID: "{team_id}" },
+    requiresEnv: ["bot_token", "team_id"],
+    prompts: {
+      bot_token: "Slack bot token (xoxb-…)",
+      team_id: "Slack team/workspace ID (T…)",
+    },
+    description: "Read + post in Slack channels, list users, fetch threads",
+    tags: ["slack", "chat", "messaging", "workspace"],
+    source: "official",
+  },
+  {
+    id: "google-drive",
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-gdrive"],
+    requires: [],
+    description: "List + read Google Drive files (requires OAuth setup, see docs)",
+    tags: ["google", "drive", "gdrive", "files", "cloud"],
+    source: "official",
+  },
+  {
+    id: "memory",
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-memory"],
+    requires: [],
+    description: "Persistent knowledge-graph memory across agent sessions",
+    tags: ["memory", "kg", "knowledge graph", "persistence", "notes"],
+    source: "official",
+  },
+  {
+    id: "fetch",
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-fetch"],
+    requires: [],
+    description: "Fetch web pages + convert to markdown (alternative to built-in web_fetch)",
+    tags: ["http", "fetch", "web", "url", "markdown"],
+    source: "official",
+  },
+  {
+    id: "everart",
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-everart"],
+    requires: [],
+    env: { EVERART_API_KEY: "{key}" },
+    requiresEnv: ["key"],
+    prompts: { key: "EverArt API key (https://everart.ai)" },
+    description: "Generate images via EverArt",
+    tags: ["image", "generate", "art", "everart"],
+    source: "official",
+  },
+];
+
+const PLACEHOLDER_RE = /\{([a-zA-Z0-9_]+)\}/g;
+
+/**
+ * Look up a registry entry by id. Returns null for unknown names.
+ */
+export function findRegistryEntry(id) {
+  return MCP_REGISTRY.find((e) => e.id === id) ?? null;
+}
+
+/**
+ * Apply user-provided placeholder values to an entry's args + env.
+ * Returns { command, args, env } ready to pass to addServer(), or
+ * throws if a required placeholder wasn't supplied.
+ *
+ *   resolveEntry(filesystemEntry, { path: "/tmp" })
+ *   → { command: "npx", args: ["-y", "...", "/tmp"], env: {} }
+ */
+export function resolveEntry(entry, values) {
+  if (!entry) throw new Error("resolveEntry: entry is required");
+  const seen = new Set();
+  const substitute = (s) =>
+    s.replace(PLACEHOLDER_RE, (_, key) => {
+      seen.add(key);
+      const v = values?.[key];
+      if (v === undefined || v === null || v === "") {
+        throw new Error(`Missing required value for {${key}}`);
+      }
+      return String(v);
+    });
+  const args = (entry.args ?? []).map(substitute);
+  const env = {};
+  for (const [k, raw] of Object.entries(entry.env ?? {})) {
+    env[k] = substitute(raw);
+  }
+  // Sanity-check that we got every required placeholder.
+  for (const k of entry.requires ?? []) {
+    if (!seen.has(k)) {
+      // Required but never referenced in args — flag in case the registry
+      // entry is malformed. Defense in depth.
+      throw new Error(`Registry entry "${entry.id}": "${k}" listed in requires but never used`);
+    }
+  }
+  for (const k of entry.requiresEnv ?? []) {
+    if (!seen.has(k)) {
+      throw new Error(`Registry entry "${entry.id}": env placeholder "${k}" listed but never used`);
+    }
+  }
+  return { command: entry.command, args, env };
+}
+
+/**
+ * Search registry by free-text query. Matches id, description, and tags.
+ * Case-insensitive substring match. Returns entries ordered by relevance
+ * (id matches first, then tag matches, then description matches).
+ */
+export function searchRegistry(query) {
+  const q = (query || "").toLowerCase().trim();
+  if (!q) return [...MCP_REGISTRY];
+  const idHits = [];
+  const tagHits = [];
+  const descHits = [];
+  for (const e of MCP_REGISTRY) {
+    if (e.id.includes(q)) {
+      idHits.push(e);
+    } else if ((e.tags ?? []).some((t) => t.toLowerCase().includes(q))) {
+      tagHits.push(e);
+    } else if ((e.description ?? "").toLowerCase().includes(q)) {
+      descHits.push(e);
+    }
+  }
+  return [...idHits, ...tagHits, ...descHits];
+}
+
+/**
+ * For "unknown id" errors: return the closest registry ids to a typo,
+ * up to 3 suggestions. Simple edit-distance-style proximity using the
+ * length-diff + character-overlap heuristic — good enough to suggest
+ * "playwright" when the user types "playright".
+ */
+export function suggestSimilar(id) {
+  const target = id.toLowerCase();
+  const scored = MCP_REGISTRY.map((e) => ({
+    id: e.id,
+    score: similarity(target, e.id.toLowerCase()),
+  }));
+  scored.sort((a, b) => b.score - a.score);
+  return scored.filter((s) => s.score > 0.4).slice(0, 3).map((s) => s.id);
+}
+
+function similarity(a, b) {
+  if (a === b) return 1;
+  if (a.length === 0 || b.length === 0) return 0;
+  // Crude bigram-overlap. Good enough to catch one-character typos.
+  const bigrams = (s) => {
+    const out = new Set();
+    for (let i = 0; i < s.length - 1; i++) out.add(s.slice(i, i + 2));
+    return out;
+  };
+  const A = bigrams(a);
+  const B = bigrams(b);
+  let shared = 0;
+  for (const x of A) if (B.has(x)) shared++;
+  return (2 * shared) / (A.size + B.size);
+}