@neus/mcp-server 1.0.0 → 1.0.2

package/e2e-mcp-live.test.js

@@ -1,235 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Hosted NEUS MCP smoke (production by default). Set MCP_E2E_BASE_URL to override.
- *
- * Hosted MCP may be stateful or stateless during rollout. If initialize returns
- * mcp-session-id, reuse it and send notifications/initialized before tools/list.
- */
-
-const BASE_URL = String(process.env.MCP_E2E_BASE_URL || 'https://mcp.neus.network').replace(/\/$/, '');
-
-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 unwrapDataArray(value, label) {
-  if (Array.isArray(value)) return value;
-  if (value?.success === true && Array.isArray(value.data)) return value.data;
-  throw new Error(`${label} must return an array or { success: true, data: array }, got: ${JSON.stringify(value).slice(0, 400)}`);
-}
-
-function parseSseJson(raw) {
-  const trimmed = String(raw || '').trim();
-  if (!trimmed) return null;
-  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.slice(0, 500)}`);
-  }
-  return JSON.parse(dataLine.slice('data: '.length));
-}
-
-const COMMON_HEADERS = {
-  'content-type': 'application/json',
-  'mcp-protocol-version': '2025-11-25',
-  accept: 'application/json, text/event-stream'
-};
-
-async function post(baseUrl, body, extraHeaders = {}) {
-  const response = await fetch(`${baseUrl}/mcp`, {
-    method: 'POST',
-    headers: { ...COMMON_HEADERS, ...extraHeaders },
-    body: JSON.stringify(body)
-  });
-  const raw = await response.text();
-  return {
-    status: response.status,
-    payload: parseSseJson(raw),
-    sessionId: response.headers.get('mcp-session-id')
-  };
-}
-
-async function callTool(baseUrl, headers, id, name, args) {
-  const { payload } = await post(baseUrl, {
-    jsonrpc: '2.0',
-    id,
-    method: 'tools/call',
-    params: { name, arguments: args }
-  }, headers);
-  const text = payload?.result?.content?.[0]?.text;
-  if (!text) {
-    throw new Error(`Missing tool payload for ${name}: ${JSON.stringify(payload).slice(0, 400)}`);
-  }
-  return JSON.parse(text);
-}
-
-async function main() {
-  console.log('\n=== NEUS MCP hosted E2E ===');
-  console.log(`BASE_URL=${BASE_URL}`);
-
-  // initialize
-  const { status: initStatus, payload: initPayload, sessionId } = await post(BASE_URL, {
-    jsonrpc: '2.0',
-    id: 1,
-    method: 'initialize',
-    params: {
-      protocolVersion: '2025-11-25',
-      capabilities: {},
-      clientInfo: { name: 'mcp-live-e2e', version: '1.0.0' }
-    }
-  });
-  if (initStatus !== 200) {
-    throw new Error(`Initialize HTTP ${initStatus}: ${JSON.stringify(initPayload).slice(0, 400)}`);
-  }
-  if (!initPayload?.result?.protocolVersion) {
-    throw new Error(`Initialize missing protocolVersion: ${JSON.stringify(initPayload).slice(0, 400)}`);
-  }
-  const sessionHeaders = sessionId ? { 'mcp-session-id': sessionId } : {};
-  if (sessionId) {
-    const { status: initializedStatus } = await post(BASE_URL, {
-      jsonrpc: '2.0',
-      method: 'notifications/initialized',
-      params: {}
-    }, sessionHeaders);
-    if (initializedStatus !== 202 && initializedStatus !== 200) {
-      throw new Error(`notifications/initialized HTTP ${initializedStatus}`);
-    }
-  }
-  console.log(sessionId ? '  ✓ initialize (stateful streamable HTTP)' : '  ✓ initialize (stateless HTTP)');
-
-  // tools/list
-  const { payload: listPayload } = await post(BASE_URL, {
-    jsonrpc: '2.0',
-    id: 2,
-    method: 'tools/list',
-    params: {}
-  }, sessionHeaders);
-  if (listPayload?.error) {
-    throw new Error(`tools/list failed: ${JSON.stringify(listPayload.error).slice(0, 400)}`);
-  }
-  const tools = listPayload?.result?.tools || [];
-  const names = tools.map((t) => t.name);
-  if (names.join(',') !== EXPECTED_TOOLS.join(',')) {
-    throw new Error(`Unexpected hosted tool list.\nExpected: ${EXPECTED_TOOLS.join(', ')}\nGot: ${names.join(', ')}`);
-  }
-  console.log('  ✓ tools/list');
-
-  // neus_context
-  const ctx = await callTool(BASE_URL, sessionHeaders, 3, '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');
-  }
-  console.log('  ✓ neus_context contract (ten keys)');
-
-  // neus_verifiers_catalog
-  const cat = unwrapDataArray(await callTool(BASE_URL, sessionHeaders, 4, 'neus_verifiers_catalog', {}), 'neus_verifiers_catalog');
-  console.log(`  ✓ neus_verifiers_catalog (array, length=${cat.length})`);
-
-  // neus_proofs_check
-  const chk = await callTool(BASE_URL, sessionHeaders, 5, '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');
-
-  // neus_verify_or_guide
-  const vog = await callTool(BASE_URL, sessionHeaders, 6, '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');
-
-  // neus_proofs_get
-  const pg = await callTool(BASE_URL, sessionHeaders, 7, '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');
-
-  // neus_me
-  const me = await callTool(BASE_URL, sessionHeaders, 8, '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');
-
-  // neus_agent_link
-  const al = await callTool(BASE_URL, sessionHeaders, 9, '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');
-
-  // neus_agent_create
-  const ac = await callTool(BASE_URL, sessionHeaders, 10, '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');
-
-  // neus_verify (preparation step)
-  const v = await callTool(BASE_URL, sessionHeaders, 11, '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');
-}
-
-main().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});

package/e2e-mcp-local.test.js

@@ -1,263 +0,0 @@
-#!/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);
-});