@proofofprotocol/inscribe-mcp 0.1.0

package/src/server-sse.js

@@ -0,0 +1,239 @@
+#!/usr/bin/env node
+/**
+ * inscribe-mcp Server (SSE/HTTP transport)
+ *
+ * MCP Server for verifiable inscriptions on Hedera blockchain.
+ * For remote access from Windows Claude Desktop via mcp-remote.
+ */
+
+import express from 'express';
+import cors from 'cors';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import dotenv from 'dotenv';
+
+// Layer 1 Tools (Primary)
+import { inscribeUrlTool } from './tools/layer1/inscribe_url.js';
+import { inscribeTool } from './tools/layer1/inscribe.js';
+import { verifyTool } from './tools/layer1/verify.js';
+import { historyTool } from './tools/layer1/history.js';
+import { identityTool } from './tools/layer1/identity.js';
+
+// Layer 2 Tools (Advanced)
+import { createTopicTool, submitMessageTool, getMessagesTool } from './tools/layer2/hcs.js';
+import { getBalanceTool, sendHbarTool, getAccountInfoTool } from './tools/layer2/account.js';
+
+dotenv.config();
+
+const PORT = process.env.PORT || 3011;
+const HOST = process.env.HOST || '0.0.0.0';
+
+// All available tools
+const allTools = [
+  // Layer 1 (Primary - Recommended)
+  inscribeUrlTool,
+  inscribeTool,
+  verifyTool,
+  historyTool,
+  identityTool,
+  // Layer 2 (Advanced - For developers)
+  createTopicTool,
+  submitMessageTool,
+  getMessagesTool,
+  getBalanceTool,
+  sendHbarTool,
+  getAccountInfoTool,
+];
+
+// Create MCP Server factory
+function createMcpServer() {
+  const server = new Server(
+    {
+      name: 'inscribe-mcp',
+      version: '1.0.0',
+    },
+    {
+      capabilities: {
+        tools: {},
+      },
+    }
+  );
+
+  // List Tools Handler
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+      tools: allTools.map(t => ({
+        name: t.name,
+        description: t.description,
+        inputSchema: t.inputSchema
+      }))
+    };
+  });
+
+  // Call Tool Handler
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const tool = allTools.find(t => t.name === name);
+
+    if (!tool) {
+      return {
+        content: [{ type: 'text', text: `Unknown tool: ${name}` }],
+        isError: true
+      };
+    }
+
+    try {
+      const result = await tool.handler(args || {});
+      return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }]
+      };
+    } catch (error) {
+      return {
+        content: [{ type: 'text', text: `Error: ${error.message}` }],
+        isError: true
+      };
+    }
+  });
+
+  return server;
+}
+
+// Express app
+const app = express();
+app.use(cors());
+app.use(express.json());
+
+// Track transports for each session
+const transports = {};
+
+// Health check
+app.get('/health', (req, res) => {
+  res.json({
+    status: 'ok',
+    server: 'inscribe-mcp',
+    version: '1.0.0',
+    transport: 'sse',
+    connections: Object.keys(transports).length,
+    tools: allTools.length
+  });
+});
+
+// SSE endpoint
+app.get('/sse', async (req, res) => {
+  console.log(`[SSE] New connection from ${req.ip}`);
+
+  const transport = new SSEServerTransport('/messages', res);
+  transports[transport.sessionId] = transport;
+
+  res.on('close', () => {
+    console.log(`[SSE] Connection closed: ${transport.sessionId}`);
+    delete transports[transport.sessionId];
+  });
+
+  const server = createMcpServer();
+  await server.connect(transport);
+  console.log(`[SSE] Server connected: ${transport.sessionId}`);
+});
+
+// Messages endpoint
+app.post('/messages', async (req, res) => {
+  const sessionId = req.query.sessionId;
+  console.log(`[Messages] Received for session: ${sessionId}`);
+
+  const transport = transports[sessionId];
+
+  if (!transport) {
+    console.log(`[Messages] Session not found: ${sessionId}`);
+    res.status(400).json({ error: 'Session not found' });
+    return;
+  }
+
+  try {
+    await transport.handlePostMessage(req, res, req.body);
+  } catch (error) {
+    console.error(`[Messages] Error: ${error.message}`);
+    if (!res.headersSent) {
+      res.status(500).json({ error: error.message });
+    }
+  }
+});
+
+// Info page
+app.get('/', (req, res) => {
+  res.send(`
+<!DOCTYPE html>
+<html>
+<head>
+  <title>inscribe-mcp</title>
+  <style>
+    body { font-family: system-ui; max-width: 800px; margin: 2rem auto; padding: 0 1rem; }
+    h1 { color: #333; }
+    code { background: #f4f4f4; padding: 0.2rem 0.5rem; border-radius: 4px; }
+    pre { background: #f4f4f4; padding: 1rem; border-radius: 8px; overflow-x: auto; }
+    .tool { margin: 0.5rem 0; padding: 0.5rem; background: #f9f9f9; border-radius: 4px; }
+    .layer1 { border-left: 3px solid #4CAF50; }
+    .layer2 { border-left: 3px solid #FF9800; }
+  </style>
+</head>
+<body>
+  <h1>inscribe-mcp</h1>
+  <p>Verifiable inscription for AI agents</p>
+
+  <h2>Connection</h2>
+  <p>SSE Endpoint: <code>http://${req.headers.host}/sse</code></p>
+
+  <h3>Claude Desktop (Windows)</h3>
+  <pre>{
+  "mcpServers": {
+    "inscribe": {
+      "command": "npx",
+      "args": ["-y", "mcp-remote", "http://${req.headers.host}/sse", "--allow-http"],
+      "env": {}
+    }
+  }
+}</pre>
+
+  <h2>Layer 1 Tools (Recommended)</h2>
+  ${allTools.filter(t => !t.name.startsWith('hcs_') && !t.name.startsWith('account_')).map(t => `
+  <div class="tool layer1">
+    <strong>${t.name}</strong><br>
+    <small>${t.description}</small>
+  </div>
+  `).join('')}
+
+  <h2>Layer 2 Tools (Advanced)</h2>
+  ${allTools.filter(t => t.name.startsWith('hcs_') || t.name.startsWith('account_')).map(t => `
+  <div class="tool layer2">
+    <strong>${t.name}</strong><br>
+    <small>${t.description}</small>
+  </div>
+  `).join('')}
+
+  <h2>Links</h2>
+  <ul>
+    <li><a href="/health">Health Check</a></li>
+    <li><a href="https://github.com/Shin-R2un/inscribe-mcp">GitHub</a></li>
+  </ul>
+</body>
+</html>
+  `);
+});
+
+// Start server
+app.listen(PORT, HOST, () => {
+  console.log(`
+╔═══════════════════════════════════════════════════════════╗
+║              inscribe-mcp Server (SSE Transport)          ║
+╠═══════════════════════════════════════════════════════════╣
+║  Server: http://${HOST}:${PORT}                              ║
+║  SSE Endpoint: http://${HOST}:${PORT}/sse                    ║
+║  Health Check: http://${HOST}:${PORT}/health                 ║
+╠═══════════════════════════════════════════════════════════╣
+║  Tools: ${allTools.length} (Layer 1: 5, Layer 2: 6)                       ║
+╚═══════════════════════════════════════════════════════════╝
+  `);
+});

