@manix-cli/manix 0.1.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Manindhra
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,74 @@
+# ▲ Manix
+
+A fast, beautiful terminal coding agent powered by [OpenRouter](https://openrouter.ai) —
+any model (Claude, GPT, Gemini, DeepSeek, free models), one key. Hand-written agent loop,
+no frameworks.
+
+```bash
+npm install -g manix     # or: npx manix
+cd your-project
+manix
+```
+
+First run asks for your OpenRouter API key (get one at [openrouter.ai/keys](https://openrouter.ai/keys)) —
+or `export OPENROUTER_API_KEY=...`.
+
+## What it does
+
+```
+❯ fix the failing test in src/auth.test.js
+  ● Bash(npm test)
+  ● Read(src/auth.js)
+  ● Edit(src/auth.js)          ← asks permission, shows the diff
+  ⏺ Fixed — the token expiry check was inverted. Tests pass.
+```
+
+- **Agentic loop** — streams responses, reads/writes/edits files, runs shell commands,
+  greps the repo, keeps going until the task is done.
+- **Safe by default** — mutating actions ask permission (yes / always this session / no).
+  `--yolo` to live dangerously.
+- **Any model** — `/model` opens a live picker with context windows and $/M pricing.
+- **Sessions** — every conversation is saved; `manix --continue` or `/resume`.
+- **MANIX.md** — project memory auto-loaded each session; generate with `/init`.
+- **Skills** — drop a `SKILL.md` playbook in `~/.manix/skills/<name>/` or `.manix/skills/<name>/`;
+  the agent loads it when relevant, or invoke directly with `/<name>`.
+- **MCP** — add servers to `~/.manix/mcp.json` or `.manix/mcp.json`:
+  ```json
+  { "mcpServers": { "github": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-github"] } } }
+  ```
+- **Cost tracking** — `/cost` shows session spend and remaining OpenRouter credits.
+
+## Commands
+
+| Command | | Flags | |
+|---|---|---|---|
+| `/help` | commands & shortcuts | `manix "task"` | start with a prompt |
+| `/model [id]` | switch model | `-p, --print` | non-interactive mode |
+| `/resume` | resume a session | `-m, --model <id>` | model for this run |
+| `/compact` | summarize history | `-c, --continue` | resume last session |
+| `/cost` | usage + credits | `-r, --resume [id]` | pick a session |
+| `/mcp` `/skills` | status / list | `--yolo` | auto-approve tools |
+| `/init` | generate MANIX.md | `-v` `-h` | version / help |
+| `/clear` `/yolo` `/exit` | | `echo task \| manix` | pipe a prompt |
+
+Shortcuts: **Esc** interrupt · **↑/↓** history · **Tab** complete · **Ctrl+C** twice to quit.
+
+## Skills format
+
+```markdown
+---
+name: commit
+description: Write conventional commits from the staged diff
+---
+Steps: run `git diff --staged`, group changes, write a conventional commit message…
+```
+
+## Development
+
+```bash
+npm install && npm test      # build + offline smoke tests
+npm run dev                  # build & run locally
+```
+
+Plain JavaScript (ESM) + JSX via esbuild. Ink 5 TUI. Raw-fetch OpenRouter client with a
+hand-rolled SSE parser — see [CLAUDE.md](CLAUDE.md) for the full architecture.

package/bin/manix.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import('../dist/cli.js').catch((err) => {
+  if (err?.code === 'ERR_MODULE_NOT_FOUND' && String(err.message).includes('dist')) {
+    console.error('manix: dist/ missing — run `npm run build` first.')
+  } else {
+    console.error(err)
+  }
+  process.exit(1)
+})

package/dist/agent.js

@@ -0,0 +1,194 @@
+import { streamChat, fetchModels, cachedModels } from "./openrouter.js";
+import { systemPrompt, COMPACT_PROMPT } from "./prompts.js";
+import { builtinTools, toOpenAI } from "./tools/index.js";
+import { skillTool } from "./skills.js";
+import { appendMessage, createSession } from "./sessions.js";
+class Agent {
+  constructor({ config, cwd, permissions, mcp, skills, contextFiles, handlers }) {
+    this.apiKey = config.apiKey;
+    this.model = config.model;
+    this.cwd = cwd;
+    this.permissions = permissions;
+    this.mcp = mcp;
+    this.skills = skills || [];
+    this.contextFiles = contextFiles || [];
+    this.h = handlers || {};
+    this.messages = [];
+    this.session = null;
+    this.usage = { prompt: 0, completion: 0, cost: 0, requests: 0 };
+    this.contextLength = 128e3;
+    this.ac = null;
+    fetchModels(this.apiKey).then(() => this.refreshModelInfo()).catch(() => {
+    });
+  }
+  refreshModelInfo() {
+    const m = (cachedModels() || []).find((x) => x.id === this.model);
+    if (m?.context_length) this.contextLength = m.context_length;
+    this.h.onStats?.(this.stats());
+  }
+  setModel(id) {
+    this.model = id;
+    this.refreshModelInfo();
+  }
+  get busy() {
+    return this.ac !== null;
+  }
+  pushMessage(msg) {
+    if (!this.session) this.session = createSession(this.cwd, this.model);
+    this.messages.push(msg);
+    appendMessage(this.session, msg);
+  }
+  resumeFrom(loaded) {
+    this.messages = loaded.messages;
+    this.session = { id: loaded.meta.id, file: loaded.file };
+  }
+  reset() {
+    this.messages = [];
+    this.session = null;
+  }
+  buildTools() {
+    return [...builtinTools(), skillTool(this.skills), ...this.mcp?.getTools() || []];
+  }
+  estimateTokens() {
+    return Math.round((JSON.stringify(this.messages).length + 4e3) / 4);
+  }
+  stats() {
+    return { ...this.usage, tokens: this.estimateTokens(), contextLength: this.contextLength };
+  }
+  trackUsage(usage) {
+    if (!usage) return;
+    this.usage.prompt += usage.prompt_tokens || 0;
+    this.usage.completion += usage.completion_tokens || 0;
+    this.usage.requests += 1;
+    if (typeof usage.cost === "number") {
+      this.usage.cost += usage.cost;
+    } else {
+      const m = (cachedModels() || []).find((x) => x.id === this.model);
+      if (m?.pricing) {
+        this.usage.cost += (usage.prompt_tokens || 0) * parseFloat(m.pricing.prompt || 0) + (usage.completion_tokens || 0) * parseFloat(m.pricing.completion || 0);
+      }
+    }
+    this.h.onStats?.(this.stats());
+  }
+  abort() {
+    this.ac?.abort();
+  }
+  async send(text) {
+    this.pushMessage({ role: "user", content: text });
+    await this.run();
+  }
+  async run() {
+    this.ac = new AbortController();
+    const tools = this.buildTools();
+    const toolSchemas = tools.map(toOpenAI);
+    try {
+      for (let turn = 0; turn < 40; turn++) {
+        const sys = {
+          role: "system",
+          content: systemPrompt({
+            cwd: this.cwd,
+            model: this.model,
+            contextFiles: this.contextFiles,
+            skills: this.skills
+          })
+        };
+        const res = await streamChat({
+          apiKey: this.apiKey,
+          model: this.model,
+          messages: [sys, ...this.messages],
+          tools: toolSchemas,
+          signal: this.ac.signal,
+          onText: this.h.onTextDelta
+        });
+        this.trackUsage(res.usage);
+        const assistant = { role: "assistant", content: res.content || null };
+        if (res.toolCalls.length) assistant.tool_calls = res.toolCalls;
+        this.pushMessage(assistant);
+        this.h.onAssistantDone?.(res.content);
+        if (!res.toolCalls.length) return;
+        for (const tc of res.toolCalls) {
+          const result = await this.execTool(tools, tc);
+          this.pushMessage({
+            role: "tool",
+            tool_call_id: tc.id,
+            content: result.length > 6e4 ? result.slice(0, 6e4) + "\n\u2026[truncated]" : result
+          });
+        }
+        if (this.estimateTokens() > this.contextLength * 0.8) {
+          this.h.onInfo?.("Context above 80% \u2014 run /compact to summarize and free space.");
+        }
+      }
+      this.h.onInfo?.("Stopped after 40 tool turns \u2014 send a message to continue.");
+    } catch (err) {
+      if (err?.name === "AbortError" || this.ac?.signal.aborted) {
+        this.h.onInfo?.("Interrupted.");
+      } else {
+        this.h.onError?.(err?.message || String(err));
+      }
+    } finally {
+      this.ac = null;
+    }
+  }
+  async execTool(tools, tc) {
+    const name = tc.function?.name || "";
+    const tool = tools.find((t) => t.name === name);
+    if (!tool) {
+      this.h.onToolEnd?.({ display: name, ok: false, summary: "unknown tool" });
+      return `Error: unknown tool "${name}"`;
+    }
+    let args;
+    try {
+      args = JSON.parse(tc.function.arguments || "{}");
+    } catch {
+      this.h.onToolEnd?.({ display: name, ok: false, summary: "bad arguments" });
+      return "Error: tool arguments were not valid JSON";
+    }
+    const display = tool.describe ? tool.describe(args) : name;
+    if (this.ac.signal.aborted) return "Interrupted by user before execution.";
+    const ask = this.h.requestPermission ? () => this.h.requestPermission({ display, preview: tool.preview?.(args) || null }) : null;
+    const allowed = await this.permissions.check(tool, ask);
+    if (!allowed) {
+      this.h.onToolEnd?.({ display, ok: false, summary: "permission denied" });
+      return "The user denied permission for this action. Do not retry it; ask or take another approach.";
+    }
+    this.h.onToolStart?.({ display });
+    try {
+      const out = String(await tool.run(args, { cwd: this.cwd }));
+      this.h.onToolEnd?.({ display, ok: true, summary: summarize(out) });
+      return out;
+    } catch (err) {
+      this.h.onToolEnd?.({ display, ok: false, summary: err.message });
+      return `Error: ${err.message}`;
+    }
+  }
+  /** Replace history with a model-written summary; starts a new session file. */
+  async compact() {
+    this.ac = new AbortController();
+    try {
+      const res = await streamChat({
+        apiKey: this.apiKey,
+        model: this.model,
+        messages: [...this.messages, { role: "user", content: COMPACT_PROMPT }],
+        signal: this.ac.signal
+      });
+      this.messages = [
+        { role: "user", content: "[Earlier conversation was compacted. Summary:]\n\n" + res.content },
+        { role: "assistant", content: "Got it \u2014 continuing from that summary." }
+      ];
+      this.session = createSession(this.cwd, this.model);
+      for (const m of this.messages) appendMessage(this.session, m);
+      this.h.onStats?.(this.stats());
+    } finally {
+      this.ac = null;
+    }
+  }
+}
+function summarize(out) {
+  const lines = String(out).split("\n").filter((l) => l.trim());
+  const shown = lines.slice(0, 3).map((l) => l.length > 100 ? l.slice(0, 99) + "\u2026" : l);
+  if (lines.length > 3) shown.push(`\u2026 +${lines.length - 3} lines`);
+  return shown.join("\n");
+}
+export {
+  Agent
+};

package/dist/cli.js

@@ -0,0 +1,123 @@
+import { jsx } from "react/jsx-runtime";
+import fs from "node:fs";
+import { loadConfig } from "./config.js";
+import { loadSkills } from "./skills.js";
+import { loadContextFiles } from "./manixmd.js";
+import { loadMcpConfigs, McpManager } from "./mcp.js";
+import { gradient, t, LOGO } from "./theme.js";
+const pkg = JSON.parse(fs.readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+function parseArgs(argv) {
+  const args2 = { _: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "-h" || a === "--help") args2.help = true;
+    else if (a === "-v" || a === "--version") args2.version = true;
+    else if (a === "-p" || a === "--print") args2.print = true;
+    else if (a === "-m" || a === "--model") args2.model = argv[++i];
+    else if (a === "-c" || a === "--continue") args2.resume = "last";
+    else if (a === "-r" || a === "--resume") {
+      const next = argv[i + 1];
+      if (next && !next.startsWith("-")) args2.resume = argv[++i];
+      else args2.resume = "pick";
+    } else if (a === "--yolo") args2.yolo = true;
+    else args2._.push(a);
+  }
+  return args2;
+}
+function usage() {
+  return `${gradient(`${LOGO} Manix`)} ${t.dim(`v${pkg.version} \u2014 terminal coding agent powered by OpenRouter`)}
+
+${t.bold("Usage")}
+  manix [prompt]            interactive TUI (optional starting prompt)
+  manix -p "task"           print mode (no TUI); assistant text \u2192 stdout
+  echo "task" | manix       pipe a prompt
+
+${t.bold("Flags")}
+  -m, --model <id>    OpenRouter model for this run
+  -c, --continue      resume the most recent session
+  -r, --resume [id]   pick (or load) a previous session
+      --yolo          auto-approve all tools (careful!)
+  -p, --print         non-interactive print mode
+  -v, --version       print version
+  -h, --help          this help
+
+${t.bold("Files")}
+  config    ~/.manix/config.json         sessions  ~/.manix/sessions/
+  MCP       ~/.manix/mcp.json \xB7 .manix/mcp.json
+  skills    ~/.manix/skills/<name>/SKILL.md \xB7 .manix/skills/<name>/SKILL.md
+  memory    ./MANIX.md (generate with /init)`;
+}
+const args = parseArgs(process.argv.slice(2));
+if (args.version) {
+  console.log(pkg.version);
+  process.exit(0);
+}
+if (args.help) {
+  console.log(usage());
+  process.exit(0);
+}
+const cwd = process.cwd();
+const config = loadConfig();
+if (args.model) config.model = args.model;
+let prompt = args._.join(" ").trim();
+if (!process.stdin.isTTY && !args.print) {
+  const stdin = fs.readFileSync(0, "utf8").trim();
+  if (stdin) {
+    prompt = [prompt, stdin].filter(Boolean).join("\n\n");
+    args.print = true;
+  }
+}
+const skills = loadSkills(cwd);
+const contextFiles = loadContextFiles(cwd);
+const mcp = new McpManager();
+const mcpConfigs = loadMcpConfigs(cwd);
+if (args.print) {
+  if (!config.apiKey) {
+    console.error("No API key. Run `manix` once interactively, or set OPENROUTER_API_KEY.");
+    process.exit(1);
+  }
+  if (!prompt) {
+    console.error('No prompt. Usage: manix -p "task"');
+    process.exit(1);
+  }
+  mcp.start(mcpConfigs);
+  if (Object.keys(mcpConfigs).length) await waitForMcp(mcp, 5e3);
+  const { runPrint } = await import("./print.js");
+  await runPrint({ config, cwd, prompt, yolo: !!args.yolo, mcp, skills, contextFiles });
+  await mcp.closeAll();
+  process.exit(process.exitCode || 0);
+}
+if (!process.stdout.isTTY) {
+  console.error('Interactive mode needs a TTY. Use -p "task" for print mode.');
+  process.exit(1);
+}
+mcp.start(mcpConfigs);
+const { render } = await import("ink");
+const { default: App } = await import("./ui/App.js");
+const instance = render(
+  /* @__PURE__ */ jsx(
+    App,
+    {
+      config,
+      cwd,
+      version: pkg.version,
+      mcp,
+      skills,
+      contextFiles,
+      initialPrompt: prompt || null,
+      resumeTarget: args.resume || null,
+      yolo: !!args.yolo
+    }
+  ),
+  { exitOnCtrlC: false }
+);
+await instance.waitUntilExit();
+await mcp.closeAll();
+process.exit(0);
+async function waitForMcp(manager, timeoutMs) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (manager.status().every((s) => s.status !== "connecting")) return;
+    await new Promise((r) => setTimeout(r, 100));
+  }
+}

package/dist/config.js

@@ -0,0 +1,38 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+const MANIX_DIR = path.join(os.homedir(), ".manix");
+const CONFIG_FILE = path.join(MANIX_DIR, "config.json");
+const DEFAULT_MODEL = "anthropic/claude-sonnet-4.5";
+function ensureDir(dir = MANIX_DIR) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function loadConfig() {
+  const cfg = readJson(CONFIG_FILE);
+  return {
+    model: DEFAULT_MODEL,
+    ...cfg,
+    apiKey: process.env.OPENROUTER_API_KEY || cfg.apiKey || null
+  };
+}
+function saveConfig(patch) {
+  ensureDir();
+  const next = { ...readJson(CONFIG_FILE), ...patch };
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(next, null, 2) + "\n", { mode: 384 });
+  return next;
+}
+export {
+  CONFIG_FILE,
+  DEFAULT_MODEL,
+  MANIX_DIR,
+  ensureDir,
+  loadConfig,
+  saveConfig
+};

