@jkumonpm/hash-crypto-mcp 2.0.0

package/README.md

@@ -0,0 +1,226 @@
+# hash-crypto-mcp
+
+Hash & Crypto MCP server. Hash, UUID, random strings, AES encrypt/decrypt.
+
+No external dependencies. Pure Node.js crypto.
+
+## Install
+
+```bash
+npm install -g hash-crypto-mcp
+```
+
+## Usage
+
+### Claude Desktop / Cursor / OpenCode
+
+Add to your MCP config:
+
+```json
+{
+  "mcpServers": {
+    "hash-crypto": {
+      "command": "npx",
+      "args": ["-y", "hash-crypto-mcp"]
+    }
+  }
+}
+```
+
+## Tools
+
+### `generate_hash` — Generate Hash
+
+Generate a cryptographic hash of the input string.
+
+**Input:**
+```json
+{
+  "algorithm": "sha256",
+  "input": "hello world"
+}
+```
+
+**Output:**
+```json
+{
+  "algorithm": "sha256",
+  "input": "hello world",
+  "hash": "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"
+}
+```
+
+**Supported algorithms:** `md5`, `sha1`, `sha256`, `sha512`
+
+### `generate_uuid` — Generate UUID
+
+Generate UUIDs (v4 or v7).
+
+**Input:**
+```json
+{
+  "version": "4",
+  "count": 3
+}
+```
+
+**Output:**
+```json
+{
+  "version": 4,
+  "count": 3,
+  "uuids": [
+    "550e8400-e29b-41d4-a716-446655440000",
+    "6ba7b810-9dad-11d1-80b4-00c04fd430c8",
+    "6ba7b811-9dad-11d1-80b4-00c04fd430c8"
+  ]
+}
+```
+
+### `generate_random_string` — Generate Random String
+
+Generate random strings with specified length and character set.
+
+**Input:**
+```json
+{
+  "length": 16,
+  "charset": "alphanumeric",
+  "count": 3
+}
+```
+
+**Output:**
+```json
+{
+  "length": 16,
+  "charset": "alphanumeric",
+  "count": 3,
+  "strings": ["aB3xK9mP2qR7sT1v", "wY5zN8jL4hF6gD0c", "eU2iO7pA3bM9nQ1x"]
+}
+```
+
+**Built-in charsets:** `alphanumeric`, `lowercase`, `uppercase`, `digits`, `hex`, `symbols`, `printable`
+
+You can also pass a custom charset string directly.
+
+### `seed_random_string` — Seed-Based Random String
+
+Generate a **deterministic** random string from a seed. Same seed + same params always produce the same output.
+
+**Input:**
+```json
+{
+  "seed": "user-123-api-key",
+  "length": 32,
+  "charset": "hex"
+}
+```
+
+**Output:**
+```json
+{
+  "seed": "user-123-api-key",
+  "length": 32,
+  "charset": "hex",
+  "string": "a3f8c2d1e9b7..."
+}
+```
+
+**Use cases:**
+- Generate reproducible API keys or tokens from a seed
+- Create deterministic test data
+- Password template generation
+
+### `encrypt_string` — Encrypt/Decrypt String
+
+AES-256-CBC encrypt or decrypt a string.
+
+**Encrypt:**
+```json
+{
+  "action": "encrypt",
+  "text": "secret message",
+  "password": "mykey123"
+}
+```
+
+**Output:**
+```json
+{
+  "action": "encrypt",
+  "encrypted": "a1b2c3d4e5f6...",
+  "salt": "abcdef1234567890...",
+  "iv": "1234567890abcdef..."
+}
+```
+
+**Decrypt:**
+```json
+{
+  "action": "decrypt",
+  "encrypted": "a1b2c3d4e5f6...",
+  "password": "mykey123",
+  "salt": "abcdef1234567890...",
+  "iv": "1234567890abcdef..."
+}
+```
+
+**Output:**
+```json
+{
+  "action": "decrypt",
+  "decrypted": "secret message"
+}
+```
+
+### `verify_hash` — Verify Hash
+
+Verify that a string produces the expected hash. Returns match status and the actual hash.
+
+**Input:**
+```json
+{
+  "algorithm": "sha256",
+  "input": "hello world",
+  "expected": "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"
+}
+```
+
+**Output (match):**
+```json
+{
+  "algorithm": "sha256",
+  "input": "hello world",
+  "expected": "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9",
+  "match": true,
+  "actual": "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"
+}
+```
+
+**Output (mismatch):**
+```json
+{
+  "algorithm": "sha256",
+  "input": "hello world",
+  "expected": "0000000000000000000000000000000000000000000000000000000000000000",
+  "match": false,
+  "actual": "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"
+}
+```
+
+## Design
+
+| Feature | Why |
+|---------|-----|
+| Zero runtime deps | Only `@modelcontextprotocol/sdk` and `zod` |
+| Native crypto | Uses `node:crypto` — no external libraries |
+| AES-256-CBC | Industry-standard encryption with random salt + IV |
+| UUID v7 support | Timestamp-based UUIDs for sortable IDs |
+| Dynamic charset | Pass any custom character string |
+| Seed-based random | Deterministic output for reproducible results |
+| Hash verification | One-step verify with match status |
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,293 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { createHash, randomUUID, randomInt, randomBytes, scryptSync, createCipheriv, createDecipheriv, createHmac } from 'node:crypto';
+// ============================================================
+// Constants
+// ============================================================
+const HASH_ALGORITHMS = ['md5', 'sha1', 'sha256', 'sha512'];
+const UUID_VERSIONS = [4, 7];
+const CHARSET_MAP = {
+    alphanumeric: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789',
+    lowercase: 'abcdefghijklmnopqrstuvwxyz',
+    uppercase: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
+    digits: '0123456789',
+    hex: '0123456789abcdef',
+    symbols: '!@#$%^&*()_+-=[]{}|;:,.<>?',
+    printable: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789 !@#$%^&*()_+-=[]{}|;:,.<>?',
+};
+const DEFAULT_CHARSET = 'alphanumeric';
+// ============================================================
+// Helpers
+// ============================================================
+function generateHash(algorithm, input) {
+    if (!HASH_ALGORITHMS.includes(algorithm)) {
+        throw new Error(`Unsupported algorithm: ${algorithm}. Supported: ${HASH_ALGORITHMS.join(', ')}`);
+    }
+    return createHash(algorithm).update(input).digest('hex');
+}
+function generateUuid(version) {
+    if (!UUID_VERSIONS.includes(version)) {
+        throw new Error(`Unsupported UUID version: ${version}. Supported: ${UUID_VERSIONS.join(', ')}`);
+    }
+    // Node.js randomUUID() generates v4 by default
+    // For v7, we'll use v4 as fallback since Node 18 doesn't support v7 natively
+    if (version === 7) {
+        // Generate UUID v7: timestamp-based (48-bit ms timestamp + random)
+        const timestamp = Date.now();
+        const tsHex = timestamp.toString(16).padStart(12, '0');
+        const random = randomBytes(10);
+        random[0] = (random[0] & 0x0f) | 0x70; // version 7
+        random[1] = (random[1] & 0x3f) | 0x80; // variant 10
+        const randHex = random.toString('hex');
+        return `${tsHex.slice(0, 8)}-${tsHex.slice(8, 12)}-${randHex.slice(0, 4)}-${randHex.slice(4, 8)}-${randHex.slice(8, 20)}`;
+    }
+    return randomUUID();
+}
+function generateRandomString(length, charset) {
+    const chars = CHARSET_MAP[charset] ?? charset;
+    if (chars.length === 0) {
+        throw new Error('Charset is empty');
+    }
+    return Array.from({ length }, () => chars[randomInt(0, chars.length)]).join('');
+}
+function deriveKey(password, salt) {
+    return scryptSync(password, salt, 32);
+}
+function encryptString(text, password) {
+    const salt = randomBytes(16);
+    const iv = randomBytes(16);
+    const key = deriveKey(password, salt);
+    const cipher = createCipheriv('aes-256-cbc', key, iv);
+    let encrypted = cipher.update(text, 'utf8', 'hex');
+    encrypted += cipher.final('hex');
+    return {
+        encrypted,
+        salt: salt.toString('hex'),
+        iv: iv.toString('hex'),
+    };
+}
+function decryptString(encrypted, password, salt, iv) {
+    const saltBuf = Buffer.from(salt, 'hex');
+    const ivBuf = Buffer.from(iv, 'hex');
+    const key = deriveKey(password, saltBuf);
+    const decipher = createDecipheriv('aes-256-cbc', key, ivBuf);
+    let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+    decrypted += decipher.final('utf8');
+    return decrypted;
+}
+function generateSeedRandomString(seed, length, charset) {
+    const chars = CHARSET_MAP[charset] ?? charset;
+    if (chars.length === 0) {
+        throw new Error('Charset is empty');
+    }
+    // Use HMAC-SHA256 to create a deterministic PRNG from the seed
+    const hash = createHmac('sha256', seed).update('seed').digest('hex');
+    let result = '';
+    let hashIndex = 0;
+    let currentHash = hash;
+    for (let i = 0; i < length; i++) {
+        if (hashIndex >= currentHash.length) {
+            currentHash = createHmac('sha256', seed).update(`seed:${Math.floor(i / 64)}`).digest('hex');
+            hashIndex = 0;
+        }
+        const byteVal = parseInt(currentHash.slice(hashIndex, hashIndex + 2), 16);
+        result += chars[byteVal % chars.length];
+        hashIndex += 2;
+    }
+    return result;
+}
+function verifyHash(algorithm, input, expected) {
+    const actual = generateHash(algorithm, input);
+    return {
+        match: actual === expected,
+        actual,
+    };
+}
+// ============================================================
+// MCP Server
+// ============================================================
+const server = new McpServer({
+    name: 'hash-crypto',
+    version: '1.0.0',
+});
+// ===== Tool 1: generate_hash =====
+server.registerTool('generate_hash', {
+    title: 'Generate Hash',
+    description: 'Generate a cryptographic hash of the input string.',
+    inputSchema: z.object({
+        algorithm: z.enum(HASH_ALGORITHMS).describe('Hash algorithm (md5, sha1, sha256, sha512)'),
+        input: z.string().describe('Input string to hash'),
+    }),
+}, async ({ algorithm, input }) => {
+    try {
+        const hash = generateHash(algorithm, input);
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ algorithm, input, hash }, null, 2),
+                }],
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: 'text', text: JSON.stringify({ error: true, message }, null, 2) }], isError: true };
+    }
+});
+// ===== Tool 2: generate_uuid =====
+server.registerTool('generate_uuid', {
+    title: 'Generate UUID',
+    description: 'Generate a UUID (v4 or v7).',
+    inputSchema: z.object({
+        version: z.enum(['4', '7']).default('4').describe('UUID version (4 = random, 7 = timestamp-based)'),
+        count: z.number().int().min(1).max(100).default(1).describe('Number of UUIDs to generate'),
+    }),
+}, async ({ version, count }) => {
+    try {
+        const v = parseInt(version, 10);
+        const uuids = Array.from({ length: count }, () => generateUuid(v));
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ version: v, count: uuids.length, uuids }, null, 2),
+                }],
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: 'text', text: JSON.stringify({ error: true, message }, null, 2) }], isError: true };
+    }
+});
+// ===== Tool 3: generate_random_string =====
+server.registerTool('generate_random_string', {
+    title: 'Generate Random String',
+    description: 'Generate a random string with specified length and character set.',
+    inputSchema: z.object({
+        length: z.number().int().min(1).max(10000).describe('Length of the random string'),
+        charset: z.string().default(DEFAULT_CHARSET).describe('Character set name (alphanumeric, lowercase, uppercase, digits, hex, symbols, printable) or custom string'),
+        count: z.number().int().min(1).max(100).default(1).describe('Number of strings to generate'),
+    }),
+}, async ({ length, charset, count }) => {
+    try {
+        const strings = Array.from({ length: count }, () => generateRandomString(length, charset));
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ length, charset, count: strings.length, strings }, null, 2),
+                }],
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: 'text', text: JSON.stringify({ error: true, message }, null, 2) }], isError: true };
+    }
+});
+// ===== Tool 4: encrypt_string =====
+server.registerTool('encrypt_string', {
+    title: 'Encrypt/Decrypt String',
+    description: 'AES-256-CBC encrypt or decrypt a string. For encryption, provide text + password. For decryption, provide encrypted + password + salt + iv.',
+    inputSchema: z.object({
+        action: z.enum(['encrypt', 'decrypt']).describe('Action to perform'),
+        text: z.string().optional().describe('Text to encrypt (required for encrypt action)'),
+        password: z.string().describe('Password for encryption/decryption'),
+        encrypted: z.string().optional().describe('Encrypted hex string (required for decrypt action)'),
+        salt: z.string().optional().describe('Salt hex string (required for decrypt action)'),
+        iv: z.string().optional().describe('IV hex string (required for decrypt action)'),
+    }),
+}, async ({ action, text, password, encrypted, salt, iv }) => {
+    try {
+        if (action === 'encrypt') {
+            if (!text) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: true, message: 'text is required for encrypt action' }, null, 2) }], isError: true };
+            }
+            const result = encryptString(text, password);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ action: 'encrypt', ...result }, null, 2),
+                    }],
+            };
+        }
+        else {
+            if (!encrypted || !salt || !iv) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: true, message: 'encrypted, salt, and iv are required for decrypt action' }, null, 2) }], isError: true };
+            }
+            const decrypted = decryptString(encrypted, password, salt, iv);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ action: 'decrypt', decrypted }, null, 2),
+                    }],
+            };
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: 'text', text: JSON.stringify({ error: true, message }, null, 2) }], isError: true };
+    }
+});
+// ===== Tool 5: seed_random_string =====
+server.registerTool('seed_random_string', {
+    title: 'Seed-Based Random String',
+    description: 'Generate a deterministic random string from a seed. Same seed + same params always produce the same output.',
+    inputSchema: z.object({
+        seed: z.string().describe('Seed string for deterministic output'),
+        length: z.number().int().min(1).max(10000).describe('Length of the random string'),
+        charset: z.string().default(DEFAULT_CHARSET).describe('Character set name (alphanumeric, lowercase, uppercase, digits, hex, symbols, printable) or custom string'),
+    }),
+}, async ({ seed, length, charset }) => {
+    try {
+        const str = generateSeedRandomString(seed, length, charset);
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ seed, length, charset, string: str }, null, 2),
+                }],
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: 'text', text: JSON.stringify({ error: true, message }, null, 2) }], isError: true };
+    }
+});
+// ===== Tool 6: verify_hash =====
+server.registerTool('verify_hash', {
+    title: 'Verify Hash',
+    description: 'Verify that a string produces the expected hash. Returns match status and the actual hash.',
+    inputSchema: z.object({
+        algorithm: z.enum(HASH_ALGORITHMS).describe('Hash algorithm (md5, sha1, sha256, sha512)'),
+        input: z.string().describe('Input string to hash'),
+        expected: z.string().describe('Expected hash value to compare against'),
+    }),
+}, async ({ algorithm, input, expected }) => {
+    try {
+        const result = verifyHash(algorithm, input, expected);
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ algorithm, input, expected, match: result.match, actual: result.actual }, null, 2),
+                }],
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: 'text', text: JSON.stringify({ error: true, message }, null, 2) }], isError: true };
+    }
+});
+// ============================================================
+// Start
+// ============================================================
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('hash-crypto-mcp server running on stdio');
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});
+process.on('SIGINT', async () => {
+    await server.close();
+    process.exit(0);
+});

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@jkumonpm/hash-crypto-mcp",
+  "version": "2.0.0",
+  "description": "Hash & Crypto MCP server — hash, UUID, random strings, AES encrypt/decrypt",
+  "type": "module",
+  "main": "./dist/index.js",
+  "bin": {
+    "hash-crypto-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist/index.js",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "dev": "node --loader ts-node/esm src/index.ts",
+    "client": "npm run build && node dist/client.js",
+    "test": "npm run build && node dist/test-runner.js",
+    "clean": "node -e \"require('fs').rmSync('dist', { recursive: true, force: true })\"",
+    "security:audit": "node scripts/security-audit.mjs",
+    "release": "node scripts/release.mjs",
+    "release:dry": "node scripts/release.mjs --dry",
+    "release:patch": "node scripts/release.mjs patch",
+    "release:minor": "node scripts/release.mjs minor",
+    "prepublishOnly": "npm run typecheck && npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "hash",
+    "crypto",
+    "uuid",
+    "random",
+    "encrypt",
+    "decrypt"
+  ],
+  "author": "",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.28.0",
+    "zod": "^3.25.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.2"
+  },
+  "peerDependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "zod": "^3.24.0"
+  },
+  "peerDependenciesMeta": {
+    "@modelcontextprotocol/sdk": {
+      "optional": false
+    },
+    "zod": {
+      "optional": false
+    }
+  }
+}