aether-code 0.6.2 → 0.9.0

package/src/mcp.js

@@ -0,0 +1,259 @@
+// MCP (Model Context Protocol) client manager.
+//
+// Lets aether-code consume any MCP server as agent tools. Users configure
+// servers in ~/.aether/mcp.json (mirror of Claude Code's pattern):
+//
+//   {
+//     "mcpServers": {
+//       "filesystem": {
+//         "command": "npx",
+//         "args": ["-y", "@modelcontextprotocol/server-filesystem", "/some/path"]
+//       },
+//       "ida": {
+//         "command": "python",
+//         "args": ["-m", "ida_pro_mcp"],
+//         "env": { "IDA_PATH": "/opt/ida" }
+//       }
+//     }
+//   }
+//
+// Each server's tools are exposed to the model namespaced as
+// `mcp__<serverName>__<toolName>` so a `filesystem` server's `read_file`
+// doesn't collide with our built-in `read_file`. The manager handles the
+// JSON-RPC handshake, tool discovery, call routing, and cleanup on exit.
+//
+// Failure model is fail-soft per server: if `ida` fails to start (binary
+// missing, init handshake errors out), we log it and continue with the
+// servers that DID start. One bad server should not break the whole CLI.
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+
+const DEFAULT_CONFIG_PATH = path.join(os.homedir(), ".aether", "mcp.json");
+const NAMESPACE_SEP = "__";
+const NAMESPACE_PREFIX = "mcp" + NAMESPACE_SEP;
+const INIT_TIMEOUT_MS = 10_000;
+const CALL_TIMEOUT_MS = 60_000;
+
+/**
+ * Read + validate the MCP config file. Returns the parsed config or null if
+ * the file is missing (which is the normal case for users who don't use MCP).
+ * Throws on malformed JSON or schema violations so the user sees the error
+ * immediately instead of silently running without their servers.
+ */
+export function loadMcpConfig(configPath) {
+  const p = configPath || DEFAULT_CONFIG_PATH;
+  if (!fs.existsSync(p)) return null;
+  let raw;
+  try {
+    raw = fs.readFileSync(p, "utf8");
+  } catch (e) {
+    throw new Error(`MCP config exists at ${p} but isn't readable: ${e.message}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    throw new Error(`MCP config at ${p} is not valid JSON: ${e.message}`);
+  }
+  return validateMcpConfig(parsed, p);
+}
+
+export function validateMcpConfig(parsed, sourcePath = "(inline)") {
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`MCP config at ${sourcePath} must be a JSON object`);
+  }
+  const servers = parsed.mcpServers;
+  if (!servers || typeof servers !== "object" || Array.isArray(servers)) {
+    throw new Error(`MCP config at ${sourcePath} needs an "mcpServers" object`);
+  }
+  for (const [name, cfg] of Object.entries(servers)) {
+    if (!/^[a-z0-9_-]{1,40}$/i.test(name)) {
+      throw new Error(
+        `MCP server name "${name}" invalid — must be 1-40 chars of [A-Za-z0-9_-]. Used in tool namespacing.`,
+      );
+    }
+    if (!cfg || typeof cfg !== "object") {
+      throw new Error(`MCP server "${name}" entry must be an object`);
+    }
+    if (typeof cfg.command !== "string" || cfg.command.length === 0) {
+      throw new Error(`MCP server "${name}" needs a non-empty "command" string`);
+    }
+    if (cfg.args !== undefined && !Array.isArray(cfg.args)) {
+      throw new Error(`MCP server "${name}".args must be an array of strings`);
+    }
+    if (Array.isArray(cfg.args) && cfg.args.some((a) => typeof a !== "string")) {
+      throw new Error(`MCP server "${name}".args must be an array of STRINGS`);
+    }
+    if (cfg.env !== undefined && (typeof cfg.env !== "object" || Array.isArray(cfg.env))) {
+      throw new Error(`MCP server "${name}".env must be an object {KEY: value}`);
+    }
+  }
+  return parsed;
+}
+
+/**
+ * Build the `mcp__<server>__<tool>` namespaced tool name. Defense against
+ * underscores in the user-defined server name accidentally collapsing the
+ * boundary (config validation already rejects those, but we double-check
+ * here since this string is what the model sees).
+ */
+export function namespaceToolName(serverName, toolName) {
+  if (serverName.includes(NAMESPACE_SEP) || toolName.includes(NAMESPACE_SEP)) {
+    // Replace with a single underscore so the boundary stays unambiguous.
+    return (
+      NAMESPACE_PREFIX +
+      serverName.replaceAll(NAMESPACE_SEP, "_") +
+      NAMESPACE_SEP +
+      toolName.replaceAll(NAMESPACE_SEP, "_")
+    );
+  }
+  return NAMESPACE_PREFIX + serverName + NAMESPACE_SEP + toolName;
+}
+
+/**
+ * Inverse of namespaceToolName: split a `mcp__server__tool` name back into
+ * its parts. Returns null if the name doesn't follow the convention (i.e.
+ * it's a built-in tool, not an MCP one).
+ */
+export function unnamespaceToolName(namespaced) {
+  if (!namespaced.startsWith(NAMESPACE_PREFIX)) return null;
+  const rest = namespaced.slice(NAMESPACE_PREFIX.length);
+  const sepIdx = rest.indexOf(NAMESPACE_SEP);
+  if (sepIdx <= 0 || sepIdx >= rest.length - NAMESPACE_SEP.length) return null;
+  return {
+    serverName: rest.slice(0, sepIdx),
+    toolName: rest.slice(sepIdx + NAMESPACE_SEP.length),
+  };
+}
+
+export class MCPManager {
+  constructor() {
+    this.servers = new Map(); // name -> { client, transport, tools: [...] }
+    this.startErrors = []; // [{ serverName, error }]
+  }
+
+  /**
+   * Start every server in the config. Failures are collected (in
+   * `startErrors`) rather than thrown so one bad server doesn't kill the
+   * CLI. Returns the count of successfully-started servers.
+   */
+  async start(config) {
+    if (!config || !config.mcpServers) return 0;
+    const entries = Object.entries(config.mcpServers);
+    await Promise.allSettled(
+      entries.map(async ([name, cfg]) => {
+        try {
+          await this.#startOne(name, cfg);
+        } catch (e) {
+          this.startErrors.push({ serverName: name, error: e.message || String(e) });
+        }
+      }),
+    );
+    return this.servers.size;
+  }
+
+  async #startOne(name, cfg) {
+    const transport = new StdioClientTransport({
+      command: cfg.command,
+      args: cfg.args ?? [],
+      env: { ...process.env, ...(cfg.env ?? {}) },
+    });
+    const client = new Client(
+      { name: "aether-code", version: "0.9.0" },
+      { capabilities: {} },
+    );
+    // Bound the init handshake so a hung server doesn't stall startup.
+    await withTimeout(client.connect(transport), INIT_TIMEOUT_MS, `MCP server "${name}" init`);
+    const toolList = await withTimeout(client.listTools(), INIT_TIMEOUT_MS, `MCP server "${name}" listTools`);
+    const tools = (toolList?.tools ?? []).map((t) => ({
+      originalName: t.name,
+      namespacedName: namespaceToolName(name, t.name),
+      description: t.description ?? "",
+      inputSchema: t.inputSchema ?? { type: "object", properties: {} },
+    }));
+    this.servers.set(name, { client, transport, tools });
+  }
+
+  /**
+   * Returns OpenAI-format tool definitions for every connected MCP tool,
+   * ready to merge into TOOL_DEFINITIONS for the agent loop.
+   */
+  getToolDefinitions() {
+    const out = [];
+    for (const { tools } of this.servers.values()) {
+      for (const t of tools) {
+        out.push({
+          type: "function",
+          function: {
+            name: t.namespacedName,
+            description: t.description || `(MCP tool ${t.originalName})`,
+            parameters: t.inputSchema,
+          },
+        });
+      }
+    }
+    return out;
+  }
+
+  /**
+   * Resolve a namespaced tool name to the right server + original name.
+   * Returns null if the name isn't an MCP tool or no server matches.
+   */
+  resolve(namespacedName) {
+    const split = unnamespaceToolName(namespacedName);
+    if (!split) return null;
+    const server = this.servers.get(split.serverName);
+    if (!server) return null;
+    return { server, serverName: split.serverName, toolName: split.toolName };
+  }
+
+  /**
+   * Invoke a namespaced MCP tool. Returns { ok, output } matching the
+   * shape executeTool() uses for built-in tools.
+   */
+  async callTool(namespacedName, args) {
+    const resolved = this.resolve(namespacedName);
+    if (!resolved) {
+      return { ok: false, output: `Unknown MCP tool: ${namespacedName}` };
+    }
+    try {
+      const result = await withTimeout(
+        resolved.server.client.callTool({
+          name: resolved.toolName,
+          arguments: args,
+        }),
+        CALL_TIMEOUT_MS,
+        `MCP tool ${namespacedName}`,
+      );
+      // MCP tool results are { content: [{type, text|data, ...}], isError? }
+      const textParts = (result?.content ?? [])
+        .filter((c) => c.type === "text")
+        .map((c) => c.text);
+      const text = textParts.join("\n") || JSON.stringify(result, null, 2);
+      return { ok: !result?.isError, output: text };
+    } catch (e) {
+      return { ok: false, output: `MCP call ${namespacedName} failed: ${e.message}` };
+    }
+  }
+
+  async shutdown() {
+    const tasks = [];
+    for (const { client } of this.servers.values()) {
+      tasks.push(client.close().catch(() => {}));
+    }
+    await Promise.allSettled(tasks);
+    this.servers.clear();
+  }
+}
+
+function withTimeout(promise, ms, label) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
+  });
+  return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}

package/src/render.js

@@ -1,198 +1,58 @@
-// ANSI helpers — no chalk dependency. Designed to feel like Claude Code:
-// bordered banner, indented tool calls, structured tool-result rendering.
-
-const isTty = process.stdout.isTTY;
-const noColor = !!process.env.NO_COLOR || !isTty;
-
-function wrap(open, close) {
-  return (s) => (noColor ? String(s) : `\x1b[${open}m${s}\x1b[${close}m`);
-}
-
-export const c = {
-  bold:    wrap(1, 22),
-  dim:     wrap(2, 22),
-  italic:  wrap(3, 23),
-  red:     wrap(31, 39),
-  green:   wrap(32, 39),
-  yellow:  wrap(33, 39),
-  blue:    wrap(34, 39),
-  magenta: wrap(35, 39),
-  cyan:    wrap(36, 39),
-  gray:    wrap(90, 39),
-  white:   wrap(37, 39),
-};
-
-const W = () => Math.min(process.stdout.columns || 80, 90);
-
-export function hr() {
-  return c.gray("─".repeat(W()));
-}
-
-export function divider() {
-  return hr();
-}
-
-/* ─── Banner — Claude-Code-style box ─── */
-
-export function banner({ version, model, mode, balance, cwd }) {
-  const w = Math.min(W(), 78);
-  const top = c.gray("╭" + "─".repeat(w - 2) + "╮");
-  const bot = c.gray("╰" + "─".repeat(w - 2) + "╯");
-  const pad = (line) => {
-    // Strip ANSI for length calc
-    const visible = line.replace(/\x1b\[[0-9;]*m/g, "");
-    const space = Math.max(0, w - 2 - visible.length - 2);
-    return c.gray("│ ") + line + " ".repeat(space) + c.gray(" │");
-  };
-  const blank = pad("");
-  const title = pad(`${c.magenta(c.bold("✻ aether-code"))}  ${c.gray("v" + version)}`);
-  const sub = pad(`${c.gray(model + " · uncensored · " + mode + (balance != null ? "  ·  " + balance.toLocaleString() + " credits" : ""))}`);
-  const cwdLine = pad(c.gray("📁 " + truncatePath(cwd, w - 6)));
-  const tip = pad(c.gray("Type ") + c.cyan("/help") + c.gray(" for shortcuts. ") + c.cyan("/exit") + c.gray(" or Ctrl+C twice to quit."));
-  return [top, blank, title, sub, cwdLine, blank, tip, bot].join("\n");
-}
-
-function truncatePath(p, max) {
-  if (!p) return "";
-  if (p.length <= max) return p;
-  return "…" + p.slice(-(max - 1));
-}
-
-/* ─── Turn / cost line ─── */
-
-export function turnLine(n) {
-  return c.dim("─── turn " + n + " " + "─".repeat(Math.max(0, W() - 12 - String(n).length)));
-}
-
-export function costLine({ creditsCharged, inputTokens, outputTokens, finishReason }) {
-  const parts = [
-    `${creditsCharged} cr`,
-    `${inputTokens}→${outputTokens} tok`,
-    finishReason ? `finish: ${finishReason}` : null,
-  ].filter(Boolean);
-  return "  " + c.dim(parts.join(" · "));
-}
-
-/* ─── Assistant text ─── */
-
-export function assistantPrefix() {
-  return c.magenta("● ") + c.bold(c.magenta("Aether")) + c.gray(":");
-}
-
-/* ─── Tool calls — friendly labels instead of raw JSON ─── */
-
-export function toolAnnounce(name, args) {
-  const label = TOOL_LABELS[name] ? TOOL_LABELS[name](args) : `${name}(${jsonPreview(args)})`;
-  return c.cyan("  ⚡ ") + c.bold(c.cyan(name)) + c.gray("  ") + c.gray(label);
-}
-
-const TOOL_LABELS = {
-  read_file: (a) => `→ ${a.path || "?"}`,
-  list_dir: (a) => `→ ${a.path || "."}`,
-  search_files: (a) => `→ ${a.pattern || "?"} in ${a.path || "."}`,
-  write_file: (a) => `→ ${a.path || "?"}  ${c.gray("(" + (a.content?.length || 0) + " bytes)")}`,
-  edit_file: (a) => `→ ${a.path || "?"}`,
-  run_shell: (a) => `${c.yellow("$")} ${a.command || "?"}` + (a.cwd && a.cwd !== "." ? c.gray(`  (cwd: ${a.cwd})`) : ""),
-};
-
-function jsonPreview(obj) {
-  const s = JSON.stringify(obj);
-  return s.length > 80 ? s.slice(0, 77) + "..." : s;
-}
-
-/* ─── Tool results — structured render per tool ─── */
-
-export function toolResultLine(name, result) {
-  const icon = result.ok ? c.green("  ✓") : c.red("  ✗");
-  const summary = summarizeResult(name, result);
-  return `${icon} ${c.dim(summary)}`;
-}
-
-function summarizeResult(name, result) {
-  if (!result.ok) {
-    // Try to extract a useful one-liner from error JSON
-    let txt = result.output || "";
-    try {
-      const j = JSON.parse(txt);
-      if (j.exit_code !== undefined) {
-        // Shell error
-        const stderr = (j.stderr || "").trim().split("\n")[0] || "(no stderr)";
-        return `exit ${j.exit_code} — ${stderr}`;
-      }
-    } catch { /* not JSON */ }
-    const firstLine = txt.split("\n")[0];
-    return firstLine.length > 100 ? firstLine.slice(0, 97) + "..." : firstLine;
-  }
-  // Success — short summary by tool type
-  const out = result.output || "";
-  if (name === "read_file") {
-    const lines = out.split("\n").length;
-    return `read ${out.length} bytes (${lines} line${lines === 1 ? "" : "s"})`;
-  }
-  if (name === "list_dir") {
-    try {
-      const items = JSON.parse(out);
-      return `${items.length} entr${items.length === 1 ? "y" : "ies"}`;
-    } catch {
-      return "ok";
-    }
-  }
-  if (name === "search_files") {
-    try {
-      const matches = JSON.parse(out);
-      return `${matches.length} match${matches.length === 1 ? "" : "es"}`;
-    } catch {
-      return "ok";
-    }
-  }
-  if (name === "write_file" || name === "edit_file") {
-    return out.split("\n")[0];
-  }
-  if (name === "run_shell") {
-    try {
-      const j = JSON.parse(out);
-      const stdoutLines = (j.stdout || "").split("\n").filter(Boolean).length;
-      return `exit ${j.exit_code} · ${stdoutLines} stdout line${stdoutLines === 1 ? "" : "s"}`;
-    } catch {
-      return "ok";
-    }
-  }
-  return out.split("\n")[0].slice(0, 80);
-}
-
-/* ─── Status line at end of turn ─── */
-
-export function statusLine({ sessionCredits, sessionIn, sessionOut, balance, history, mode }) {
-  const parts = [];
-  parts.push(`session: ${sessionCredits} cr · ${sessionIn}→${sessionOut} tok`);
-  if (balance != null) parts.push(`balance: ${balance.toLocaleString()}`);
-  if (history > 0) parts.push(`history: ${history} msg${history === 1 ? "" : "s"}`);
-  parts.push(c.cyan(mode));
-  return c.dim(parts.join("  ·  "));
-}
-
-/* ─── Errors ─── */
-
-export function errorLine(msg) {
-  return `${c.red(c.bold("✗ Error:"))} ${msg}`;
-}
-
-export function warnLine(msg) {
-  return `${c.yellow("⚠ ")} ${msg}`;
-}
-
-export function note(msg) {
-  return c.dim(msg);
-}
-
-/* ─── Confirmation prompt rendering ─── */
-
-export function confirmPrompt(label) {
-  return c.yellow("  ? ") + c.bold(label) + c.gray("  [y/N] ");
-}
-
-/* ─── Spinner / pending indicator (no animation, just text) ─── */
-
-export function pending(msg) {
-  return c.gray("  ⋯ " + msg);
-}
+// ANSI helpers — no chalk dependency.
+
+const isTty = process.stdout.isTTY;
+const noColor = !!process.env.NO_COLOR || !isTty;
+
+function wrap(open, close) {
+  return (s) => (noColor ? String(s) : `\x1b[${open}m${s}\x1b[${close}m`);
+}
+
+export const c = {
+  bold:    wrap(1, 22),
+  dim:     wrap(2, 22),
+  red:     wrap(31, 39),
+  green:   wrap(32, 39),
+  yellow:  wrap(33, 39),
+  blue:    wrap(34, 39),
+  magenta: wrap(35, 39),
+  cyan:    wrap(36, 39),
+  gray:    wrap(90, 39),
+};
+
+export function divider() {
+  const w = process.stdout.columns || 60;
+  return c.gray("─".repeat(Math.min(60, w)));
+}
+
+export function turn(n) {
+  return c.gray(`turn ${n}`);
+}
+
+export function toolHeader(name, args) {
+  // Format args compactly. If any value is huge, truncate it.
+  const compact = JSON.stringify(args);
+  const trimmed = compact.length > 120 ? compact.slice(0, 117) + "..." : compact;
+  return `${c.cyan(c.bold(name))}${c.gray("(")}${c.gray(trimmed)}${c.gray(")")}`;
+}
+
+export function toolResult(text, ok = true) {
+  const prefix = ok ? c.green("  ✓ ") : c.red("  ✗ ");
+  // First line bold-ish, then dim continuation
+  const lines = text.split("\n");
+  const head = lines[0].slice(0, 200);
+  const rest = lines.slice(1, 6).join("\n").slice(0, 600);
+  return `${prefix}${head}${rest ? "\n" + c.dim(rest) : ""}`;
+}
+
+export function assistant(text) {
+  // Indent each line for visual separation from tool calls
+  return text.split("\n").map((l) => `  ${l}`).join("\n");
+}
+
+export function errorLine(msg) {
+  return `${c.red(c.bold("Error:"))} ${msg}`;
+}
+
+export function note(msg) {
+  return c.dim(msg);
+}