dero-mcp-server 0.1.1 → 0.1.2

package/scripts/flow-test.ts

@@ -1,257 +0,0 @@
-#!/usr/bin/env npx tsx
-/**
- * DERO MCP Server — Flow Test
- * 
- * Tests the daemon RPC calls that the MCP tools wrap.
- * Run this against a live daemon (local or remote) to verify connectivity
- * and that the RPC methods return expected data shapes.
- * 
- * Usage:
- *   npx tsx scripts/flow-test.ts
- *   npx tsx scripts/flow-test.ts http://127.0.0.1:10102
- *   DERO_DAEMON_URL=http://... npx tsx scripts/flow-test.ts
- */
-
-const DEFAULT_URL = "http://82.65.143.182:10102";
-
-type FlowStatus = "pass" | "fail" | "skip";
-type FlowResult = {
-  id: string;
-  name: string;
-  status: FlowStatus;
-  message?: string;
-  durationMs: number;
-};
-
-async function deroRpc<T = unknown>(
-  endpoint: string,
-  method: string,
-  params?: unknown
-): Promise<T> {
-  const res = await fetch(`${endpoint}/json_rpc`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({
-      jsonrpc: "2.0",
-      id: "1",
-      method,
-      params,
-    }),
-  });
-
-  if (!res.ok) {
-    throw new Error(`HTTP ${res.status} from daemon`);
-  }
-
-  const data = await res.json();
-  if (data.error) {
-    throw new Error(`RPC error: ${JSON.stringify(data.error)}`);
-  }
-  return data.result;
-}
-
-function assert(condition: unknown, message: string): void {
-  if (!condition) throw new Error(message);
-}
-
-async function runFlow(
-  id: string,
-  name: string,
-  fn: () => Promise<void>
-): Promise<FlowResult> {
-  const start = performance.now();
-  try {
-    await fn();
-    return { id, name, status: "pass", durationMs: Math.round(performance.now() - start) };
-  } catch (error) {
-    return {
-      id,
-      name,
-      status: "fail",
-      message: error instanceof Error ? error.message : String(error),
-      durationMs: Math.round(performance.now() - start),
-    };
-  }
-}
-
-async function runAllFlows(daemonUrl: string): Promise<FlowResult[]> {
-  const results: FlowResult[] = [];
-
-  // Flow 1: Ping
-  results.push(
-    await runFlow("ping", "DERO.Ping — daemon reachable", async () => {
-      const result = await deroRpc<string>(daemonUrl, "DERO.Ping");
-      assert(result === "Pong " || result === "Pong", `Expected 'Pong', got '${result}'`);
-    })
-  );
-
-  // Flow 2: Echo
-  results.push(
-    await runFlow("echo", "DERO.Echo — roundtrip strings", async () => {
-      const words = ["hello", "dero", "mcp"];
-      const result = await deroRpc<string>(daemonUrl, "DERO.Echo", words);
-      assert(typeof result === "string", "Expected string response");
-      assert(result.includes("DERO") || words.some(w => result.includes(w)), "Echo should contain input or DERO");
-    })
-  );
-
-  // Flow 3: GetInfo
-  let topoheight: number | undefined;
-  results.push(
-    await runFlow("get-info", "DERO.GetInfo — chain metadata", async () => {
-      const result = await deroRpc<{
-        topoheight?: number;
-        height?: number;
-        network?: string;
-        version?: string;
-      }>(daemonUrl, "DERO.GetInfo");
-      assert(typeof result.topoheight === "number", "Missing topoheight");
-      assert(typeof result.height === "number", "Missing height");
-      topoheight = result.topoheight;
-    })
-  );
-
-  // Flow 4: GetHeight
-  results.push(
-    await runFlow("get-height", "DERO.GetHeight — block heights", async () => {
-      const result = await deroRpc<{
-        height?: number;
-        stableheight?: number;
-        topoheight?: number;
-      }>(daemonUrl, "DERO.GetHeight");
-      assert(typeof result.height === "number", "Missing height");
-      assert(typeof result.topoheight === "number", "Missing topoheight");
-    })
-  );
-
-  // Flow 5: GetBlockCount
-  results.push(
-    await runFlow("get-block-count", "DERO.GetBlockCount — total blocks", async () => {
-      const result = await deroRpc<{ count?: number }>(daemonUrl, "DERO.GetBlockCount");
-      assert(typeof result.count === "number", "Missing count");
-      assert(result.count > 0, "Block count should be > 0");
-    })
-  );
-
-  // Flow 6: GetLastBlockHeader
-  results.push(
-    await runFlow("get-last-block-header", "DERO.GetLastBlockHeader — tip block", async () => {
-      const result = await deroRpc<{ block_header?: { height?: number; hash?: string } }>(
-        daemonUrl,
-        "DERO.GetLastBlockHeader"
-      );
-      assert(result.block_header, "Missing block_header");
-      assert(typeof result.block_header.height === "number", "Missing height in header");
-    })
-  );
-
-  // Flow 7: GetBlock by height (use topoheight - 10 for safety)
-  results.push(
-    await runFlow("get-block-by-height", "DERO.GetBlock — fetch by height", async () => {
-      const testHeight = Math.max(1, (topoheight ?? 100) - 10);
-      const result = await deroRpc<{ block_header?: unknown }>(daemonUrl, "DERO.GetBlock", {
-        height: testHeight,
-      });
-      assert(result.block_header, "Missing block_header in response");
-    })
-  );
-
-  // Flow 8: GetTxPool (may be empty, just check shape)
-  results.push(
-    await runFlow("get-tx-pool", "DERO.GetTxPool — mempool check", async () => {
-      const result = await deroRpc<{ tx_hashes?: string[] }>(daemonUrl, "DERO.GetTxPool");
-      // tx_hashes may be null/undefined if empty, which is fine
-      assert(
-        result.tx_hashes === undefined || result.tx_hashes === null || Array.isArray(result.tx_hashes),
-        "tx_hashes should be array or null"
-      );
-    })
-  );
-
-  // Flow 9: NameToAddress (test known name "dero" — may not exist on all networks)
-  results.push(
-    await runFlow("name-to-address", "DERO.NameToAddress — resolve 'dero'", async () => {
-      try {
-        const result = await deroRpc<{ address?: string; name?: string }>(
-          daemonUrl,
-          "DERO.NameToAddress",
-          { name: "dero", topoheight: -1 }
-        );
-        // Name may not be registered, that's okay
-        if (result.address) {
-          assert(result.address.startsWith("dero") || result.address.startsWith("deto"), "Invalid address format");
-        }
-      } catch (e) {
-        // Name not found is acceptable
-        if (String(e).includes("NOT FOUND") || String(e).includes("not found")) {
-          return;
-        }
-        throw e;
-      }
-    })
-  );
-
-  // Flow 10: GetSC — test with the name registry SCID
-  const NAME_REGISTRY_SCID = "0000000000000000000000000000000000000000000000000000000000000001";
-  results.push(
-    await runFlow("get-sc", "DERO.GetSC — name registry contract", async () => {
-      const result = await deroRpc<{ code?: string; balances?: unknown }>(
-        daemonUrl,
-        "DERO.GetSC",
-        { scid: NAME_REGISTRY_SCID, code: true, variables: false }
-      );
-      assert(result.code, "Missing contract code");
-      assert(result.code.includes("Function"), "Code should contain Function keyword");
-    })
-  );
-
-  return results;
-}
-
-function formatReport(results: FlowResult[]): string {
-  const lines: string[] = [
-    "",
-    "DERO MCP Flow Test Results",
-    "==========================",
-    "",
-  ];
-
-  const passed = results.filter((r) => r.status === "pass").length;
-  const failed = results.filter((r) => r.status === "fail").length;
-  const skipped = results.filter((r) => r.status === "skip").length;
-
-  for (const r of results) {
-    const icon = r.status === "pass" ? "✓" : r.status === "fail" ? "✗" : "○";
-    const status = r.status.toUpperCase().padEnd(4);
-    lines.push(`${icon} ${status} ${r.name} (${r.durationMs}ms)`);
-    if (r.message) {
-      lines.push(`       ${r.message}`);
-    }
-  }
-
-  lines.push("");
-  lines.push(`Summary: ${passed} passed, ${failed} failed, ${skipped} skipped`);
-  lines.push("");
-
-  return lines.join("\n");
-}
-
-async function main() {
-  const daemonUrl = (process.argv[2] || process.env.DERO_DAEMON_URL || DEFAULT_URL).replace(/\/$/, "");
-
-  console.log(`Testing daemon at: ${daemonUrl}`);
-  console.log("");
-
-  try {
-    const results = await runAllFlows(daemonUrl);
-    console.log(formatReport(results));
-
-    const failed = results.filter((r) => r.status === "fail").length;
-    process.exit(failed > 0 ? 1 : 0);
-  } catch (error) {
-    console.error("Fatal error:", error instanceof Error ? error.message : error);
-    process.exit(1);
-  }
-}
-
-main();