package/src/server.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+/**
+ * inscribe-mcp Server (stdio transport)
+ *
+ * MCP Server for verifiable inscriptions on Hedera blockchain.
+ */
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import dotenv from 'dotenv';
+
+// Layer 1 Tools (Primary)
+import { inscribeUrlTool } from './tools/layer1/inscribe_url.js';
+import { inscribeTool } from './tools/layer1/inscribe.js';
+import { verifyTool } from './tools/layer1/verify.js';
+import { historyTool } from './tools/layer1/history.js';
+import { identityTool } from './tools/layer1/identity.js';
+
+// Layer 2 Tools (Advanced)
+import { createTopicTool, submitMessageTool, getMessagesTool } from './tools/layer2/hcs.js';
+import { getBalanceTool, sendHbarTool, getAccountInfoTool } from './tools/layer2/account.js';
+
+dotenv.config();
+
+// All available tools
+const allTools = [
+  // Layer 1 (Primary - Recommended)
+  inscribeUrlTool,  // Killer feature
+  inscribeTool,
+  verifyTool,
+  historyTool,
+  identityTool,
+  // Layer 2 (Advanced - For developers)
+  createTopicTool,
+  submitMessageTool,
+  getMessagesTool,
+  getBalanceTool,
+  sendHbarTool,
+  getAccountInfoTool,
+];
+
+// Create MCP Server
+const server = new Server(
+  {
+    name: 'inscribe-mcp',
+    version: '1.0.0',
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+// List Tools Handler
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: allTools.map(t => ({
+      name: t.name,
+      description: t.description,
+      inputSchema: t.inputSchema
+    }))
+  };
+});
+
+// Call Tool Handler
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  const tool = allTools.find(t => t.name === name);
+
+  if (!tool) {
+    return {
+      content: [{ type: 'text', text: `Unknown tool: ${name}` }],
+      isError: true
+    };
+  }
+
+  try {
+    const result = await tool.handler(args || {});
+    return {
+      content: [{ type: 'text', text: JSON.stringify(result, null, 2) }]
+    };
+  } catch (error) {
+    return {
+      content: [{ type: 'text', text: `Error: ${error.message}` }],
+      isError: true
+    };
+  }
+});
+
+// Main
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('inscribe-mcp server started (stdio)');
+}
+
+main().catch(console.error);

