@yamo/mcp-server 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 YAMO Protocol
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,36 @@
+# 🤖 YAMO Chain MCP Server (v1.0.0 - Protocol v0.4)
+
+This MCP Server acts as a bridge, allowing LLMs to interact with the YAMO Blockchain. It is now powered by `@yamo/core` for robust IPFS handling.
+
+## 🧰 Tools Provided
+
+### `yamo_submit_block`
+Submits a new reasoning block.
+*   **Input**: `blockId`, `contentHash`, etc.
+*   **New Feature**: `content` (string) and `files` (array). If provided, the server handles IPFS uploading and Deep Bundling automatically before signing.
+*   **Encryption**: Optional `encryptionKey` (string). If provided, the bundle is encrypted (AES-256-GCM) before upload, ensuring privacy for sensitive reasoning chains.
+
+### `yamo_verify_block`
+Verifies if a specific hash matches the immutable record.
+
+## ⚙️ Configuration
+
+Add to your Claude Desktop config (`claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "yamo-chain": {
+      "command": "node",
+      "args": ["/absolute/path/to/yamo/packages/mcp-server/dist/index.js"],
+      "env": {
+        "CONTRACT_ADDRESS": "0xe7f1...",
+        "RPC_URL": "http://127.0.0.1:8545",
+        "PRIVATE_KEY": "0x...",
+        "USE_REAL_IPFS": "true",
+        "PINATA_JWT": "eyJ..."
+      }
+    }
+  }
+}
+```

package/dist/index.js

@@ -0,0 +1,154 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const core_1 = require("@yamo/core");
+const dotenv = __importStar(require("dotenv"));
+const fs_1 = __importDefault(require("fs"));
+dotenv.config();
+const SUBMIT_BLOCK_TOOL = {
+    name: "yamo_submit_block",
+    description: "Submits a YAMO block to the YAMORegistry smart contract.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            blockId: { type: "string" },
+            previousBlock: { type: "string" },
+            contentHash: { type: "string" },
+            consensusType: { type: "string" },
+            ledger: { type: "string" },
+            content: { type: "string", description: "Optional: Full YAMO text content for IPFS anchoring." },
+            encryptionKey: { type: "string", description: "Optional: Key to encrypt the IPFS bundle." },
+            files: {
+                type: "array",
+                items: { type: "object", properties: { name: { type: "string" }, content: { type: "string" } } },
+                description: "Optional: Array of output files to bundle. Each file's 'content' can be either the actual file content (string) or a file path (will be auto-read)."
+            }
+        },
+        required: ["blockId", "previousBlock", "contentHash", "consensusType", "ledger"],
+    },
+};
+const VERIFY_BLOCK_TOOL = {
+    name: "yamo_verify_block",
+    description: "Verifies a block's content hash.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            blockId: { type: "string" },
+            contentHash: { type: "string" },
+        },
+        required: ["blockId", "contentHash"],
+    },
+};
+class YamoMcpServer {
+    server;
+    ipfs;
+    chain;
+    constructor() {
+        this.server = new index_js_1.Server({ name: "yamo", version: "1.0.0" }, { capabilities: { tools: {} } });
+        this.ipfs = new core_1.IpfsManager();
+        this.chain = new core_1.YamoChainClient();
+        this.setupHandlers();
+    }
+    setupHandlers() {
+        this.server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
+            tools: [SUBMIT_BLOCK_TOOL, VERIFY_BLOCK_TOOL],
+        }));
+        this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            try {
+                if (name === "yamo_submit_block") {
+                    const { blockId, previousBlock, contentHash, consensusType, ledger, content, files, encryptionKey } = args;
+                    // Process files - auto-read if they're file paths
+                    let processedFiles = files;
+                    if (files && Array.isArray(files)) {
+                        processedFiles = files.map((file) => {
+                            // Check if content is a file path that exists
+                            if (typeof file.content === 'string' && fs_1.default.existsSync(file.content)) {
+                                console.error(`Auto-reading file from path: ${file.content}`);
+                                return {
+                                    name: file.name,
+                                    content: fs_1.default.readFileSync(file.content, 'utf8')
+                                };
+                            }
+                            // Otherwise use content as-is
+                            return file;
+                        });
+                    }
+                    let ipfsCID = undefined;
+                    if (content) {
+                        ipfsCID = await this.ipfs.upload({
+                            content,
+                            files: processedFiles,
+                            encryptionKey
+                        });
+                    }
+                    const txHash = await this.chain.submitBlock(blockId, previousBlock, contentHash, consensusType, ledger, ipfsCID);
+                    return {
+                        content: [{ type: "text", text: `Block ${blockId} anchored. Tx: ${txHash}. IPFS: ${ipfsCID || "None"}` }],
+                    };
+                }
+                if (name === "yamo_verify_block") {
+                    const { blockId, contentHash } = args;
+                    const contract = this.chain.getContract(false);
+                    const hashBytes = contentHash.startsWith("0x") ? contentHash : `0x${contentHash}`;
+                    const isValid = await contract.verifyBlock(blockId, hashBytes);
+                    return {
+                        content: [{ type: "text", text: isValid ? "VERIFIED" : "FAILED" }],
+                    };
+                }
+                throw new Error(`Unknown tool: ${name}`);
+            }
+            catch (error) {
+                return {
+                    content: [{ type: "text", text: `Error: ${error.message}` }],
+                    isError: true,
+                };
+            }
+        });
+    }
+    async run() {
+        const transport = new stdio_js_1.StdioServerTransport();
+        await this.server.connect(transport);
+        console.error("YAMO MCP Server v1.0.0 running on stdio");
+    }
+}
+const server = new YamoMcpServer();
+server.run().catch(console.error);