package/scripts/mcp-smoke-probes.ts

@@ -1,168 +0,0 @@
-#!/usr/bin/env npx tsx
-/**
- * Lightweight MCP smoke probes for local stdio server contract checks.
- *
- * Verifies:
- * - tools/list count + name parity
- * - resources/list count + URI parity
- * - prompts/list count + name parity
- * - prompts/get returns usable messages
- * - structured tool error payload shape on execution failure
- */
-
-import { Client } from '@modelcontextprotocol/sdk/client/index.js'
-import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js'
-
-const DEFAULT_DAEMON_URL = 'http://82.65.143.182:10102'
-const NAME_REGISTRY_SCID = '0000000000000000000000000000000000000000000000000000000000000001'
-
-const EXPECTED_TOOLS = [
-  'dero_daemon_ping',
-  'dero_daemon_echo',
-  'dero_get_info',
-  'dero_get_height',
-  'dero_get_block_count',
-  'dero_get_last_block_header',
-  'dero_get_block',
-  'dero_get_block_header_by_topo_height',
-  'dero_get_block_header_by_hash',
-  'dero_get_tx_pool',
-  'dero_get_random_address',
-  'dero_get_transaction',
-  'dero_get_encrypted_balance',
-  'dero_get_sc',
-  'dero_get_gas_estimate',
-  'dero_name_to_address',
-  'dero_get_block_template',
-] as const
-
-const EXPECTED_RESOURCES = [
-  'dero://mcp/server-info',
-  'dero://mcp/safety-boundary',
-  'dero://mcp/example-flows',
-] as const
-
-const EXPECTED_PROMPTS = [
-  'network_health_check',
-  'inspect_smart_contract',
-  'trace_transaction',
-] as const
-
-function parseArgs(argv: string[]) {
-  let daemonUrl = process.env.DERO_DAEMON_URL ?? DEFAULT_DAEMON_URL
-  for (let i = 0; i < argv.length; i++) {
-    const arg = argv[i]
-    if ((arg === '--daemon-url' || arg === '--url') && argv[i + 1]) {
-      daemonUrl = argv[++i]
-    } else if (arg.startsWith('--daemon-url=')) {
-      daemonUrl = arg.slice('--daemon-url='.length)
-    } else if (arg.startsWith('--url=')) {
-      daemonUrl = arg.slice('--url='.length)
-    }
-  }
-  return daemonUrl.replace(/\/$/, '')
-}
-
-function assertSortedEqual(actual: string[], expected: readonly string[], label: string) {
-  const a = [...actual].sort()
-  const e = [...expected].sort()
-  if (a.length !== e.length) {
-    throw new Error(`${label}: expected ${e.length}, got ${a.length}`)
-  }
-  for (let i = 0; i < e.length; i++) {
-    if (a[i] !== e[i]) {
-      throw new Error(`${label} mismatch at ${i}: expected ${e[i]}, got ${a[i]}`)
-    }
-  }
-}
-
-function parseFirstTextJson(result: { content: Array<{ type: string; text?: string }> }): unknown {
-  const textEntry = result.content.find((c) => c.type === 'text' && typeof c.text === 'string')
-  if (!textEntry?.text) {
-    throw new Error('Tool result missing text content')
-  }
-  try {
-    return JSON.parse(textEntry.text)
-  } catch {
-    throw new Error('Tool text content is not valid JSON')
-  }
-}
-
-async function main() {
-  const daemonUrl = parseArgs(process.argv.slice(2))
-  console.log(`[smoke:mcp] daemon=${daemonUrl}`)
-  console.log('================================')
-
-  const transport = new StdioClientTransport({
-    command: 'node',
-    args: ['dist/index.js'],
-    env: {
-      ...process.env,
-      DERO_DAEMON_URL: daemonUrl,
-    } as Record<string, string>,
-  })
-
-  const client = new Client({
-    name: 'dero-mcp-smoke-probes',
-    version: '1.0.0',
-  })
-
-  try {
-    await client.connect(transport)
-
-    const tools = await client.listTools()
-    const toolNames = tools.tools.map((t) => t.name)
-    assertSortedEqual(toolNames, EXPECTED_TOOLS, 'tools/list')
-    console.log(`OK  tools/list      ${toolNames.length} tools`)
-
-    const resources = await client.listResources()
-    const resourceUris = resources.resources.map((r) => r.uri)
-    assertSortedEqual(resourceUris, EXPECTED_RESOURCES, 'resources/list')
-    console.log(`OK  resources/list  ${resourceUris.length} resources`)
-
-    const prompts = await client.listPrompts()
-    const promptNames = prompts.prompts.map((p) => p.name)
-    assertSortedEqual(promptNames, EXPECTED_PROMPTS, 'prompts/list')
-    console.log(`OK  prompts/list    ${promptNames.length} prompts`)
-
-    const prompt = await client.getPrompt({
-      name: 'inspect_smart_contract',
-      arguments: { scid: NAME_REGISTRY_SCID },
-    })
-    if (!prompt.messages?.length) {
-      throw new Error('prompts/get returned zero messages')
-    }
-    console.log('OK  prompts/get     inspect_smart_contract')
-
-    const structuredErrorProbe = await client.callTool({
-      name: 'dero_get_block',
-      arguments: {},
-    })
-    const errorPayload = parseFirstTextJson(structuredErrorProbe as { content: Array<{ type: string; text?: string }> }) as {
-      ok?: boolean
-      _meta?: { error?: { code?: string; hint?: string; retryable?: boolean } }
-    }
-    if (
-      errorPayload.ok !== false ||
-      !errorPayload._meta?.error?.code ||
-      typeof errorPayload._meta.error.hint !== 'string' ||
-      typeof errorPayload._meta.error.retryable !== 'boolean'
-    ) {
-      throw new Error('structured error probe did not return expected _meta.error shape')
-    }
-    console.log('OK  tools/call      structured _meta.error probe')
-
-    console.log('')
-    console.log('All MCP smoke probes passed.')
-    process.exit(0)
-  } catch (error) {
-    console.error('')
-    console.error('[smoke:mcp] FAIL:', error instanceof Error ? error.message : error)
-    process.exit(1)
-  } finally {
-    await client.close()
-    await transport.close()
-  }
-}
-
-main()

