@yamo/mcp-server 1.3.10 → 1.3.11

package/dist/index.js

@@ -47,19 +47,45 @@ const crypto_1 = __importDefault(require("crypto"));
 const path_1 = __importDefault(require("path"));
 const pkg = JSON.parse(fs_1.default.readFileSync(path_1.default.join(__dirname, '../package.json'), 'utf8'));
 dotenv.config();
+// Constants
+const GENESIS_HASH = "0x0000000000000000000000000000000000000000000000000000000000000000";
+const TOOL_NAMES = {
+    SUBMIT_BLOCK: "yamo_submit_block",
+    GET_BLOCK: "yamo_get_block",
+    GET_LATEST_BLOCK: "yamo_get_latest_block",
+    AUDIT_BLOCK: "yamo_audit_block",
+    VERIFY_BLOCK: "yamo_verify_block",
+};
+const LOG_PREFIX = {
+    DEBUG: "[DEBUG]",
+    INFO: "[INFO]",
+    ERROR: "[ERROR]",
+};
+const VALIDATION_RULES = {
+    BYTES32_PATTERN: /^0x[a-fA-F0-9]{64}$/,
+    ETH_ADDRESS_PATTERN: /^0x[a-fA-F0-9]{40}$/,
+};
 // Validation helpers
 function validateBytes32(value, fieldName) {
-    if (!value.match(/^0x[a-fA-F0-9]{64}$/)) {
+    if (!value.match(VALIDATION_RULES.BYTES32_PATTERN)) {
         throw new Error(`${fieldName} must be a valid bytes32 hash (0x + 64 hex chars). ` +
             `Received: ${value.substring(0, 20)}...` +
             `\nDo NOT include algorithm prefixes like "sha256:"`);
     }
 }
 function validateEthereumAddress(address, fieldName) {
-    if (!address || !address.match(/^0x[a-fA-F0-9]{40}$/)) {
+    if (!address || !address.match(VALIDATION_RULES.ETH_ADDRESS_PATTERN)) {
         throw new Error(`${fieldName} must be a valid Ethereum address (0x + 40 hex characters)`);
     }
 }
+function validateBlockId(blockId) {
+    if (!blockId)
+        throw new Error("blockId is required");
+    const parts = blockId.split('_');
+    if (parts.length < 2) {
+        throw new Error(`blockId must follow format {origin}_{workflow} (e.g., 'claude_chain'). Received: ${blockId}`);
+    }
+}
 function validateEnvironment() {
     const requiredEnvVars = ['CONTRACT_ADDRESS', 'RPC_URL', 'PRIVATE_KEY'];
     const missing = requiredEnvVars.filter(v => !process.env[v]);
@@ -275,6 +301,238 @@ class YamoMcpServer {
         this.chain = new core_1.YamoChainClient();
         this.setupHandlers();
     }
+    // Response formatting helpers
+    createSuccessResponse(data) {
+        return {
+            content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+        };
+    }
+    createErrorResponse(error, isError = true) {
+        return {
+            content: [{ type: "text", text: JSON.stringify(error, null, 2) }],
+            isError,
+        };
+    }
+    createTextResponse(text) {
+        return { content: [{ type: "text", text }] };
+    }
+    // Logging helper
+    log(level, message) {
+        const prefix = LOG_PREFIX[level];
+        console.error(`${prefix} ${message}`);
+    }
+    // Cache update helper
+    updateLatestBlockCache(contentHash) {
+        this.latestContentHash = contentHash;
+        this.log('INFO', `Updated latestContentHash cache: ${contentHash}`);
+    }
+    // Block formatting helper
+    formatBlockResponse(block) {
+        return {
+            blockId: block.blockId,
+            previousBlock: block.previousBlock,
+            agentAddress: block.agentAddress,
+            contentHash: block.contentHash,
+            timestamp: block.timestamp,
+            timestampISO: new Date(block.timestamp * 1000).toISOString(),
+            consensusType: block.consensusType,
+            ledger: block.ledger,
+            ipfsCID: block.ipfsCID || null
+        };
+    }
+    // File security validation
+    validateFileSecurity(filePath) {
+        const realPath = fs_1.default.realpathSync(filePath);
+        const allowedDir = fs_1.default.realpathSync(process.cwd());
+        const stats = fs_1.default.lstatSync(filePath);
+        if (stats.isSymbolicLink()) {
+            throw new Error(`Symbolic links are not allowed: ${filePath}`);
+        }
+        if (!realPath.startsWith(allowedDir)) {
+            throw new Error(`File path outside allowed directory: ${filePath}`);
+        }
+    }
+    // File processing helper
+    async processSingleFile(file) {
+        if (typeof file.content === 'string' && fs_1.default.existsSync(file.content)) {
+            this.validateFileSecurity(file.content);
+            this.log('DEBUG', `Auto-reading file from path: ${file.content}`);
+            const content = await fs_1.default.promises.readFile(fs_1.default.realpathSync(file.content), 'utf8');
+            return { name: file.name, content };
+        }
+        return file;
+    }
+    // Previous block resolution helper
+    async resolvePreviousBlock(previousBlock) {
+        if (previousBlock)
+            return previousBlock;
+        this.log('INFO', 'No previousBlock provided, fetching latest block from chain...');
+        if (this.latestContentHash) {
+            this.log('INFO', `Using cached latest block's contentHash: ${this.latestContentHash}`);
+            return this.latestContentHash;
+        }
+        const latestHash = await this.chain.getLatestBlockHash();
+        if (latestHash && latestHash !== GENESIS_HASH) {
+            this.latestContentHash = latestHash;
+            this.log('INFO', `Using latest block's contentHash from contract: ${latestHash}`);
+            return latestHash;
+        }
+        this.log('INFO', 'No existing blocks found, using genesis');
+        return GENESIS_HASH;
+    }
+    async handleSubmitBlock(args) {
+        const { blockId, previousBlock, contentHash, consensusType, ledger, content, files, encryptionKey } = args;
+        // Validate inputs
+        validateBlockId(blockId);
+        validateBytes32(contentHash, "contentHash");
+        if (previousBlock) {
+            validateBytes32(previousBlock, "previousBlock");
+        }
+        // Process files with security validation
+        const processedFiles = files && Array.isArray(files)
+            ? await Promise.all(files.map(f => this.processSingleFile(f)))
+            : files;
+        // Resolve previous block hash
+        const resolvedPreviousBlock = await this.resolvePreviousBlock(previousBlock);
+        // Upload to IPFS if content provided
+        let ipfsCID = undefined;
+        if (content) {
+            ipfsCID = await this.ipfs.upload({
+                content,
+                files: processedFiles,
+                encryptionKey
+            });
+        }
+        // Submit to blockchain
+        const tx = await this.chain.submitBlock(blockId, resolvedPreviousBlock, contentHash, consensusType, ledger, ipfsCID);
+        const receipt = await tx.wait();
+        // Update cache
+        this.updateLatestBlockCache(contentHash);
+        return this.createSuccessResponse({
+            success: true,
+            blockId,
+            transactionHash: tx.hash,
+            blockNumber: receipt.blockNumber,
+            gasUsed: receipt.gasUsed.toString(),
+            effectiveGasPrice: receipt.effectiveGasPrice?.toString(),
+            ipfsCID: ipfsCID || null,
+            previousBlock: resolvedPreviousBlock,
+            contractAddress: this.chain.getContractAddress(),
+            timestamp: new Date().toISOString()
+        });
+    }
+    async handleGetBlock(args) {
+        const { blockId } = args;
+        const block = await this.chain.getBlock(blockId);
+        if (!block) {
+            return this.createErrorResponse({
+                success: false,
+                error: "Block not found on-chain",
+                blockId,
+                hint: "Verify the blockId or check if the block was submitted"
+            });
+        }
+        return this.createSuccessResponse({
+            success: true,
+            block: this.formatBlockResponse(block)
+        });
+    }
+    async handleGetLatestBlock() {
+        const latestBlock = await this.chain.getLatestBlock();
+        if (!latestBlock) {
+            return this.createErrorResponse({
+                success: false,
+                error: "No blocks found on-chain",
+                hint: "The chain may be empty. Try submitting a genesis block first."
+            });
+        }
+        return this.createSuccessResponse({
+            success: true,
+            block: this.formatBlockResponse(latestBlock)
+        });
+    }
+    async handleAuditBlock(args) {
+        const { blockId, encryptionKey } = args;
+        const block = await this.chain.getBlock(blockId);
+        if (!block) {
+            return this.createErrorResponse({
+                verified: false,
+                error: "Block not found on-chain",
+                blockId,
+                hint: "Cannot audit non-existent block"
+            });
+        }
+        if (!block.ipfsCID) {
+            return this.createSuccessResponse({
+                verified: null,
+                onChainHash: block.contentHash,
+                ipfsCID: null,
+                note: "V1 block with no IPFS CID - cannot audit actual content",
+                blockId,
+                agentAddress: block.agentAddress,
+                timestamp: block.timestamp
+            });
+        }
+        try {
+            const bundle = await this.ipfs.downloadBundle(block.ipfsCID, encryptionKey);
+            const computedHash = "0x" + crypto_1.default.createHash("sha256").update(bundle.block).digest("hex");
+            const verified = computedHash === block.contentHash;
+            return this.createSuccessResponse({
+                verified,
+                blockId,
+                onChainHash: block.contentHash,
+                computedHash,
+                ipfsCID: block.ipfsCID,
+                agentAddress: block.agentAddress,
+                timestamp: block.timestamp,
+                timestampISO: new Date(block.timestamp * 1000).toISOString(),
+                consensusType: block.consensusType,
+                ledger: block.ledger,
+                contentPreview: bundle.block.substring(0, 500) + (bundle.block.length > 500 ? "..." : ""),
+                contentLength: bundle.block.length,
+                artifactFiles: Object.keys(bundle.files),
+                wasEncrypted: !!encryptionKey
+            });
+        }
+        catch (error) {
+            let errorType = "unknown";
+            let hint = "";
+            if (error.message.includes("encrypted") && !encryptionKey) {
+                errorType = "missing_key";
+                hint = "This bundle is encrypted. Provide encryptionKey to audit.";
+            }
+            else if (error.message.includes("Decryption failed") || error.message.includes("decrypt")) {
+                errorType = "decryption_failed";
+                hint = "The provided encryption key may be incorrect.";
+            }
+            else if (error.message.includes("not found on-chain")) {
+                errorType = "block_not_found";
+                hint = "Verify the blockId was submitted correctly.";
+            }
+            return this.createErrorResponse({
+                verified: false,
+                error: error.message,
+                errorType,
+                hint,
+                blockId
+            });
+        }
+    }
+    async handleVerifyBlock(args) {
+        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 this.createTextResponse(isValid ? "VERIFIED" : "FAILED");
+    }
+    // Tool handler registry
+    toolHandlers = {
+        [TOOL_NAMES.SUBMIT_BLOCK]: (args) => this.handleSubmitBlock(args),
+        [TOOL_NAMES.GET_BLOCK]: (args) => this.handleGetBlock(args),
+        [TOOL_NAMES.GET_LATEST_BLOCK]: () => this.handleGetLatestBlock(),
+        [TOOL_NAMES.AUDIT_BLOCK]: (args) => this.handleAuditBlock(args),
+        [TOOL_NAMES.VERIFY_BLOCK]: (args) => this.handleVerifyBlock(args),
+    };
     setupHandlers() {
         this.server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
             tools: [SUBMIT_BLOCK_TOOL, GET_BLOCK_TOOL, GET_LATEST_BLOCK_TOOL, AUDIT_BLOCK_TOOL, VERIFY_BLOCK_TOOL],
@@ -282,261 +540,26 @@ class YamoMcpServer {
         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 (with security fix)
-                    let processedFiles = files;
-                    if (files && Array.isArray(files)) {
-                        processedFiles = await Promise.all(files.map(async (file) => {
-                            // Check if content is a file path that exists
-                            if (typeof file.content === 'string' && fs_1.default.existsSync(file.content)) {
-                                // Security: Resolve symlinks and restrict to cwd (prevents symlink attacks and TOCTOU)
-                                const filePath = fs_1.default.realpathSync(file.content);
-                                const allowedDir = fs_1.default.realpathSync(process.cwd());
-                                // Check for symlinks
-                                const stats = fs_1.default.lstatSync(file.content);
-                                if (stats.isSymbolicLink()) {
-                                    throw new Error(`Symbolic links are not allowed: ${file.content}`);
-                                }
-                                if (!filePath.startsWith(allowedDir)) {
-                                    throw new Error(`File path outside allowed directory: ${file.content}`);
-                                }
-                                console.error(`[DEBUG] Auto-reading file from path: ${file.content}`);
-                                return {
-                                    name: file.name,
-                                    content: await fs_1.default.promises.readFile(filePath, 'utf8')
-                                };
-                            }
-                            // Otherwise use content as-is
-                            return file;
-                        }));
-                    }
-                    // Input validation (Part 3: Security Fixes)
-                    validateBytes32(contentHash, "contentHash");
-                    // Auto-fetch previousBlock if not provided
-                    let resolvedPreviousBlock = previousBlock;
-                    if (!resolvedPreviousBlock) {
-                        console.error(`[INFO] No previousBlock provided, fetching latest block from chain...`);
-                        // First, try the cache (most reliable for chain continuation)
-                        if (this.latestContentHash) {
-                            resolvedPreviousBlock = this.latestContentHash;
-                            console.error(`[INFO] Using cached latest block's contentHash: ${resolvedPreviousBlock}`);
-                        }
-                        else {
-                            // Fallback to direct contract state read (reliable)
-                            const latestHash = await this.chain.getLatestBlockHash();
-                            if (latestHash && latestHash !== "0x0000000000000000000000000000000000000000000000000000000000000000") {
-                                resolvedPreviousBlock = latestHash;
-                                this.latestContentHash = latestHash; // Update cache
-                                console.error(`[INFO] Using latest block's contentHash from contract: ${resolvedPreviousBlock}`);
-                            }
-                            else {
-                                // No blocks exist yet, use genesis
-                                resolvedPreviousBlock = "0x0000000000000000000000000000000000000000000000000000000000000000";
-                                console.error(`[INFO] No existing blocks found, using genesis`);
-                            }
-                        }
-                    }
-                    else if (previousBlock) {
-                        validateBytes32(previousBlock, "previousBlock");
-                    }
-                    let ipfsCID = undefined;
-                    if (content) {
-                        ipfsCID = await this.ipfs.upload({
-                            content,
-                            files: processedFiles,
-                            encryptionKey
-                        });
-                    }
-                    const tx = await this.chain.submitBlock(blockId, resolvedPreviousBlock, contentHash, consensusType, ledger, ipfsCID);
-                    const receipt = await tx.wait();
-                    // Update cache with the new block's contentHash for chain continuation
-                    this.latestContentHash = contentHash;
-                    console.error(`[INFO] Updated latestContentHash cache: ${contentHash}`);
-                    return {
-                        content: [{ type: "text", text: JSON.stringify({
-                                    success: true,
-                                    blockId,
-                                    transactionHash: tx.hash,
-                                    blockNumber: receipt.blockNumber,
-                                    gasUsed: receipt.gasUsed.toString(),
-                                    effectiveGasPrice: receipt.effectiveGasPrice?.toString(),
-                                    ipfsCID: ipfsCID || null,
-                                    previousBlock: resolvedPreviousBlock,
-                                    contractAddress: this.chain.getContractAddress(),
-                                    timestamp: new Date().toISOString()
-                                }, null, 2) }],
-                    };
-                }
-                if (name === "yamo_get_block") {
-                    const { blockId } = args;
-                    const block = await this.chain.getBlock(blockId);
-                    if (!block) {
-                        return {
-                            content: [{ type: "text", text: JSON.stringify({
-                                        success: false,
-                                        error: "Block not found on-chain",
-                                        blockId,
-                                        hint: "Verify the blockId or check if the block was submitted"
-                                    }, null, 2) }],
-                            isError: true,
-                        };
-                    }
-                    return {
-                        content: [{ type: "text", text: JSON.stringify({
-                                    success: true,
-                                    block: {
-                                        blockId: block.blockId,
-                                        previousBlock: block.previousBlock,
-                                        agentAddress: block.agentAddress,
-                                        contentHash: block.contentHash,
-                                        timestamp: block.timestamp,
-                                        timestampISO: new Date(block.timestamp * 1000).toISOString(),
-                                        consensusType: block.consensusType,
-                                        ledger: block.ledger,
-                                        ipfsCID: block.ipfsCID || null
-                                    }
-                                }, null, 2) }],
-                    };
-                }
-                if (name === "yamo_get_latest_block") {
-                    const latestBlock = await this.chain.getLatestBlock();
-                    if (!latestBlock) {
-                        return {
-                            content: [{ type: "text", text: JSON.stringify({
-                                        success: false,
-                                        error: "No blocks found on-chain",
-                                        hint: "The chain may be empty. Try submitting a genesis block first."
-                                    }, null, 2) }],
-                            isError: true,
-                        };
-                    }
-                    return {
-                        content: [{ type: "text", text: JSON.stringify({
-                                    success: true,
-                                    block: {
-                                        blockId: latestBlock.blockId,
-                                        previousBlock: latestBlock.previousBlock,
-                                        agentAddress: latestBlock.agentAddress,
-                                        contentHash: latestBlock.contentHash,
-                                        timestamp: latestBlock.timestamp,
-                                        timestampISO: new Date(latestBlock.timestamp * 1000).toISOString(),
-                                        consensusType: latestBlock.consensusType,
-                                        ledger: latestBlock.ledger,
-                                        ipfsCID: latestBlock.ipfsCID || null
-                                    }
-                                }, null, 2) }],
-                    };
-                }
-                if (name === "yamo_audit_block") {
-                    const { blockId, encryptionKey } = args;
-                    // Get block from chain
-                    const block = await this.chain.getBlock(blockId);
-                    if (!block) {
-                        return {
-                            content: [{ type: "text", text: JSON.stringify({
-                                        verified: false,
-                                        error: "Block not found on-chain",
-                                        blockId,
-                                        hint: "Cannot audit non-existent block"
-                                    }, null, 2) }],
-                            isError: true,
-                        };
-                    }
-                    // If no IPFS CID, can't audit content
-                    if (!block.ipfsCID) {
-                        return {
-                            content: [{ type: "text", text: JSON.stringify({
-                                        verified: null, // Cannot verify without IPFS
-                                        onChainHash: block.contentHash,
-                                        ipfsCID: null,
-                                        note: "V1 block with no IPFS CID - cannot audit actual content",
-                                        blockId,
-                                        agentAddress: block.agentAddress,
-                                        timestamp: block.timestamp
-                                    }, null, 2) }],
-                        };
-                    }
-                    // Download and verify from IPFS
-                    try {
-                        const bundle = await this.ipfs.downloadBundle(block.ipfsCID, encryptionKey);
-                        const computedHash = "0x" + crypto_1.default.createHash("sha256").update(bundle.block).digest("hex");
-                        const verified = computedHash === block.contentHash;
-                        return {
-                            content: [{ type: "text", text: JSON.stringify({
-                                        verified,
-                                        blockId,
-                                        onChainHash: block.contentHash,
-                                        computedHash,
-                                        ipfsCID: block.ipfsCID,
-                                        agentAddress: block.agentAddress,
-                                        timestamp: block.timestamp,
-                                        timestampISO: new Date(block.timestamp * 1000).toISOString(),
-                                        consensusType: block.consensusType,
-                                        ledger: block.ledger,
-                                        contentPreview: bundle.block.substring(0, 500) + (bundle.block.length > 500 ? "..." : ""),
-                                        contentLength: bundle.block.length,
-                                        artifactFiles: Object.keys(bundle.files),
-                                        wasEncrypted: !!encryptionKey
-                                    }, null, 2) }],
-                        };
-                    }
-                    catch (error) {
-                        // Enhanced error messages
-                        let errorType = "unknown";
-                        let hint = "";
-                        if (error.message.includes("encrypted") && !encryptionKey) {
-                            errorType = "missing_key";
-                            hint = "This bundle is encrypted. Provide encryptionKey to audit.";
-                        }
-                        else if (error.message.includes("Decryption failed") || error.message.includes("decrypt")) {
-                            errorType = "decryption_failed";
-                            hint = "The provided encryption key may be incorrect.";
-                        }
-                        else if (error.message.includes("not found on-chain")) {
-                            errorType = "block_not_found";
-                            hint = "Verify the blockId was submitted correctly.";
-                        }
-                        return {
-                            content: [{ type: "text", text: JSON.stringify({
-                                        verified: false,
-                                        error: error.message,
-                                        errorType,
-                                        hint,
-                                        blockId
-                                    }, null, 2) }],
-                            isError: true,
-                        };
-                    }
-                }
-                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" }],
-                    };
+                const handler = this.toolHandlers[name];
+                if (!handler) {
+                    throw new Error(`Unknown tool: ${name}`);
                 }
-                throw new Error(`Unknown tool: ${name}`);
+                return await handler(args);
             }
             catch (error) {
-                return {
-                    content: [{ type: "text", text: JSON.stringify({
-                                success: false,
-                                error: error.message,
-                                tool: name,
-                                timestamp: new Date().toISOString()
-                            }, null, 2) }],
-                    isError: true,
-                };
+                return this.createErrorResponse({
+                    success: false,
+                    error: error.message,
+                    tool: name,
+                    timestamp: new Date().toISOString()
+                });
             }
         });
     }
     async run() {
         const transport = new stdio_js_1.StdioServerTransport();
         await this.server.connect(transport);
-        console.error(`YAMO MCP Server v${pkg.version} running on stdio`);
+        this.log('INFO', `YAMO MCP Server v${pkg.version} running on stdio`);
     }
 }
 const server = new YamoMcpServer();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yamo/mcp-server",
-  "version": "1.3.10",
+  "version": "1.3.11",
   "description": "YAMO Protocol v0.4 - Model Context Protocol server for AI agents",
   "main": "dist/index.js",
   "type": "commonjs",