dero-mcp-server 0.1.1 → 0.2.2

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`
-}