@signet-auth/mcp-tools 0.4.0

package/README.md

@@ -0,0 +1,49 @@
+# @signet-auth/mcp-tools
+
+<!-- mcp-name: io.github.prismer-ai/signet-mcp-tools -->
+
+Standalone MCP server exposing Signet cryptographic tools over `stdio`.
+
+## Tools
+
+- `signet_generate_keypair`: Generate an Ed25519 keypair and return the public key.
+- `signet_sign`: Sign a tool action and return a Signet receipt.
+- `signet_verify`: Verify a Signet receipt against a public key.
+- `signet_content_hash`: Compute the canonical SHA-256 content hash for JSON input.
+
+## Install
+
+```bash
+npm install -g @signet-auth/mcp-tools
+```
+
+## Run
+
+```bash
+signet-mcp-tools
+```
+
+To avoid passing secret keys through MCP arguments, prefer setting:
+
+```bash
+export SIGNET_SECRET_KEY=...
+signet-mcp-tools
+```
+
+## Local Development
+
+```bash
+npm run build --workspace @signet-auth/mcp-tools
+npm run test --workspace @signet-auth/mcp-tools
+npm run start --workspace @signet-auth/mcp-tools
+```
+
+## MCP Registry / Glama
+
+This package is intended to be published with the MCP name:
+
+```text
+io.github.prismer-ai/signet-mcp-tools
+```
+
+The registry manifest is in [server.json](./server.json).

package/dist/server.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/server.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+/**
+ * @signet-auth/mcp-tools — Standalone MCP server exposing Signet crypto tools.
+ *
+ * Security note: signet_sign requires a secret key as input. This is inherent
+ * to the signing operation. In production, use SIGNET_SECRET_KEY env var instead
+ * of passing keys through tool arguments. The generate_keypair tool only returns
+ * the public key — secret keys should be managed via the Signet CLI keystore.
+ */
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createSignetToolsServer } from './tools.js';
+const server = createSignetToolsServer();
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/tools.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Signet MCP tools — server factory.
+ *
+ * Extracted from server.ts so tests can create a server instance
+ * without triggering stdio transport side-effects.
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+export declare function createSignetToolsServer(): Server;

package/dist/tools.js

@@ -0,0 +1,130 @@
+/**
+ * Signet MCP tools — server factory.
+ *
+ * Extracted from server.ts so tests can create a server instance
+ * without triggering stdio transport side-effects.
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { generateKeypair, sign, verifyAny, contentHash, } from '@signet-auth/core';
+export function createSignetToolsServer() {
+    const server = new Server({ name: 'signet-mcp-tools', version: '0.4.0' }, { capabilities: { tools: {} } });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: [
+            {
+                name: 'signet_generate_keypair',
+                description: 'Generate a new Ed25519 keypair. Returns only the public key. Use Signet CLI to manage secret keys securely.',
+                inputSchema: { type: 'object', properties: {} },
+            },
+            {
+                name: 'signet_sign',
+                description: 'Sign an action (tool call) with an Ed25519 key, producing a cryptographic receipt. Uses SIGNET_SECRET_KEY env var if set, otherwise requires secret_key argument.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        secret_key: { type: 'string', description: 'Base64 secret key (optional if SIGNET_SECRET_KEY env is set)' },
+                        tool: { type: 'string', description: 'Tool name being called' },
+                        params: { description: 'Tool parameters (any JSON value)' },
+                        signer_name: { type: 'string', description: 'Agent name' },
+                        signer_owner: { type: 'string', description: 'Agent owner (optional)' },
+                        target: { type: 'string', description: 'Target MCP server URI' },
+                    },
+                    required: ['tool', 'signer_name'],
+                },
+            },
+            {
+                name: 'signet_verify',
+                description: 'Verify a Signet receipt signature. Returns {valid: true/false}. Accepts both bare base64 and ed25519:-prefixed public keys.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        receipt_json: { type: 'string', description: 'Receipt JSON string' },
+                        public_key: { type: 'string', description: 'Public key (base64 or ed25519:base64)' },
+                    },
+                    required: ['receipt_json', 'public_key'],
+                },
+            },
+            {
+                name: 'signet_content_hash',
+                description: 'Compute SHA-256 hash of canonical JSON (RFC 8785 JCS). Accepts any JSON value.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        content: { description: 'JSON content to hash (object, array, string, number, boolean, or null)' },
+                    },
+                    required: ['content'],
+                },
+            },
+        ],
+    }));
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        try {
+            switch (name) {
+                case 'signet_generate_keypair': {
+                    const kp = generateKeypair();
+                    // Only return public key — secret key management via CLI/env
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify({ public_key: kp.publicKey, note: 'Secret key generated but not returned. Use Signet CLI for key management.' }) }],
+                    };
+                }
+                case 'signet_sign': {
+                    const secretKey = args?.secret_key ?? process.env.SIGNET_SECRET_KEY;
+                    if (!secretKey) {
+                        return {
+                            content: [{ type: 'text', text: 'Error: no secret key. Set SIGNET_SECRET_KEY env var or pass secret_key argument.' }],
+                            isError: true,
+                        };
+                    }
+                    if (!args?.tool || !args?.signer_name) {
+                        return {
+                            content: [{ type: 'text', text: 'Error: tool and signer_name are required.' }],
+                            isError: true,
+                        };
+                    }
+                    const action = {
+                        tool: args.tool,
+                        params: args?.params ?? {},
+                        params_hash: '',
+                        target: args?.target ?? '',
+                        transport: 'mcp',
+                    };
+                    const receipt = sign(secretKey, action, args.signer_name, args?.signer_owner ?? '');
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify(receipt) }],
+                    };
+                }
+                case 'signet_verify': {
+                    if (!args?.receipt_json || !args?.public_key) {
+                        return {
+                            content: [{ type: 'text', text: 'Error: receipt_json and public_key are required.' }],
+                            isError: true,
+                        };
+                    }
+                    const valid = verifyAny(args.receipt_json, args.public_key);
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify({ valid }) }],
+                    };
+                }
+                case 'signet_content_hash': {
+                    const hash = contentHash(args?.content);
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify({ hash }) }],
+                    };
+                }
+                default:
+                    return {
+                        content: [{ type: 'text', text: `Unknown tool: ${name}` }],
+                        isError: true,
+                    };
+            }
+        }
+        catch (err) {
+            return {
+                content: [{ type: 'text', text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
+    return server;
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@signet-auth/mcp-tools",
+  "version": "0.4.0",
+  "description": "MCP server exposing Signet cryptographic signing, verification, and audit tools",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "signet",
+    "signing",
+    "audit",
+    "cryptography"
+  ],
+  "homepage": "https://github.com/Prismer-AI/signet/tree/main/packages/signet-mcp-tools#readme",
+  "bugs": {
+    "url": "https://github.com/Prismer-AI/signet/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Prismer-AI/signet.git",
+    "directory": "packages/signet-mcp-tools"
+  },
+  "mcpName": "io.github.prismer-ai/signet-mcp-tools",
+  "type": "module",
+  "bin": {
+    "signet-mcp-tools": "dist/server.js"
+  },
+  "files": ["dist/"],
+  "scripts": {
+    "build": "npx tsc",
+    "test": "npx tsc -p tsconfig.test.json && node --test dist-test/tests/tools.test.js",
+    "start": "node dist/server.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.10.0",
+    "@signet-auth/core": "^0.4.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22",
+    "typescript": "^5"
+  },
+  "license": "Apache-2.0 OR MIT"
+}