package/server.json

@@ -1,23 +0,0 @@
-{
-  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
-  "name": "io.github.DHEBP/dero-mcp-server",
-  "title": "DERO MCP Server",
-  "description": "Read-only DERO daemon MCP tools for chain inspection and analysis.",
-  "version": "0.1.1",
-  "websiteUrl": "https://derod.org",
-  "repository": {
-    "url": "https://github.com/DHEBP/dero-mcp-server",
-    "source": "github"
-  },
-  "packages": [
-    {
-      "registryType": "npm",
-      "registryBaseUrl": "https://registry.npmjs.org",
-      "identifier": "dero-mcp-server",
-      "version": "0.1.1",
-      "transport": {
-        "type": "stdio"
-      }
-    }
-  ]
-}

package/src/index.ts

@@ -1,30 +0,0 @@
-#!/usr/bin/env node
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
-import { createDeroMcpServer } from './server.js'
-
-/** Default public mainnet JSON-RPC (override with DERO_DAEMON_URL). */
-const DEFAULT_DAEMON_BASE = 'http://82.65.143.182:10102'
-
-function daemonUrlFromEnv(): string {
-  const fromEnv = process.env.DERO_DAEMON_URL?.trim()
-  if (fromEnv) return fromEnv.replace(/\/json_rpc\/?$/, '')
-  return DEFAULT_DAEMON_BASE
-}
-
-async function main() {
-  const base = daemonUrlFromEnv()
-  const server = createDeroMcpServer(base)
-
-  const transport = new StdioServerTransport()
-
-  process.stderr.write(
-    `[dero-mcp-server] DERO_DAEMON_URL base: ${base} (JSON-RPC at ${base.replace(/\/$/, '')}/json_rpc)\n`,
-  )
-
-  await server.connect(transport)
-}
-
-main().catch((err) => {
-  process.stderr.write(`[dero-mcp-server] fatal: ${err instanceof Error ? err.message : String(err)}\n`)
-  process.exit(1)
-})