package/dist/integration-test.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/client/stdio.js");
+const crypto_1 = __importDefault(require("crypto"));
+async function runTest() {
+    const transport = new stdio_js_1.StdioClientTransport({
+        command: "node",
+        args: ["dist/index.js"],
+        env: {
+            ...process.env,
+            CONTRACT_ADDRESS: "0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512",
+            RPC_URL: "http://127.0.0.1:8545"
+        }
+    });
+    const client = new index_js_1.Client({
+        name: "test-agent",
+        version: "1.0.0"
+    }, {
+        capabilities: {}
+    });
+    await client.connect(transport);
+    // Define a YAMO Genesis Block
+    const yamoContent = `
+block: 00001;
+previous_block: 0;
+agent: Genesis_Agent;
+intent: initialize_yamo_chain;
+output: yamo_chain_started;
+meta: hypothesis;Blockchain anchoring works;
+meta: confidence;1.0;
+signature: genesis_sig;
+  `.trim();
+    const contentHash = crypto_1.default.createHash('sha256').update(yamoContent).digest('hex');
+    console.log("Submitting YAMO Genesis Block...");
+    const submitResult = await client.callTool({
+        name: "yamo_submit_block",
+        arguments: {
+            blockId: "00001",
+            previousBlock: "0",
+            contentHash: contentHash,
+            consensusType: "genesis",
+            ledger: "local_hardhat"
+        }
+    });
+    console.log("Submit Result:", JSON.stringify(submitResult, null, 2));
+    console.log("\nVerifying Block...");
+    const verifyResult = await client.callTool({
+        name: "yamo_verify_block",
+        arguments: {
+            blockId: "00001",
+            contentHash: contentHash
+        }
+    });
+    console.log("Verify Result:", JSON.stringify(verifyResult, null, 2));
+    process.exit(0);
+}
+runTest().catch(console.error);

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@yamo/mcp-server",
+  "version": "1.0.0",
+  "description": "YAMO Protocol v0.4 - Model Context Protocol server for AI agents",
+  "main": "dist/index.js",
+  "type": "commonjs",
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "start": "node dist/index.js",
+    "dev": "ts-node src/index.ts"
+  },
+  "keywords": [
+    "yamo",
+    "mcp",
+    "ai",
+    "agent"
+  ],
+  "author": "YAMO Protocol",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yamo-protocol/yamo-mcp-server.git"
+  },
+  "bugs": {
+    "url": "https://github.com/yamo-protocol/yamo-mcp-server/issues"
+  },
+  "homepage": "https://github.com/yamo-protocol/yamo-mcp-server#readme",
+  "devDependencies": {
+    "@types/form-data": "^2.2.1",
+    "@types/node": "^25.0.3",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.25.1",
+    "@yamo/core": "^1.0.0",
+    "axios": "^1.13.2",
+    "dotenv": "^17.2.3",
+    "form-data": "^4.0.5"
+  }
+}