@bsbofmusic/evomap-mcp-lite 0.1.0 → 0.3.0

package/index.js

@@ -1,93 +1,350 @@
 #!/usr/bin/env node
 
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import crypto from "node:crypto";
 import axios from "axios";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
+/* =========================
+   CONFIG
+========================= */
 const API = process.env.EVOMAP_API_BASE || "https://evomap.ai";
 const TIMEOUT_MS = Number(process.env.EVOMAP_TIMEOUT || "30") * 1000;
 
-function clipJson(obj, maxChars = 6000) {
+// retry settings (stability)
+const RETRY_MAX = Number(process.env.EVOMAP_RETRY_MAX || "3"); // 0..5 recommended
+const RETRY_BASE_DELAY_MS = Number(process.env.EVOMAP_RETRY_BASE_DELAY_MS || "250");
+
+// output clipping (token control)
+const MAX_RETURN_CHARS = Number(process.env.EVOMAP_MAX_RETURN_CHARS || "8000");
+
+// node identity persistence
+const DEFAULT_NODE_FILE = path.join(os.homedir(), ".evomap-mcp", "node.json");
+const NODE_FILE = process.env.EVOMAP_NODE_FILE || DEFAULT_NODE_FILE;
+
+// heartbeat throttling
+const HEARTBEAT_MIN_INTERVAL_MS = 10 * 60 * 1000; // 10 minutes
+let lastHeartbeatAt = 0;
+
+/* =========================
+   STATE (binding)
+========================= */
+const state = {
+  sender_id: null,
+  bound: null, // true/false/unknown
+  claim_code: null,
+  claim_url: null,
+  lastHelloAt: null,
+  lastHelloRaw: null
+};
+
+/* =========================
+   UTILS
+========================= */
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function newMsgId(prefix = "msg") {
+  return `${prefix}_${Date.now()}_${crypto.randomBytes(6).toString("hex")}`;
+}
+
+function clipJson(obj, maxChars = MAX_RETURN_CHARS) {
   const s = JSON.stringify(obj, null, 2);
   if (s.length <= maxChars) return s;
   return s.slice(0, maxChars) + "\n...<clipped>";
 }
 
+function ensureDirForFile(filePath) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+function loadOrCreateNodeId() {
+  if (process.env.EVOMAP_NODE_ID && process.env.EVOMAP_NODE_ID.trim()) {
+    return { sender_id: process.env.EVOMAP_NODE_ID.trim(), source: "env" };
+  }
+
+  try {
+    if (fs.existsSync(NODE_FILE)) {
+      const raw = fs.readFileSync(NODE_FILE, "utf8");
+      const obj = JSON.parse(raw);
+      if (obj?.sender_id) return { sender_id: String(obj.sender_id), source: "file" };
+    }
+  } catch {
+    // ignore
+  }
+
+  const sender_id = `node_${crypto.randomBytes(10).toString("hex")}`;
+  try {
+    ensureDirForFile(NODE_FILE);
+    fs.writeFileSync(NODE_FILE, JSON.stringify({ sender_id, created_at: nowIso() }, null, 2), "utf8");
+  } catch {
+    // ignore
+  }
+  return { sender_id, source: "generated" };
+}
+
+function makeEnvelope({ message_type, sender_id, payload }) {
+  return {
+    protocol: "gep-a2a",
+    protocol_version: "1.0.0",
+    message_type,
+    message_id: newMsgId(message_type),
+    sender_id,
+    timestamp: nowIso(),
+    payload
+  };
+}
+
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+function isRetryable(err) {
+  const status = err?.response?.status;
+  if (!status) return true;
+  if (status === 429) return true;
+  if (status >= 500) return true;
+  return false;
+}
+
 async function http(method, url, data) {
-  const res = await axios({
+  return axios({
     method,
     url,
     data,
     timeout: TIMEOUT_MS,
     headers: { "content-type": "application/json" }
+  }).then((r) => r.data);
+}
+
+async function safeCall(method, url, data) {
+  let attempt = 0;
+  while (true) {
+    try {
+      const out = await http(method, url, data);
+      return out;
+    } catch (err) {
+      attempt += 1;
+
+      const wrapped = err?.response
+        ? { error: true, status: err.response.status, data: err.response.data }
+        : { error: true, message: err?.message || String(err) };
+
+      if (attempt > RETRY_MAX || !isRetryable(err)) return wrapped;
+
+      const delay = RETRY_BASE_DELAY_MS * Math.pow(2, attempt - 1);
+      await sleep(delay);
+    }
+  }
+}
+
+function bindingNoticeIfNeeded() {
+  if (state.bound === false && state.claim_url) {
+    return `⚠️ EvoMap 账号未绑定。请用 claim 链接绑定后再长期使用：${state.claim_url}（claim_code: ${state.claim_code || "N/A"}）`;
+  }
+  return null;
+}
+
+/* =========================
+   HELLO + HEARTBEAT
+========================= */
+async function ensureHeartbeat() {
+  const now = Date.now();
+  if (now - lastHeartbeatAt < HEARTBEAT_MIN_INTERVAL_MS) return;
+
+  const payload = { node_id: state.sender_id, timestamp: nowIso() };
+  const data = await safeCall("post", `${API}/a2a/heartbeat`, payload);
+  lastHeartbeatAt = now;
+
+  if (data?.error) console.error("[evomap-lite] heartbeat failed:", data);
+}
+
+async function helloAndUpdateBinding() {
+  const env = makeEnvelope({
+    message_type: "hello",
+    sender_id: state.sender_id,
+    payload: {
+      capabilities: ["mcp", "bugfix", "asset_reuse", "validate"],
+      gene_count: 0,
+      capsule_count: 0,
+      env_fingerprint: { platform: process.platform, arch: process.arch, node: process.version }
+    }
   });
-  return res.data;
+
+  const data = await safeCall("post", `${API}/a2a/hello`, env);
+  state.lastHelloAt = nowIso();
+  state.lastHelloRaw = data;
+
+  if (data?.error) {
+    console.error("[evomap-lite] hello failed (continuing):", data);
+    state.bound = null;
+    return;
+  }
+
+  const claim_code = data?.claim_code || data?.payload?.claim_code || data?.data?.claim_code;
+  const claim_url = data?.claim_url || data?.payload?.claim_url || data?.data?.claim_url;
+
+  state.claim_code = claim_code || null;
+  state.claim_url = claim_url || null;
+  state.bound = claim_url ? false : true;
+
+  const maybeNodeId =
+    data?.your_node_id ||
+    data?.node_id ||
+    data?.payload?.your_node_id ||
+    data?.payload?.node_id;
+
+  if (maybeNodeId && typeof maybeNodeId === "string" && !process.env.EVOMAP_NODE_ID) {
+    try {
+      ensureDirForFile(NODE_FILE);
+      fs.writeFileSync(NODE_FILE, JSON.stringify({ sender_id: maybeNodeId, updated_at: nowIso() }, null, 2), "utf8");
+      state.sender_id = maybeNodeId;
+      console.error("[evomap-lite] node_id updated from hello response:", maybeNodeId);
+    } catch {
+      // ignore
+    }
+  }
 }
 
+/* =========================
+   MCP SERVER
+========================= */
+const { sender_id } = loadOrCreateNodeId();
+state.sender_id = sender_id;
+
 const server = new McpServer({
   name: "evomap-lite",
-  version: "0.1.0"
+  version: "0.3.0"
 });
 
-/* ========================
-   TOOL 1: FETCH
-======================== */
+/* TOOL: account status (NEW) */
+server.tool(
+  "evomap_account_status",
+  {
+    type: "object",
+    properties: {},
+    required: []
+  },
+  async () => {
+    if (state.bound === null) await helloAndUpdateBinding();
+
+    const notice = bindingNoticeIfNeeded();
+    const out = {
+      sender_id: state.sender_id,
+      bound: state.bound,
+      claim_code: state.claim_code,
+      claim_url: state.claim_url,
+      last_hello_at: state.lastHelloAt
+    };
+
+    return {
+      content: [
+        ...(notice ? [{ type: "text", text: notice }] : []),
+        { type: "text", text: clipJson(out) }
+      ]
+    };
+  }
+);
+
+/* TOOL 1: fetch (A2A envelope) */
 server.tool(
   "evomap_fetch",
   {
-    signals: { type: "array", items: { type: "string" } },
-    context: { type: "string" },
-    limit: { type: "number", optional: true }
+    type: "object",
+    properties: {
+      signals: { type: "array", items: { type: "string" }, description: "keywords array" },
+      context: { type: "string", description: "short bug context", default: "" },
+      limit: { type: "number", description: "default 5, max 10", default: 5 }
+    },
+    required: ["signals"]
   },
   async ({ signals, context, limit }) => {
-    const payload = {
-      signals,
-      context,
-      limit: Math.min(Number(limit || 5), 10)
-    };
+    await ensureHeartbeat();
 
-    const data = await http("post", `${API}/a2a/fetch`, payload);
+    const env = makeEnvelope({
+      message_type: "fetch",
+      sender_id: state.sender_id,
+      payload: {
+        signals,
+        context: context || "",
+        limit: Math.min(Number(limit || 5), 10)
+      }
+    });
 
+    const data = await safeCall("post", `${API}/a2a/fetch`, env);
+
+    const notice = bindingNoticeIfNeeded();
     return {
-      content: [{ type: "text", text: clipJson(data) }]
+      content: [
+        ...(notice ? [{ type: "text", text: notice }] : []),
+        { type: "text", text: clipJson(data) }
+      ]
     };
   }
 );
 
-/* ========================
-   TOOL 2: ASSET DETAIL
-======================== */
+/* TOOL 2: asset detail (REST) */
 server.tool(
   "evomap_asset",
   {
-    asset_id: { type: "string" }
+    type: "object",
+    properties: {
+      asset_id: { type: "string", description: "asset id" },
+      detail_level: { type: "string", enum: ["brief", "full"], default: "brief" }
+    },
+    required: ["asset_id"]
   },
-  async ({ asset_id }) => {
-    const data = await http("get", `${API}/a2a/assets/${asset_id}`);
+  async ({ asset_id, detail_level }) => {
+    const detailed = detail_level === "full" ? "true" : "false";
+    const data = await safeCall(
+      "get",
+      `${API}/a2a/assets/${encodeURIComponent(asset_id)}?detailed=${detailed}`
+    );
+
+    const notice = bindingNoticeIfNeeded();
     return {
-      content: [{ type: "text", text: clipJson(data) }]
+      content: [
+        ...(notice ? [{ type: "text", text: notice }] : []),
+        { type: "text", text: clipJson(data) }
+      ]
     };
   }
 );
 
-/* ========================
-   TOOL 3: VALIDATE
-======================== */
+/* TOOL 3: validate bundle (REST) */
 server.tool(
   "evomap_validate_bundle",
   {
-    bundle: { type: "object" }
+    type: "object",
+    properties: {
+      bundle: { type: "object", description: "gene + capsule + evolution_event bundle object" }
+    },
+    required: ["bundle"]
   },
   async ({ bundle }) => {
-    const data = await http("post", `${API}/a2a/validate`, bundle);
+    const data = await safeCall("post", `${API}/a2a/validate`, bundle);
+
+    const notice = bindingNoticeIfNeeded();
     return {
-      content: [{ type: "text", text: clipJson(data) }]
+      content: [
+        ...(notice ? [{ type: "text", text: notice }] : []),
+        { type: "text", text: clipJson(data) }
+      ]
     };
   }
 );
 
-/* ========================
-   正确启动 MCP (stdio)
-======================== */
+/* START */
 const transport = new StdioServerTransport();
-await server.connect(transport);
+await server.connect(transport);
+
+// hello after connect
+await helloAndUpdateBinding();
+if (state.bound === false && state.claim_url) {
+  console.error("[evomap-lite] account not bound; claim_url:", state.claim_url);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bsbofmusic/evomap-mcp-lite",
-  "version": "0.1.0",
-  "description": "Lite MCP server for EvoMap asset reuse (bugfix oriented)",
+  "version": "0.3.0",
+  "description": "EvoMap MCP Lite (Plus) - compliant A2A + stable connectivity + binding check",
   "type": "module",
   "bin": {
     "evomap-mcp-lite": "./index.js"