package/src/test.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+/**
+ * inscribe-mcp Test Script
+ *
+ * Direct tool testing without MCP client
+ */
+
+import dotenv from 'dotenv';
+dotenv.config();
+
+// Layer 1 Tools
+import { inscribeUrlTool } from './tools/layer1/inscribe_url.js';
+import { inscribeTool } from './tools/layer1/inscribe.js';
+import { verifyTool } from './tools/layer1/verify.js';
+import { historyTool } from './tools/layer1/history.js';
+
+// Layer 2 Tools
+import { getBalanceTool } from './tools/layer2/account.js';
+
+async function testMcpServer() {
+  console.log('=== inscribe-mcp Test ===\n');
+
+  const allTools = [
+    inscribeUrlTool, inscribeTool, verifyTool, historyTool, getBalanceTool
+  ];
+
+  try {
+    console.log('✅ Tools loaded\n');
+
+    // 1. List Tools
+    console.log('1. List Tools:');
+    console.log('---');
+    allTools.forEach(t => console.log(`   • ${t.name}: ${t.description.substring(0, 50)}...`));
+    console.log(`\n   Total: ${allTools.length} tools (testing subset)\n`);
+
+    // 2. Test account_get_balance
+    console.log('2. Test account_get_balance:');
+    console.log('---');
+    const balanceData = await getBalanceTool.handler({});
+    console.log(`   Account: ${balanceData.account_id}`);
+    console.log(`   Balance: ${balanceData.balance_hbar} HBAR\n`);
+
+    // 3. Test inscribe
+    console.log('3. Test inscribe:');
+    console.log('---');
+    const inscribeData = await inscribeTool.handler({
+      content: 'inscribe-mcp テスト: ' + new Date().toISOString(),
+      type: 'test'
+    });
+    console.log(`   Success: ${inscribeData.success}`);
+    console.log(`   Inscription ID: ${inscribeData.inscription_id}`);
+    console.log(`   Hash: ${inscribeData.content_hash?.substring(0, 16)}...`);
+    console.log(`   HashScan: ${inscribeData.verify_url}\n`);
+
+    // 4. Test verify
+    if (inscribeData.success && inscribeData.inscription_id) {
+      // Wait for mirror node to index
+      console.log('4. Test verify (waiting 3s for indexing):');
+      console.log('---');
+      await new Promise(r => setTimeout(r, 3000));
+
+      const verifyData = await verifyTool.handler({
+        inscription_id: inscribeData.inscription_id
+      });
+      console.log(`   Valid: ${verifyData.valid}`);
+      console.log(`   Type: ${verifyData.type}`);
+      console.log(`   Timestamp: ${verifyData.consensus_timestamp}\n`);
+    }
+
+    // 5. Test history
+    console.log('5. Test history:');
+    console.log('---');
+    const historyData = await historyTool.handler({ limit: 5 });
+    console.log(`   Success: ${historyData.success}`);
+    console.log(`   Count: ${historyData.count}`);
+    if (historyData.inscriptions?.length > 0) {
+      console.log(`   Latest: ${historyData.inscriptions[0].type} - ${historyData.inscriptions[0].content_preview?.substring(0, 40)}...`);
+    }
+    console.log('');
+
+    // 6. Test inscribe_url (YouTube)
+    console.log('6. Test inscribe_url (YouTube):');
+    console.log('---');
+    const urlData = await inscribeUrlTool.handler({
+      url: 'https://www.youtube.com/watch?v=dQw4w9WgXcQ',
+      note: 'テスト用'
+    });
+    console.log(`   Success: ${urlData.success}`);
+    if (urlData.success) {
+      console.log(`   Platform: ${urlData.capture?.platform}`);
+      console.log(`   Source: ${urlData.capture?.source}`);
+      console.log(`   Author: ${urlData.capture?.author}`);
+      console.log(`   Content: ${urlData.capture?.content_preview?.substring(0, 50)}...`);
+    } else {
+      console.log(`   Error: ${urlData.error}`);
+    }
+    console.log('');
+
+    console.log('=== All Tests Completed! ===');
+
+  } catch (error) {
+    console.error('Test error:', error.message);
+    console.error(error.stack);
+  }
+}
+
+testMcpServer().catch(console.error);

