autonomy-mcp 1.0.0

package/README.md

@@ -0,0 +1,69 @@
+# @autonomy/mcp
+
+MCP Server for [theautonomy.ai](https://theautonomy.ai) - Multi-chain RPC and AI agent infrastructure.
+
+## Installation
+
+```bash
+npm install -g @autonomy/mcp
+```
+
+## Usage with Claude Desktop
+
+Add to your Claude Desktop config (`~/.config/claude/mcp.json`):
+
+```json
+{
+  "mcpServers": {
+    "autonomy": {
+      "command": "autonomy-mcp",
+      "env": {
+        "AUTONOMY_KEY": "your-api-key"
+      }
+    }
+  }
+}
+```
+
+## Available Tools
+
+### Data
+- `weather_get` - Get weather for a city
+- `crypto_price` - Get cryptocurrency price
+
+### EVM Chains (23 chains)
+- `chain_balance` - Get wallet balance
+- `chain_gas` - Get gas price
+- `chain_block` - Get latest block
+
+### Monopoly Chains (exclusive access)
+- `kaspa_balance`, `kaspa_price` - Kaspa
+- `tao_price`, `tao_subnets` - Bittensor TAO
+- `sui_balance`, `sui_price` - SUI
+- `icp_price` - Internet Computer
+- `ergo_balance` - Ergo
+- `radix_balance` - Radix
+- `alephium_balance` - Alephium
+- `flux_balance` - Flux
+
+### Platform
+- `plans_list` - List subscription plans
+- `chains_list` - List all 31 supported chains
+
+## Pricing
+
+- **Free**: 10 calls (preview)
+- **$0.99/mo**: 500K EVM + 100 monopoly/day
+- **$4.99/mo**: 2M calls all chains
+- **$19.99/mo**: 10M calls
+- **$49.99/mo**: 50M calls
+- **$99.99/mo**: Unlimited
+
+## Environment Variables
+
+- `AUTONOMY_KEY` - Your API key (get one at https://api.theautonomy.ai/v1/keys/create)
+- `AUTONOMY_API_URL` - API base URL (default: https://api.theautonomy.ai)
+
+## License
+
+MIT

package/index.js

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+
+const API_BASE = process.env.AUTONOMY_API_URL || 'https://api.theautonomy.ai';
+const API_KEY = process.env.AUTONOMY_KEY || '';
+
+const tools = [
+  { name: 'weather_get', description: 'Get weather for a city', params: ['city'] },
+  { name: 'crypto_price', description: 'Get cryptocurrency price', params: ['symbol'] },
+  { name: 'chain_balance', description: 'Get wallet balance on EVM chain', params: ['chainId', 'address'] },
+  { name: 'chain_gas', description: 'Get gas price on EVM chain', params: ['chainId'] },
+  { name: 'chain_block', description: 'Get latest block on EVM chain', params: ['chainId'] },
+  { name: 'kaspa_balance', description: 'Get Kaspa wallet balance', params: ['address'] },
+  { name: 'kaspa_price', description: 'Get Kaspa price', params: [] },
+  { name: 'tao_price', description: 'Get Bittensor TAO price', params: [] },
+  { name: 'tao_subnets', description: 'List Bittensor subnets', params: [] },
+  { name: 'sui_balance', description: 'Get SUI wallet balance', params: ['address'] },
+  { name: 'sui_price', description: 'Get SUI price', params: [] },
+  { name: 'icp_price', description: 'Get ICP price', params: [] },
+  { name: 'ergo_balance', description: 'Get Ergo wallet balance', params: ['address'] },
+  { name: 'radix_balance', description: 'Get Radix wallet balance', params: ['address'] },
+  { name: 'alephium_balance', description: 'Get Alephium wallet balance', params: ['address'] },
+  { name: 'flux_balance', description: 'Get Flux wallet balance', params: ['address'] },
+  { name: 'plans_list', description: 'List subscription plans', params: [] },
+  { name: 'chains_list', description: 'List all supported chains', params: [] }
+];
+
+async function apiCall(path) {
+  try {
+    const headers = { 'Accept': 'application/json' };
+    if (API_KEY) headers['Authorization'] = `Bearer ${API_KEY}`;
+    const res = await fetch(`${API_BASE}${path}`, { headers });
+    return await res.json();
+  } catch {
+    return { error: 'Request failed' };
+  }
+}
+
+async function executeTool(name, args) {
+  const routes = {
+    weather_get: () => apiCall(`/api/data/weather/${encodeURIComponent(args.city)}`),
+    crypto_price: () => apiCall(`/api/data/crypto/${encodeURIComponent(args.symbol)}`),
+    chain_balance: () => apiCall(`/api/chain/balance/${args.chainId}/${args.address}`),
+    chain_gas: () => apiCall(`/api/chain/gas/${args.chainId}`),
+    chain_block: () => apiCall(`/api/chain/block/${args.chainId}`),
+    kaspa_balance: () => apiCall(`/v1/kaspa/balance/${args.address}`),
+    kaspa_price: () => apiCall('/v1/kaspa/price'),
+    tao_price: () => apiCall('/v1/tao/price'),
+    tao_subnets: () => apiCall('/v1/tao/subnets'),
+    sui_balance: () => apiCall(`/v1/sui/balance/${args.address}`),
+    sui_price: () => apiCall('/v1/sui/price'),
+    icp_price: () => apiCall('/v1/icp/price'),
+    ergo_balance: () => apiCall(`/v1/ergo/balance/${args.address}`),
+    radix_balance: () => apiCall(`/v1/radix/balance/${args.address}`),
+    alephium_balance: () => apiCall(`/v1/alephium/balance/${args.address}`),
+    flux_balance: () => apiCall(`/v1/flux/balance/${args.address}`),
+    plans_list: () => apiCall('/v1/plans'),
+    chains_list: () => apiCall('/v1/chains')
+  };
+  return routes[name] ? routes[name]() : { error: 'Unknown tool' };
+}
+
+function sendResponse(id, result) {
+  process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id, result }) + '\n');
+}
+
+function sendError(id, code, message) {
+  process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id, error: { code, message } }) + '\n');
+}
+
+async function handleRequest(request) {
+  const { id, method, params } = request;
+
+  if (method === 'initialize') {
+    return sendResponse(id, {
+      protocolVersion: '2024-11-05',
+      serverInfo: { name: '@autonomy/mcp', version: '1.0.0' },
+      capabilities: { tools: {} }
+    });
+  }
+
+  if (method === 'tools/list') {
+    return sendResponse(id, {
+      tools: tools.map(t => ({
+        name: t.name,
+        description: t.description,
+        inputSchema: {
+          type: 'object',
+          properties: Object.fromEntries(t.params.map(p => [p, { type: 'string' }])),
+          required: t.params
+        }
+      }))
+    });
+  }
+
+  if (method === 'tools/call') {
+    const { name, arguments: args } = params;
+    const result = await executeTool(name, args || {});
+    return sendResponse(id, {
+      content: [{ type: 'text', text: JSON.stringify(result, null, 2) }]
+    });
+  }
+
+  if (method === 'notifications/initialized') return;
+
+  sendError(id, -32601, 'Method not found');
+}
+
+let buffer = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', async (chunk) => {
+  buffer += chunk;
+  const lines = buffer.split('\n');
+  buffer = lines.pop() || '';
+  for (const line of lines) {
+    if (line.trim()) {
+      try { await handleRequest(JSON.parse(line)); }
+      catch { sendError(null, -32700, 'Parse error'); }
+    }
+  }
+});
+
+process.stderr.write('@autonomy/mcp v1.0.0 | https://theautonomy.ai\n');

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "autonomy-mcp",
+  "version": "1.0.0",
+  "description": "MCP Server for theautonomy.ai - Multi-chain RPC and AI agent infrastructure",
+  "main": "index.js",
+  "bin": {
+    "autonomy-mcp": "./index.js"
+  },
+  "type": "module",
+  "keywords": [
+    "mcp",
+    "claude",
+    "ai",
+    "blockchain",
+    "rpc",
+    "pulsechain",
+    "kaspa",
+    "bittensor",
+    "sui",
+    "multi-chain"
+  ],
+  "author": "theautonomy.ai",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SleepyJP/autonomy-mcp.git"
+  },
+  "homepage": "https://theautonomy.ai",
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}