@neus/mcp-server 1.0.0

package/e2e-mcp-local.test.js

@@ -0,0 +1,263 @@
+#!/usr/bin/env node
+
+/**
+ * Local NEUS MCP smoke: health, discovery, ten-key neus_context contract.
+ */
+
+import { spawn } from 'node:child_process';
+
+const PORT = 3110;
+const BASE_URL = `http://127.0.0.1:${PORT}`;
+
+const EXPECTED_TOOLS = [
+  'neus_context',
+  'neus_verifiers_catalog',
+  'neus_proofs_check',
+  'neus_verify',
+  'neus_verify_or_guide',
+  'neus_proofs_get',
+  'neus_me',
+  'neus_agent_link',
+  'neus_agent_create'
+];
+
+const NEUS_CONTEXT_KEYS = [
+  'product',
+  'setup',
+  'mode',
+  'goldenPath',
+  'jobs',
+  'tools',
+  'proofModel',
+  'agentModel',
+  'safetyRules',
+  'verifierSummary'
+];
+
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function waitForHealth(url, timeoutMs = 20000) {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    try {
+      const res = await fetch(`${url}/health`);
+      if (res.ok) return true;
+    } catch {
+      // ignore
+    }
+    await wait(250);
+  }
+  return false;
+}
+
+function parseSseJson(raw) {
+  const trimmed = String(raw || '').trim();
+  if (trimmed.startsWith('{')) {
+    return JSON.parse(trimmed);
+  }
+  const dataLine = String(raw || '')
+    .split(/\r?\n/)
+    .find((line) => line.startsWith('data: '));
+  if (!dataLine) {
+    throw new Error(`Unexpected MCP response: ${raw}`);
+  }
+  return JSON.parse(dataLine.slice('data: '.length));
+}
+
+async function initMcpSession(baseUrl) {
+  const headers = {
+    'content-type': 'application/json',
+    'mcp-protocol-version': '2025-11-25',
+    accept: 'application/json, text/event-stream'
+  };
+
+  const response = await fetch(`${baseUrl}/mcp`, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify({
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'initialize',
+      params: {
+        protocolVersion: '2025-11-25',
+        capabilities: {},
+        clientInfo: { name: 'mcp-local-e2e', version: '1.0.0' }
+      }
+    })
+  });
+
+  const raw = await response.text();
+  const sessionId = response.headers.get('mcp-session-id');
+  if (sessionId) {
+    throw new Error(`MCP initialize should be stateless and must not return mcp-session-id: ${sessionId}`);
+  }
+  parseSseJson(raw);
+  return { headers };
+}
+
+async function listTools(baseUrl, headers, id) {
+  const response = await fetch(`${baseUrl}/mcp`, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify({
+      jsonrpc: '2.0',
+      id,
+      method: 'tools/list',
+      params: {}
+    })
+  });
+
+  const raw = await response.text();
+  const payload = parseSseJson(raw);
+  return payload?.result?.tools || [];
+}
+
+async function callTool(baseUrl, headers, id, name, args) {
+  const response = await fetch(`${baseUrl}/mcp`, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify({
+      jsonrpc: '2.0',
+      id,
+      method: 'tools/call',
+      params: {
+        name,
+        arguments: args
+      }
+    })
+  });
+
+  const raw = await response.text();
+  const payload = parseSseJson(raw);
+  const text = payload?.result?.content?.[0]?.text;
+  if (!text) {
+    throw new Error(`Missing tool payload for ${name}: ${raw}`);
+  }
+  return JSON.parse(text);
+}
+
+async function main() {
+  console.log('\n=== NEUS MCP local E2E ===');
+  console.log(`Spawning MCP on ${BASE_URL}`);
+
+  const child = spawn(process.execPath, ['server.js'], {
+    cwd: new URL('.', import.meta.url),
+    env: {
+      ...process.env,
+      MCP_TRANSPORT: 'http',
+      HOST: '127.0.0.1',
+      PORT: String(PORT)
+    },
+    stdio: ['ignore', 'pipe', 'pipe']
+  });
+
+  child.stdout.on('data', () => {});
+  child.stderr.on('data', () => {});
+
+  let headers = null;
+
+  try {
+    const ready = await waitForHealth(BASE_URL);
+    if (!ready) throw new Error('MCP server did not become healthy in time');
+    console.log('  ✓ Health endpoint');
+
+    ({ headers } = await initMcpSession(BASE_URL));
+    console.log('  ✓ MCP stateless initialize');
+
+    const tools = await listTools(BASE_URL, headers, 10);
+    const names = tools.map((t) => t.name);
+    if (names.join(',') !== EXPECTED_TOOLS.join(',')) {
+      throw new Error(`Unexpected public tool list.\nExpected: ${EXPECTED_TOOLS.join(', ')}\nGot: ${names.join(', ')}`);
+    }
+    console.log('  ✓ tools/list matches nine-tool public surface');
+
+    const ctx = await callTool(BASE_URL, headers, 11, 'neus_context', {});
+    const keys = Object.keys(ctx).sort();
+    const expectedKeys = [...NEUS_CONTEXT_KEYS].sort();
+    if (keys.join(',') !== expectedKeys.join(',')) {
+      throw new Error(`Unexpected neus_context shape.\nExpected keys: ${expectedKeys.join(', ')}\nGot: ${keys.join(', ')}`);
+    }
+    if (!Array.isArray(ctx.goldenPath) || ctx.goldenPath.length === 0) {
+      throw new Error('neus_context.goldenPath must be a non-empty array');
+    }
+    if (!Array.isArray(ctx.verifierSummary)) {
+      throw new Error('neus_context.verifierSummary must be an array');
+    }
+
+    const cat = await callTool(BASE_URL, headers, 11, 'neus_verifiers_catalog', {});
+    if (!Array.isArray(cat)) {
+      throw new Error(`neus_verifiers_catalog must return an array, got: ${JSON.stringify(cat).slice(0, 400)}`);
+    }
+    console.log(`  ✓ neus_verifiers_catalog (array, length=${cat.length})`);
+
+    const chk = await callTool(BASE_URL, headers, 12, 'neus_proofs_check', {
+      wallet: '0x0000000000000000000000000000000000000001',
+      verifiers: ['ownership-basic']
+    });
+    if (typeof chk?.eligible !== 'boolean') {
+      throw new Error(`neus_proofs_check missing eligible boolean: ${JSON.stringify(chk).slice(0, 400)}`);
+    }
+    console.log('  ✓ neus_proofs_check');
+
+    const vog = await callTool(BASE_URL, headers, 13, 'neus_verify_or_guide', {
+      walletAddress: '0x0000000000000000000000000000000000000001',
+      verifierIds: ['ownership-basic']
+    });
+    if (typeof vog?.eligible !== 'boolean') {
+      throw new Error(`neus_verify_or_guide missing eligible boolean: ${JSON.stringify(vog).slice(0, 400)}`);
+    }
+    console.log('  ✓ neus_verify_or_guide');
+
+    const pg = await callTool(BASE_URL, headers, 14, 'neus_proofs_get', {
+      identifier: '0x0000000000000000000000000000000000000001',
+      limit: 5
+    });
+    if (!pg || typeof pg !== 'object' || !Array.isArray(pg.data?.proofs)) {
+      throw new Error(`neus_proofs_get missing data.proofs array: ${JSON.stringify(pg).slice(0, 400)}`);
+    }
+    console.log('  ✓ neus_proofs_get');
+
+    const me = await callTool(BASE_URL, headers, 15, 'neus_me', {});
+    if (typeof me?.status !== 'string') {
+      throw new Error(`neus_me missing status string: ${JSON.stringify(me).slice(0, 400)}`);
+    }
+    console.log('  ✓ neus_me');
+
+    const al = await callTool(BASE_URL, headers, 16, 'neus_agent_link', {
+      agentWallet: '0x0000000000000000000000000000000000000001'
+    });
+    if (typeof al?.status !== 'string') {
+      throw new Error(`neus_agent_link missing status string: ${JSON.stringify(al).slice(0, 400)}`);
+    }
+    console.log('  ✓ neus_agent_link');
+
+    const ac = await callTool(BASE_URL, headers, 17, 'neus_agent_create', {
+      agentId: 'e2e-test-agent',
+      agentWallet: 'generate'
+    });
+    if (typeof ac?.status !== 'string' && typeof ac?.error !== 'string') {
+      throw new Error(`neus_agent_create missing status or error: ${JSON.stringify(ac).slice(0, 400)}`);
+    }
+    console.log('  ✓ neus_agent_create');
+
+    const v = await callTool(BASE_URL, headers, 18, 'neus_verify', {
+      walletAddress: '0x0000000000000000000000000000000000000001',
+      verifierIds: ['ownership-basic']
+    });
+    if (typeof v?.status !== 'string' && typeof v?.error !== 'string') {
+      throw new Error(`neus_verify missing status or error: ${JSON.stringify(v).slice(0, 400)}`);
+    }
+    console.log('  ✓ neus_verify');
+    console.log('\n--- Summary ---');
+    console.log('Passed');
+  } finally {
+    child.kill('SIGTERM');
+  }
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@neus/mcp-server",
+  "version": "1.0.0",
+  "mcpName": "io.github.neus/neus-mcp",
+  "description": "NEUS MCP over HTTP: verifiers, proof checks, guided verify, reads, agent identity/delegation.",
+  "type": "module",
+  "main": "server.js",
+  "bin": {
+    "neus-mcp": "server.js"
+  },
+  "scripts": {
+    "start": "node server.js",
+    "dev": "node --watch server.js",
+    "test:e2e:local": "node e2e-mcp-local.test.js",
+    "test:e2e:live": "node e2e-mcp-live.test.js",
+    "test:e2e:agent": "node e2e-mcp-agent-local.test.js",
+    "test:agent-context": "node test-agent-context.js",
+    "test:public-contract": "node test-public-mcp-contract.js"
+  },
+  "engines": {
+    "node": ">=22.13.0"
+  },
+  "dependencies": {
+    "@azure/monitor-opentelemetry": "^1.11.0",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/resources": "^2.7.1",
+    "viem": "^2.47.6",
+    "zod": "^4.3.6"
+  },
+  "keywords": [
+    "neus",
+    "mcp",
+    "model-context-protocol",
+    "verification",
+    "proofs",
+    "agents",
+    "gate-check",
+    "ai-agents",
+    "identity",
+    "web3",
+    "wallet-verification",
+    "sybil-resistance"
+  ],
+  "license": "Apache-2.0",
+  "author": "NEUS Network <info@neus.network>",
+  "homepage": "https://neus.network",
+  "bugs": {
+    "url": "https://github.com/neus/network/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/neus/protocol.git",
+    "directory": "mcp"
+  },
+  "files": [
+    "server.js",
+    "README.md",
+    "server.json",
+    "CHANGELOG.md",
+    "e2e-mcp-local.test.js",
+    "e2e-mcp-live.test.js",
+    "e2e-mcp-agent-local.test.js",
+    "test-agent-context.js",
+    "test-public-mcp-contract.js"
+  ]
+}