@erickwendel/ciphersuite-mcp 0.0.5 → 0.0.7

package/{src/index.ts → build/index.js}

@@ -1,15 +1,11 @@
-#!/usr/bin/env node
-
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { server } from "./mcp.ts";
-
+import { server } from "./mcp.js";
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
     console.error("Encrypt MCP Server running on stdio");
 }
-
 main().catch((error) => {
     console.error("Fatal error in main():", error);
     process.exit(1);
-});
+});

package/build/mcp.js

@@ -0,0 +1,137 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { randomBytes, createCipheriv, createDecipheriv, scryptSync } from 'node:crypto';
+import z from "zod";
+export const server = new McpServer({
+    name: "@erickwendel/ciphersuite-mcp",
+    version: "0.0.1",
+});
+// Fixed salt — same passphrase always derives the same key so decryption works across calls
+const SALT = 'mcp-encrypter-salt';
+function deriveKey(passphrase) {
+    return scryptSync(passphrase, SALT, 32);
+}
+function encrypt(text, key) {
+    const iv = randomBytes(16);
+    const cipher = createCipheriv('aes-256-cbc', deriveKey(key), iv);
+    const encrypted = Buffer.concat([
+        cipher.update(Buffer.from(text, 'utf8')),
+        cipher.final(),
+    ]);
+    return `${iv.toString('hex')}:${encrypted.toString('hex')}`;
+}
+function decrypt(encryptedText, key) {
+    const [ivHex, ...rest] = encryptedText.split(':');
+    const iv = Buffer.from(ivHex, 'hex');
+    const encrypted = Buffer.from(rest.join(':'), 'hex');
+    const decipher = createDecipheriv('aes-256-cbc', deriveKey(key), iv);
+    const decrypted = Buffer.concat([
+        decipher.update(encrypted),
+        decipher.final(),
+    ]);
+    return decrypted.toString('utf8');
+}
+server.registerTool("encrypt_message", {
+    description: "Encrypt a message",
+    inputSchema: {
+        message: z.string().describe("The message to encrypt"),
+        encryptionKey: z.string().describe("Any passphrase to use for encryption — the server derives a strong key from it automatically"),
+    },
+    outputSchema: {
+        encryptedMessage: z.string().describe("The encrypted message (format: iv:ciphertext)"),
+    }
+}, async ({ message, encryptionKey }) => {
+    try {
+        const encryptedMessage = encrypt(message, encryptionKey);
+        return {
+            content: [{ type: "text", text: encryptedMessage }],
+            structuredContent: { encryptedMessage },
+        };
+    }
+    catch (err) {
+        return {
+            isError: true,
+            content: [{ type: "text", text: `Failed to encrypt message! Check if the message and encryption key are correct. Error details: ${err instanceof Error ? err.message : String(err)}` }],
+        };
+    }
+});
+server.registerTool("decrypt_message", {
+    description: "Decrypt a message that was encrypted with the encrypt_message tool",
+    inputSchema: {
+        encryptedMessage: z.string().describe("The encrypted message to decrypt (format: iv:ciphertext)"),
+        encryptionKey: z.string().describe("The same passphrase used during encryption"),
+    },
+    outputSchema: {
+        decryptedMessage: z.string().describe("The decrypted plain-text message"),
+    }
+}, async ({ encryptedMessage, encryptionKey }) => {
+    try {
+        const decryptedMessage = decrypt(encryptedMessage, encryptionKey);
+        return {
+            content: [{ type: "text", text: decryptedMessage }],
+            structuredContent: { decryptedMessage },
+        };
+    }
+    catch (err) {
+        return {
+            isError: true,
+            content: [
+                {
+                    type: "text",
+                    text: `Failed to decrypt message! Check if the encrypted message is correct and if the encryption key matches the one used for encryption. Error details: ${err instanceof Error ? err.message : String(err)}`,
+                },
+            ],
+        };
+    }
+});
+server.registerResource("encryption://info", "encryption://info", { description: "Describes the encryption algorithm, key requirements, and output format used by this server." }, async () => ({
+    contents: [
+        {
+            uri: "encryption://info",
+            mimeType: "text/plain",
+            text: `
+Algorithm : AES-256-CBC
+Key derivation: scrypt (passphrase + fixed server salt → 32-byte key)
+Output format: <16-byte IV in hex>:<ciphertext in hex>  (separated by ":")
+Notes:
+  - Users pass any passphrase — the server derives a strong 32-byte key automatically using scrypt.
+  - A random IV is generated for every encryption — the same message encrypted twice will produce different output.
+  - Use the exact same passphrase to decrypt.
+  - Keep the full "iv:ciphertext" string to decrypt later.
+`.trim(),
+        },
+    ],
+}));
+server.registerPrompt("encrypt_message_prompt", {
+    description: "Prompt to encrypt a plain-text message using the encrypt_message tool",
+    argsSchema: {
+        message: z.string().describe("The plain-text message to encrypt"),
+        encryptionKey: z.string().describe("Any passphrase — the server derives a strong key automatically"),
+    },
+}, ({ message, encryptionKey }) => ({
+    messages: [
+        {
+            role: "user",
+            content: {
+                type: "text",
+                text: `Please encrypt the following message using the encrypt_message tool.\nMessage: ${message}\nEncryption key: ${encryptionKey}`,
+            },
+        },
+    ],
+}));
+server.registerPrompt("decrypt_message_prompt", {
+    description: "Prompt to decrypt a message using the decrypt_message tool",
+    argsSchema: {
+        encryptedMessage: z.string().describe("The iv:ciphertext string to decrypt"),
+        encryptionKey: z.string().describe("The same passphrase used during encryption"),
+    },
+}, ({ encryptedMessage, encryptionKey }) => ({
+    messages: [
+        {
+            role: "user",
+            content: {
+                type: "text",
+                text: `Please decrypt the following message using the decrypt_message tool.\nEncrypted message: ${encryptedMessage}\nEncryption key: ${encryptionKey}`,
+            },
+        },
+    ],
+}));

