@bsbofmusic/agent-reach-mcp 0.1.0

package/README.md

@@ -0,0 +1,20 @@
+# Agent-Reach MCP (stdio)
+
+A minimal MCP stdio server for OpenCode / CC-Switch.
+
+## What it does
+
+- Creates a Python venv under user cache directory
+- On **every tool call**, upgrades Agent-Reach from GitHub `main.zip`
+- Exposes MCP tools:
+  - `reach_ensure`
+  - `reach_doctor`
+  - `reach_read`
+
+> This package prioritizes "always latest" behavior.
+
+## Install / run locally
+
+```bash
+npm install
+node index.js

package/index.js

@@ -0,0 +1,263 @@
+import os from "node:os";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { spawn } from "node:child_process";
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+
+/**
+ * A minimal, robust MCP stdio server that:
+ * - Creates a Python venv under user cache dir
+ * - On EVERY tool call, upgrades Agent-Reach from GitHub main.zip
+ * - Executes `agent-reach` via the venv (fallback to python -m ...)
+ *
+ * NOTE: This favors "latest" over strict stability, per your requirement.
+ */
+
+function isWindows() {
+  return process.platform === "win32";
+}
+
+function userCacheDir(appName) {
+  if (isWindows()) {
+    const base =
+      process.env.LOCALAPPDATA ||
+      path.join(os.homedir(), "AppData", "Local");
+    return path.join(base, appName);
+  }
+  if (process.platform === "darwin") {
+    return path.join(os.homedir(), "Library", "Caches", appName);
+  }
+  const base = process.env.XDG_CACHE_HOME || path.join(os.homedir(), ".cache");
+  return path.join(base, appName);
+}
+
+async function ensureDir(p) {
+  await fs.mkdir(p, { recursive: true });
+}
+
+function run(cmd, args, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? 10 * 60 * 1000;
+  const cwd = opts.cwd;
+  const env = opts.env ?? process.env;
+
+  return new Promise((resolve) => {
+    const child = spawn(cmd, args, {
+      cwd,
+      env,
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true,
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout.on("data", (d) => (stdout += d.toString()));
+    child.stderr.on("data", (d) => (stderr += d.toString()));
+
+    const t = setTimeout(() => {
+      try {
+        child.kill("SIGKILL");
+      } catch {}
+      resolve({
+        code: 124,
+        stdout,
+        stderr: stderr + `\n[timeout] ${cmd} ${args.join(" ")}`,
+      });
+    }, timeoutMs);
+
+    child.on("close", (code) => {
+      clearTimeout(t);
+      resolve({ code: code ?? 1, stdout, stderr });
+    });
+  });
+}
+
+function venvPaths(root) {
+  const venvDir = path.join(root, "venv");
+  if (isWindows()) {
+    return {
+      venvDir,
+      pythonExe: path.join(venvDir, "Scripts", "python.exe"),
+      agentReachExe: path.join(venvDir, "Scripts", "agent-reach.exe"),
+    };
+  }
+  return {
+    venvDir,
+    pythonExe: path.join(venvDir, "bin", "python"),
+    agentReachExe: path.join(venvDir, "bin", "agent-reach"),
+  };
+}
+
+async function createVenvIfMissing(root) {
+  await ensureDir(root);
+  const { venvDir, pythonExe } = venvPaths(root);
+
+  if (existsSync(pythonExe)) return;
+
+  // Try creating venv using system python.
+  // Windows: python, then py -3
+  const candidates = isWindows()
+    ? [
+        { cmd: "python", args: ["-m", "venv", venvDir] },
+        { cmd: "py", args: ["-3", "-m", "venv", venvDir] },
+      ]
+    : [
+        { cmd: "python3", args: ["-m", "venv", venvDir] },
+        { cmd: "python", args: ["-m", "venv", venvDir] },
+      ];
+
+  let last = null;
+  for (const c of candidates) {
+    last = await run(c.cmd, c.args, { timeoutMs: 2 * 60 * 1000 });
+    if (last.code === 0 && existsSync(pythonExe)) break;
+  }
+
+  if (!existsSync(pythonExe)) {
+    const tried = candidates.map((c) => `${c.cmd} ${c.args.join(" ")}`).join(" | ");
+    const err = last?.stderr || "";
+    throw new Error(
+      `Failed to create Python venv.\nTried: ${tried}\nLast stderr:\n${err}`
+    );
+  }
+}
+
+async function ensureLatestAgentReach(root) {
+  await createVenvIfMissing(root);
+  const { pythonExe, agentReachExe } = venvPaths(root);
+
+  // Upgrade pip tooling (best effort)
+  await run(pythonExe, ["-m", "pip", "install", "-U", "pip", "setuptools", "wheel"], {
+    timeoutMs: 5 * 60 * 1000,
+  });
+
+  // Your "always latest" requirement:
+  const pkgUrl = "https://github.com/Panniantong/agent-reach/archive/main.zip";
+  const installRes = await run(pythonExe, ["-m", "pip", "install", "-U", pkgUrl], {
+    timeoutMs: 10 * 60 * 1000,
+  });
+
+  let log = `pip install -U ${pkgUrl}\nexit=${installRes.code}\n`;
+  if (installRes.stdout.trim()) log += `stdout:\n${installRes.stdout}\n`;
+  if (installRes.stderr.trim()) log += `stderr:\n${installRes.stderr}\n`;
+
+  if (installRes.code !== 0) {
+    throw new Error(`Failed to install/upgrade Agent-Reach.\n\n${log}`);
+  }
+
+  if (!existsSync(agentReachExe)) {
+    log += `warning: agent-reach executable not found at ${agentReachExe}\n`;
+  }
+
+  return { pythonExe, agentReachExe, ensureLog: log };
+}
+
+async function runAgentReach(root, args) {
+  const { pythonExe, agentReachExe, ensureLog } = await ensureLatestAgentReach(root);
+
+  let execRes;
+  if (existsSync(agentReachExe)) {
+    execRes = await run(agentReachExe, args, { timeoutMs: 10 * 60 * 1000 });
+  } else {
+    // Fallback: module import. (May vary; best effort.)
+    execRes = await run(pythonExe, ["-m", "agent_reach", ...args], {
+      timeoutMs: 10 * 60 * 1000,
+    });
+  }
+
+  let out = `# ensure_latest\n${ensureLog}\n`;
+  out += `# agent-reach ${args.join(" ")}\nexit=${execRes.code}\n`;
+  if (execRes.stdout.trim()) out += `stdout:\n${execRes.stdout}\n`;
+  if (execRes.stderr.trim()) out += `stderr:\n${execRes.stderr}\n`;
+
+  return { out, code: execRes.code };
+}
+
+function text(content) {
+  return [{ type: "text", text: content }];
+}
+
+async function main() {
+  const server = new Server(
+    { name: "agent-reach-mcp", version: "0.1.0" },
+    { capabilities: { tools: {} } }
+  );
+
+  const cacheRoot = userCacheDir("agent-reach-mcp");
+  const runtimeRoot = path.join(cacheRoot, "runtime");
+  await ensureDir(runtimeRoot);
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+      tools: [
+        {
+          name: "reach_ensure",
+          description:
+            "Ensure venv exists and Agent-Reach is upgraded to latest main. Returns install logs.",
+          inputSchema: { type: "object", properties: {} },
+        },
+        {
+          name: "reach_doctor",
+          description: "Run `agent-reach doctor` (auto-updates Agent-Reach first).",
+          inputSchema: { type: "object", properties: {} },
+        },
+        {
+          name: "reach_read",
+          description: "Run `agent-reach read <url>` (auto-updates Agent-Reach first).",
+          inputSchema: {
+            type: "object",
+            properties: {
+              url: { type: "string", description: "URL to read (http/https)" },
+            },
+            required: ["url"],
+          },
+        },
+      ],
+    };
+  });
+
+  server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const name = req.params.name;
+    const input = req.params.arguments ?? {};
+
+    try {
+      if (name === "reach_ensure") {
+        const { ensureLog } = await ensureLatestAgentReach(runtimeRoot);
+        return { content: text(ensureLog) };
+      }
+
+      if (name === "reach_doctor") {
+        const { out, code } = await runAgentReach(runtimeRoot, ["doctor"]);
+        return { content: text(out), isError: code !== 0 };
+      }
+
+      if (name === "reach_read") {
+        const url = String(input.url ?? "");
+        if (!url || !/^https?:\/\//i.test(url)) {
+          return { content: text("Invalid url. Must start with http(s)://"), isError: true };
+        }
+        const { out, code } = await runAgentReach(runtimeRoot, ["read", url]);
+        return { content: text(out), isError: code !== 0 };
+      }
+
+      return { content: text(`Unknown tool: ${name}`), isError: true };
+    } catch (e) {
+      const msg = e?.stack || e?.message || String(e);
+      return { content: text(`Error:\n${msg}`), isError: true };
+    }
+  });
+
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+main().catch((e) => {
+  console.error(e?.stack || e?.message || String(e));
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@bsbofmusic/agent-reach-mcp",
+  "version": "0.1.0",
+  "description": "MCP stdio server that auto-installs/updates Agent-Reach and exposes reach_* tools.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "agent-reach-mcp": "index.js"
+  },
+  "files": [
+    "index.js",
+    "README.md"
+  ],
+  "scripts": {
+    "start": "node index.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.17.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}