package/dist/manixmd.js

@@ -0,0 +1,18 @@
+import fs from "node:fs";
+import path from "node:path";
+import { MANIX_DIR } from "./config.js";
+function loadContextFiles(cwd) {
+  const candidates = [path.join(MANIX_DIR, "MANIX.md"), path.join(cwd, "MANIX.md")];
+  const out = [];
+  for (const p of candidates) {
+    try {
+      const content = fs.readFileSync(p, "utf8").trim();
+      if (content) out.push({ path: p, content: content.slice(0, 2e4) });
+    } catch {
+    }
+  }
+  return out;
+}
+export {
+  loadContextFiles
+};

package/dist/markdown.js

@@ -0,0 +1,35 @@
+import { t } from "./theme.js";
+function renderMarkdown(md) {
+  const out = [];
+  let inCode = false;
+  for (const line of String(md).split("\n")) {
+    const fence = line.match(/^\s*```(\S*)/);
+    if (fence) {
+      inCode = !inCode;
+      out.push(inCode ? t.faint("\u250C\u2574" + (fence[1] || "code")) : t.faint("\u2514\u2574"));
+      continue;
+    }
+    if (inCode) {
+      out.push(t.faint("\u2502 ") + t.code(line));
+      continue;
+    }
+    out.push(renderLine(line));
+  }
+  if (inCode) out.push(t.faint("\u2514\u2574"));
+  return out.join("\n");
+}
+function renderLine(line) {
+  let m;
+  if (m = line.match(/^#{1,6}\s+(.*)$/)) return t.accent.bold(inline(m[1]));
+  if (m = line.match(/^(\s*)[-*]\s+(.*)$/)) return m[1] + t.accent("\u2022") + " " + inline(m[2]);
+  if (m = line.match(/^(\s*)(\d+)\.\s+(.*)$/)) return m[1] + t.accent(m[2] + ".") + " " + inline(m[3]);
+  if (/^\s*>\s?/.test(line)) return t.dim("\u2502 " + line.replace(/^\s*>\s?/, ""));
+  if (/^\s*([-*_])\s?(\1\s?){2,}$/.test(line)) return t.faint("\u2500".repeat(40));
+  return inline(line);
+}
+function inline(s) {
+  return s.replace(/`([^`]+)`/g, (_, c) => t.code(c)).replace(/\*\*([^*]+)\*\*/g, (_, b) => t.bold(b)).replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, txt, url) => txt + " " + t.faint(`(${url})`));
+}
+export {
+  renderMarkdown
+};

package/dist/mcp.js

@@ -0,0 +1,100 @@
+import fs from "node:fs";
+import path from "node:path";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { MANIX_DIR } from "./config.js";
+function loadMcpConfigs(cwd) {
+  const files = [path.join(MANIX_DIR, "mcp.json"), path.join(cwd, ".manix", "mcp.json")];
+  const servers = {};
+  for (const f of files) {
+    try {
+      Object.assign(servers, JSON.parse(fs.readFileSync(f, "utf8")).mcpServers || {});
+    } catch {
+    }
+  }
+  return servers;
+}
+function withTimeout(promise, ms, msg) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error(msg)), ms);
+    timer.unref?.();
+  });
+  return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}
+class McpManager {
+  constructor() {
+    this.servers = /* @__PURE__ */ new Map();
+  }
+  /** Connect all configured servers in the background; onUpdate fires per status change. */
+  start(configs, onUpdate) {
+    for (const [name, cfg] of Object.entries(configs)) {
+      const entry = { name, status: "connecting", tools: [], client: null, error: null };
+      this.servers.set(name, entry);
+      this.connect(entry, cfg).then(() => onUpdate?.(entry)).catch((err) => {
+        entry.status = "error";
+        entry.error = err.message;
+        onUpdate?.(entry);
+      });
+    }
+  }
+  async connect(entry, cfg) {
+    const client = new Client({ name: "manix", version: "0.1.0" });
+    const transport = new StdioClientTransport({
+      command: cfg.command,
+      args: cfg.args || [],
+      env: { ...process.env, ...cfg.env || {} },
+      stderr: "ignore"
+    });
+    await withTimeout(client.connect(transport), 15e3, `MCP "${entry.name}": connect timed out`);
+    const { tools } = await withTimeout(client.listTools(), 15e3, `MCP "${entry.name}": listTools timed out`);
+    entry.client = client;
+    entry.tools = tools || [];
+    entry.status = "ready";
+  }
+  /** All ready servers' tools in Manix tool shape, namespaced mcp__server__tool. */
+  getTools() {
+    const out = [];
+    for (const s of this.servers.values()) {
+      if (s.status !== "ready") continue;
+      for (const tl of s.tools) {
+        out.push({
+          name: `mcp__${s.name}__${tl.name}`,
+          safe: false,
+          // external code — always gate behind permissions
+          description: (tl.description || `${tl.name} from MCP server ${s.name}`).slice(0, 1024),
+          parameters: tl.inputSchema || { type: "object", properties: {} },
+          describe: (a) => `${s.name}:${tl.name}(${JSON.stringify(a).slice(0, 48)})`,
+          preview: (a) => JSON.stringify(a, null, 2).split("\n").slice(0, 10),
+          run: async (a) => {
+            const res = await s.client.callTool({ name: tl.name, arguments: a });
+            const text = (res.content || []).map((c) => c.type === "text" ? c.text : `[${c.type} content]`).join("\n");
+            if (res.isError) throw new Error(text || "MCP tool returned an error");
+            return text || "(no output)";
+          }
+        });
+      }
+    }
+    return out;
+  }
+  status() {
+    return [...this.servers.values()].map((s) => ({
+      name: s.name,
+      status: s.status,
+      tools: s.tools.length,
+      error: s.error
+    }));
+  }
+  async closeAll() {
+    for (const s of this.servers.values()) {
+      try {
+        await s.client?.close();
+      } catch {
+      }
+    }
+  }
+}
+export {
+  McpManager,
+  loadMcpConfigs
+};