package/src/rpc.ts

@@ -1,60 +0,0 @@
-const DEFAULT_TIMEOUT_MS = 45_000
-
-export type JsonRpcResponse<T = unknown> = {
-  jsonrpc: '2.0'
-  id: string | number
-  result?: T
-  error?: { code: number; message: string; data?: unknown }
-}
-
-/**
- * POST JSON-RPC 2.0 to a DERO daemon or wallet endpoint (…/json_rpc).
- */
-export async function deroJsonRpc<T = unknown>(
-  jsonRpcUrl: string,
-  method: string,
-  params?: unknown,
-  options?: { timeoutMs?: number },
-): Promise<T> {
-  const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS
-  const body: Record<string, unknown> = {
-    jsonrpc: '2.0',
-    id: 'dero-mcp',
-    method,
-  }
-  if (params !== undefined) body.params = params
-
-  const controller = new AbortController()
-  const timer = setTimeout(() => controller.abort(), timeoutMs)
-  try {
-    const res = await fetch(jsonRpcUrl, {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify(body),
-      signal: controller.signal,
-    })
-    const text = await res.text()
-    if (!res.ok) {
-      throw new Error(`HTTP ${res.status}: ${text.slice(0, 500)}`)
-    }
-    let json: JsonRpcResponse<T>
-    try {
-      json = JSON.parse(text) as JsonRpcResponse<T>
-    } catch {
-      throw new Error(`Invalid JSON from node: ${text.slice(0, 200)}`)
-    }
-    if (json.error) {
-      throw new Error(
-        `RPC error ${json.error.code}: ${json.error.message}${json.error.data != null ? ` ${JSON.stringify(json.error.data)}` : ''}`,
-      )
-    }
-    return json.result as T
-  } finally {
-    clearTimeout(timer)
-  }
-}
-
-export function jsonRpcEndpoint(baseUrl: string): string {
-  const trimmed = baseUrl.replace(/\/$/, '')
-  return trimmed.endsWith('/json_rpc') ? trimmed : `${trimmed}/json_rpc`
-}