package/package.json

@@ -1,18 +1,19 @@
 {
   "name": "@erickwendel/ciphersuite-mcp",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "",
   "main": "index.js",
   "bin": {
-    "ciphersuite-mcp": "./src/index.ts"
+    "ciphersuite-mcp": "./build/index.js"
   },
   "files": [
-    "src"
+    "build"
   ],
   "scripts": {
-    "build": "chmod 755 src/index.ts",
-    "start": "node src/index.ts",
-    "dev": "node --watch --inspect src/index.ts",
+    "build": "npx tsc && chmod 755 build/index.js",
+    "prepublishOnly": "npm run build",
+    "start": "node --experimental-strip-types src/index.ts",
+    "dev": "node --watch --inspect --experimental-strip-types src/index.ts",
     "test": "node --test tests/**/*.test.ts",
     "mcp:inspect": "npx @modelcontextprotocol/inspector node src/index.ts",
     "test:dev": "node --inspect --test --watch tests/**/*.test.ts",
@@ -30,7 +31,10 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.27.1",
-    "@types/node": "^24.11.0",
     "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@types/node": "^24.11.0",
+    "typescript": "^5.9.3"
   }
 }

package/src/mcp.ts

@@ -1,168 +0,0 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { randomBytes, createCipheriv, createDecipheriv, scryptSync } from 'node:crypto';
-import z from "zod";
-
-export const server = new McpServer({
-    name: "@erickwendel/ciphersuite-mcp",
-    version: "0.0.1",
-});
-
-
-// Fixed salt — same passphrase always derives the same key so decryption works across calls
-const SALT = 'mcp-encrypter-salt';
-
-function deriveKey(passphrase: string): Buffer {
-    return scryptSync(passphrase, SALT, 32);
-}
-
-function encrypt(text: string, key: string): string {
-    const iv = randomBytes(16);
-    const cipher = createCipheriv('aes-256-cbc', deriveKey(key), iv);
-    const encrypted = Buffer.concat([
-        cipher.update(Buffer.from(text, 'utf8')),
-        cipher.final(),
-    ]);
-    return `${iv.toString('hex')}:${encrypted.toString('hex')}`;
-}
-
-function decrypt(encryptedText: string, key: string): string {
-    const [ivHex, ...rest] = encryptedText.split(':');
-    const iv = Buffer.from(ivHex, 'hex');
-    const encrypted = Buffer.from(rest.join(':'), 'hex');
-    const decipher = createDecipheriv('aes-256-cbc', deriveKey(key), iv);
-    const decrypted = Buffer.concat([
-        decipher.update(encrypted),
-        decipher.final(),
-    ]);
-    return decrypted.toString('utf8');
-}
-
-
-server.registerTool(
-    "encrypt_message",
-    {
-        description: "Encrypt a message",
-        inputSchema: {
-            message: z.string().describe("The message to encrypt"),
-            encryptionKey: z.string().describe("Any passphrase to use for encryption — the server derives a strong key from it automatically"),
-        },
-        outputSchema: {
-            encryptedMessage: z.string().describe("The encrypted message (format: iv:ciphertext)"),
-        }
-    },
-    async ({ message, encryptionKey }) => {
-        try {
-            const encryptedMessage = encrypt(message, encryptionKey);
-            return {
-                content: [{ type: "text", text: encryptedMessage }],
-                structuredContent: { encryptedMessage },
-            };
-        } catch (err) {
-            return {
-                isError: true,
-                content: [{ type: "text", text: `Failed to encrypt message! Check if the message and encryption key are correct. Error details: ${err instanceof Error ? err.message : String(err)}` }],
-            };
-        }
-    },
-);
-
-server.registerTool(
-    "decrypt_message",
-    {
-        description: "Decrypt a message that was encrypted with the encrypt_message tool",
-        inputSchema: {
-            encryptedMessage: z.string().describe("The encrypted message to decrypt (format: iv:ciphertext)"),
-            encryptionKey: z.string().describe("The same passphrase used during encryption"),
-        },
-        outputSchema: {
-            decryptedMessage: z.string().describe("The decrypted plain-text message"),
-        }
-    },
-    async ({ encryptedMessage, encryptionKey }) => {
-        try {
-            const decryptedMessage = decrypt(encryptedMessage, encryptionKey);
-            return {
-                content: [{ type: "text", text: decryptedMessage }],
-                structuredContent: { decryptedMessage },
-            };
-        } catch (err) {
-            return {
-                isError: true,
-                content: [
-                    {
-                        type: "text",
-                        text: `Failed to decrypt message! Check if the encrypted message is correct and if the encryption key matches the one used for encryption. Error details: ${err instanceof Error ? err.message : String(err)}`,
-                    },
-                ],
-            };
-        }
-    },
-);
-
-server.registerResource(
-    "encryption://info",
-    "encryption://info",
-    { description: "Describes the encryption algorithm, key requirements, and output format used by this server." },
-    async () => ({
-        contents: [
-            {
-                uri: "encryption://info",
-                mimeType: "text/plain",
-                text: `
-Algorithm : AES-256-CBC
-Key derivation: scrypt (passphrase + fixed server salt → 32-byte key)
-Output format: <16-byte IV in hex>:<ciphertext in hex>  (separated by ":")
-Notes:
-  - Users pass any passphrase — the server derives a strong 32-byte key automatically using scrypt.
-  - A random IV is generated for every encryption — the same message encrypted twice will produce different output.
-  - Use the exact same passphrase to decrypt.
-  - Keep the full "iv:ciphertext" string to decrypt later.
-`.trim(),
-            },
-        ],
-    }),
-);
-
-server.registerPrompt(
-    "encrypt_message_prompt",
-    {
-        description: "Prompt to encrypt a plain-text message using the encrypt_message tool",
-        argsSchema: {
-            message: z.string().describe("The plain-text message to encrypt"),
-            encryptionKey: z.string().describe("Any passphrase — the server derives a strong key automatically"),
-        },
-    },
-    ({ message, encryptionKey }) => ({
-        messages: [
-            {
-                role: "user",
-                content: {
-                    type: "text",
-                    text: `Please encrypt the following message using the encrypt_message tool.\nMessage: ${message}\nEncryption key: ${encryptionKey}`,
-                },
-            },
-        ],
-    }),
-);
-
-server.registerPrompt(
-    "decrypt_message_prompt",
-    {
-        description: "Prompt to decrypt a message using the decrypt_message tool",
-        argsSchema: {
-            encryptedMessage: z.string().describe("The iv:ciphertext string to decrypt"),
-            encryptionKey: z.string().describe("The same passphrase used during encryption"),
-        },
-    },
-    ({ encryptedMessage, encryptionKey }) => ({
-        messages: [
-            {
-                role: "user",
-                content: {
-                    type: "text",
-                    text: `Please decrypt the following message using the decrypt_message tool.\nEncrypted message: ${encryptedMessage}\nEncryption key: ${encryptionKey}`,
-                },
-            },
-        ],
-    }),
-);