package/src/tools/layer1/history.js

@@ -0,0 +1,174 @@
+/**
+ * history - Inscription History Tool
+ *
+ * Retrieve history of inscriptions.
+ */
+
+import { getMirrorNodeUrl, getNetwork, getOperatorId } from '../../lib/hedera.js';
+import { logToolExecution, createTimer } from '../../lib/logger.js';
+
+export const historyTool = {
+  name: 'history',
+  description: '刻んだ履歴を取得する',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      limit: {
+        type: 'number',
+        description: '取得件数（デフォルト: 10、最大: 100）',
+        default: 10
+      },
+      type: {
+        type: 'string',
+        description: '種類でフィルター（article, log, decision, url_capture など）'
+      },
+      author: {
+        type: 'string',
+        description: '著者でフィルター'
+      },
+      topic_id: {
+        type: 'string',
+        description: 'トピックID（省略時はデフォルトトピック）'
+      }
+    }
+  },
+
+  handler: async ({ limit = 10, type, author, topic_id }) => {
+    const timer = createTimer();
+    const network = getNetwork();
+    const operator = getOperatorId().toString();
+    const topicId = topic_id || process.env.DEFAULT_TOPIC_ID;
+
+    if (!topicId) {
+      logToolExecution({
+        command: 'history',
+        network,
+        operator,
+        status: 'error',
+        latency: timer(),
+        error: 'Topic ID not specified'
+      });
+      return {
+        success: false,
+        error: 'トピックIDが指定されていません',
+        inscriptions: [],
+        count: 0
+      };
+    }
+
+    // Limit to max 100
+    const fetchLimit = Math.min(limit, 100);
+
+    // Fetch from Mirror Node
+    const mirrorUrl = getMirrorNodeUrl();
+    const apiUrl = `${mirrorUrl}/api/v1/topics/${topicId}/messages?limit=${fetchLimit}&order=desc`;
+
+    try {
+      const response = await fetch(apiUrl);
+      if (!response.ok) {
+        logToolExecution({
+          command: 'history',
+          network,
+          topicId,
+          operator,
+          status: 'error',
+          latency: timer(),
+          error: 'Mirror Node fetch failed'
+        });
+        return {
+          success: false,
+          error: 'Mirror Node からの取得に失敗しました',
+          inscriptions: [],
+          count: 0
+        };
+      }
+
+      const data = await response.json();
+
+      if (!data.messages) {
+        logToolExecution({
+          command: 'history',
+          network,
+          topicId,
+          operator,
+          status: 'success',
+          latency: timer(),
+          metadata: { count: 0 }
+        });
+        return {
+          success: true,
+          inscriptions: [],
+          count: 0,
+          topic_id: topicId
+        };
+      }
+
+      // Parse and filter inscriptions
+      let inscriptions = data.messages.map(msg => {
+        try {
+          const content = JSON.parse(
+            Buffer.from(msg.message, 'base64').toString('utf-8')
+          );
+          return {
+            inscription_id: `${topicId}-${msg.consensus_timestamp}`,
+            consensus_timestamp: msg.consensus_timestamp,
+            ...content
+          };
+        } catch {
+          // Skip non-JSON messages
+          return null;
+        }
+      }).filter(Boolean);
+
+      // Apply filters
+      if (type) {
+        inscriptions = inscriptions.filter(i => i.type === type);
+      }
+      if (author) {
+        inscriptions = inscriptions.filter(i => i.author === author);
+      }
+
+      logToolExecution({
+        command: 'history',
+        network,
+        topicId,
+        operator,
+        status: 'success',
+        latency: timer(),
+        metadata: { count: inscriptions.length }
+      });
+
+      return {
+        success: true,
+        inscriptions: inscriptions.map(i => ({
+          inscription_id: i.inscription_id,
+          type: i.type,
+          content_preview: i.content_preview || i.content?.substring(0, 100),
+          author: i.author,
+          platform: i.platform,
+          inscribed_at: i.inscribed_at || i.captured_at,
+          consensus_timestamp: i.consensus_timestamp
+        })),
+        count: inscriptions.length,
+        topic_id: topicId,
+        verify_url: `https://hashscan.io/${network}/topic/${topicId}`
+      };
+    } catch (error) {
+      logToolExecution({
+        command: 'history',
+        network,
+        topicId,
+        operator,
+        status: 'error',
+        latency: timer(),
+        error: error.message
+      });
+      return {
+        success: false,
+        error: `履歴取得エラー: ${error.message}`,
+        inscriptions: [],
+        count: 0
+      };
+    }
+  }
+};