@signet-auth/mcp 0.1.0 → 0.2.0

package/dist/src/index.d.ts

@@ -1 +1,2 @@
 export { SigningTransport, type SigningTransportOptions, type Transport, type JSONRPCMessage } from './signing-transport.js';
+export type { CompoundReceipt, SignetReceipt } from '@signet-auth/core';

package/dist/src/signing-transport.d.ts

@@ -1,4 +1,4 @@
-import { type SignetReceipt } from '@signet-auth/core';
+import { type CompoundReceipt, type SignetReceipt } from '@signet-auth/core';
 export interface JSONRPCMessage {
     jsonrpc: '2.0';
     id?: string | number;
@@ -20,7 +20,9 @@ export interface Transport {
 export interface SigningTransportOptions {
     target?: string;
     transport?: string;
-    onSign?: (receipt: SignetReceipt) => void;
+    responseTimeout?: number;
+    onReceipt?: (receipt: CompoundReceipt) => void;
+    onDispatch?: (receipt: SignetReceipt) => void;
 }
 export declare class SigningTransport implements Transport {
     private inner;
@@ -28,7 +30,9 @@ export declare class SigningTransport implements Transport {
     private signerName;
     private signerOwner;
     private opts;
+    private pendingRequests;
     constructor(inner: Transport, secretKey: string, signerName: string, signerOwner?: string, options?: SigningTransportOptions);
+    private _timeout;
     onclose?: () => void;
     onerror?: (error: Error) => void;
     onmessage?: (message: JSONRPCMessage, extra?: unknown) => void;
@@ -38,6 +42,4 @@ export declare class SigningTransport implements Transport {
     close(): Promise<void>;
     send(message: JSONRPCMessage, options?: unknown): Promise<void>;
     private isToolCall;
-    private signToolCall;
-    private injectSignet;
 }

package/dist/src/signing-transport.js

@@ -1,23 +1,46 @@
-import { sign } from '@signet-auth/core';
+import { sign, signCompound } from '@signet-auth/core';
 export class SigningTransport {
     inner;
     secretKey;
     signerName;
     signerOwner;
     opts;
+    pendingRequests = new Map();
     constructor(inner, secretKey, signerName, signerOwner, options) {
         this.inner = inner;
         this.secretKey = secretKey;
         this.signerName = signerName;
         this.signerOwner = signerOwner ?? '';
         this.opts = options ?? {};
+        const timeout = this.opts.responseTimeout ?? 30000;
         // Forward callbacks using lazy closures.
         // MCP SDK's Protocol.connect() sets our callbacks AFTER construction,
         // so these closures must read this.onclose/etc lazily at call time.
         this.inner.onclose = () => this.onclose?.();
         this.inner.onerror = (e) => this.onerror?.(e);
-        this.inner.onmessage = (msg, extra) => this.onmessage?.(msg, extra);
+        this.inner.onmessage = (msg, extra) => {
+            // Check if this is a response to a pending tool call
+            if (msg.id !== undefined && this.pendingRequests.has(msg.id)) {
+                const pending = this.pendingRequests.get(msg.id);
+                clearTimeout(pending.timer);
+                this.pendingRequests.delete(msg.id);
+                const tsResponse = new Date().toISOString();
+                const responseContent = 'result' in msg ? msg.result : (msg.error ?? null);
+                try {
+                    const receipt = signCompound(this.secretKey, pending.action, responseContent, this.signerName, this.signerOwner, pending.tsRequest, tsResponse);
+                    this.opts.onReceipt?.(receipt);
+                }
+                catch (err) {
+                    this.onerror?.(err instanceof Error ? err : new Error(String(err)));
+                }
+            }
+            // Always forward message to outer onmessage
+            this.onmessage?.(msg, extra);
+        };
+        // Store timeout for use in send()
+        this._timeout = timeout;
     }
+    _timeout;
     onclose;
     onerror;
     onmessage;
@@ -26,38 +49,49 @@ export class SigningTransport {
         this.inner.setProtocolVersion?.(v);
     };
     start() { return this.inner.start(); }
-    close() { return this.inner.close(); }
+    async close() {
+        for (const entry of this.pendingRequests.values()) {
+            if (entry.timer)
+                clearTimeout(entry.timer);
+        }
+        this.pendingRequests.clear();
+        return this.inner.close();
+    }
     async send(message, options) {
-        if (this.isToolCall(message)) {
-            const receipt = this.signToolCall(message);
-            this.injectSignet(message, receipt);
-            this.opts.onSign?.(receipt);
+        if (this.isToolCall(message) && message.id !== undefined) {
+            const params = (message.params ?? {});
+            const action = {
+                tool: params.name ?? 'unknown',
+                params: params.arguments ?? {},
+                params_hash: '',
+                target: this.opts.target ?? 'unknown',
+                transport: this.opts.transport ?? 'stdio',
+            };
+            const tsRequest = new Date().toISOString();
+            // Sign v1 dispatch receipt with full params for server verification
+            try {
+                const dispatchReceipt = sign(this.secretKey, action, this.signerName, this.signerOwner);
+                // Deep-clone and inject into _meta._signet
+                const clonedParams = JSON.parse(JSON.stringify(message.params ?? {}));
+                if (!clonedParams._meta)
+                    clonedParams._meta = {};
+                clonedParams._meta._signet = dispatchReceipt;
+                message.params = clonedParams;
+                this.opts.onDispatch?.(dispatchReceipt);
+            }
+            catch (err) {
+                this.onerror?.(err instanceof Error ? err : new Error(String(err)));
+                return;
+            }
+            const id = message.id;
+            const timer = setTimeout(() => {
+                this.pendingRequests.delete(id);
+            }, this._timeout);
+            this.pendingRequests.set(id, { action, tsRequest, timer });
         }
         return this.inner.send(message, options);
     }
     isToolCall(message) {
         return message.method === 'tools/call';
     }
-    signToolCall(message) {
-        const params = (message.params ?? {});
-        const action = {
-            tool: params.name ?? 'unknown',
-            params: params.arguments ?? {},
-            params_hash: '',
-            target: this.opts.target ?? 'unknown',
-            transport: this.opts.transport ?? 'stdio',
-        };
-        return sign(this.secretKey, action, this.signerName, this.signerOwner);
-    }
-    injectSignet(message, receipt) {
-        // Deep-clone params to avoid mutating the original object
-        const params = JSON.parse(JSON.stringify(message.params ?? {}));
-        if (!params._meta)
-            params._meta = {};
-        params._meta._signet = {
-            ...receipt,
-            action: { ...receipt.action, params: null },
-        };
-        message.params = params;
-    }
 }

package/dist/tests/mcp.test.js

@@ -1,78 +1,149 @@
 import { describe, it } from 'node:test';
 import assert from 'node:assert';
-import { generateKeypair } from '@signet-auth/core';
+import { generateKeypair, verifyAny } from '@signet-auth/core';
 import { SigningTransport } from '../src/index.js';
-// Mock transport that records sent messages
+// Mock transport that records sent messages and supports simulating responses
 class MockTransport {
     sent = [];
+    messageHandler;
     onclose;
     onerror;
-    onmessage;
-    sessionId;
+    // Capture the onmessage handler set by SigningTransport
+    set onmessage(handler) {
+        this.messageHandler = handler;
+    }
+    get onmessage() { return this.messageHandler; }
     async start() { }
     async close() { }
     async send(message) {
         this.sent.push(JSON.parse(JSON.stringify(message)));
     }
+    // Simulate a response from the server
+    simulateResponse(id, result) {
+        this.messageHandler?.({ jsonrpc: '2.0', id, result }, undefined);
+    }
+    simulateError(id, error) {
+        this.messageHandler?.({ jsonrpc: '2.0', id, error }, undefined);
+    }
 }
-describe('@signet/mcp SigningTransport', () => {
+describe('@signet-auth/mcp SigningTransport v2', () => {
     const kp = generateKeypair();
-    function createTransport() {
+    function createTransport(opts) {
         const mock = new MockTransport();
         const signing = new SigningTransport(mock, kp.secretKey, 'test-agent', 'owner', {
             target: 'mcp://test-server',
             transport: 'stdio',
+            ...opts,
         });
         return { mock, signing };
     }
-    function toolCallMessage(name, args) {
+    function toolCallMessage(id, name, args) {
         return {
             jsonrpc: '2.0',
-            id: 1,
+            id,
             method: 'tools/call',
             params: { name, arguments: args },
         };
     }
-    it('signs tool call messages', async () => {
-        const { mock, signing } = createTransport();
-        await signing.send(toolCallMessage('echo', { message: 'hello' }));
-        assert.strictEqual(mock.sent.length, 1);
-        const sent = mock.sent[0];
-        assert(sent.params._meta._signet, '_signet should be injected');
-        assert(sent.params._meta._signet.sig.startsWith('ed25519:'));
-        assert(sent.params._meta._signet.id.startsWith('rec_'));
+    it('signs compound receipt on response', async () => {
+        let receipt = null;
+        const { mock, signing } = createTransport({ onReceipt: (r) => { receipt = r; } });
+        await signing.send(toolCallMessage(1, 'echo', { message: 'hello' }));
+        mock.simulateResponse(1, { content: [{ type: 'text', text: 'hello' }] });
+        assert(receipt !== null, 'onReceipt should have been called');
+        const r = receipt;
+        assert.strictEqual(r.v, 2);
+        assert(r.id.startsWith('rec_'));
+        assert(r.sig.startsWith('ed25519:'));
+        assert.strictEqual(r.signer.name, 'test-agent');
+        assert.strictEqual(r.action.tool, 'echo');
     });
-    it('passes through non-tool-call messages', async () => {
-        const { mock, signing } = createTransport();
-        const listMsg = { jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} };
+    it('compound receipt has response hash', async () => {
+        let receipt = null;
+        const { mock, signing } = createTransport({ onReceipt: (r) => { receipt = r; } });
+        await signing.send(toolCallMessage(2, 'search', { query: 'test' }));
+        mock.simulateResponse(2, { content: [{ type: 'text', text: 'results' }] });
+        assert(receipt !== null);
+        assert(receipt.response.content_hash.startsWith('sha256:'));
+    });
+    it('produces compound receipt on error response', async () => {
+        let receipt = null;
+        const { mock, signing } = createTransport({ onReceipt: (r) => { receipt = r; } });
+        await signing.send(toolCallMessage(3, 'fail_tool', {}));
+        mock.simulateError(3, { code: -32000, message: 'tool failed' });
+        assert(receipt !== null, 'onReceipt should fire even on error responses');
+        const r = receipt;
+        assert.strictEqual(r.v, 2);
+        assert(r.response.content_hash.startsWith('sha256:'));
+    });
+    it('passes through non-tool-call messages unchanged', async () => {
+        let receipt = null;
+        const { mock, signing } = createTransport({ onReceipt: (r) => { receipt = r; } });
+        const listMsg = { jsonrpc: '2.0', id: 4, method: 'tools/list', params: {} };
         await signing.send(listMsg);
         assert.strictEqual(mock.sent.length, 1);
         const sent = mock.sent[0];
-        assert.strictEqual(sent.params._meta, undefined);
+        // No _meta injection in v2
+        const params = sent['params'];
+        assert.strictEqual(params?._meta, undefined);
+        // Simulate a response — should not produce a receipt since it wasn't a tool call
+        mock.simulateResponse(4, {});
+        assert.strictEqual(receipt, null, 'no receipt for non-tool-call responses');
     });
-    it('receipt has correct tool name', async () => {
-        const { mock, signing } = createTransport();
-        await signing.send(toolCallMessage('github_create_issue', { title: 'bug' }));
-        const signet = mock.sent[0].params._meta._signet;
-        assert.strictEqual(signet.action.tool, 'github_create_issue');
+    it('does not fire onReceipt after timeout', async () => {
+        let receiptCount = 0;
+        const { mock, signing } = createTransport({
+            responseTimeout: 50,
+            onReceipt: () => { receiptCount++; },
+        });
+        await signing.send(toolCallMessage(5, 'slow_tool', {}));
+        // Wait longer than timeout before simulating response
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        mock.simulateResponse(5, { content: [] });
+        assert.strictEqual(receiptCount, 0, 'no receipt after timeout');
+    });
+    it('close clears pending requests — no receipt after close', async () => {
+        let receiptCount = 0;
+        const { mock, signing } = createTransport({
+            onReceipt: () => { receiptCount++; },
+        });
+        await signing.send(toolCallMessage(6, 'some_tool', {}));
+        await signing.close();
+        mock.simulateResponse(6, { content: [] });
+        assert.strictEqual(receiptCount, 0, 'no receipt after close clears pending');
     });
-    it('receipt params are null (hash-only)', async () => {
+    it('injects _meta._signet dispatch receipt into tool call message', async () => {
         const { mock, signing } = createTransport();
-        await signing.send(toolCallMessage('echo', { data: 'secret' }));
-        const signet = mock.sent[0].params._meta._signet;
-        assert.strictEqual(signet.action.params, null);
-        assert(signet.action.params_hash.startsWith('sha256:'));
+        await signing.send(toolCallMessage(7, 'echo', { message: 'hello' }));
+        assert.strictEqual(mock.sent.length, 1);
+        const params = mock.sent[0].params;
+        const meta = params._meta;
+        assert(meta !== undefined, '_meta should be present');
+        const signet = meta._signet;
+        assert(signet !== undefined, '_meta._signet should be present');
+        assert(signet.sig.startsWith('ed25519:'), 'sig should start with ed25519:');
+        assert.strictEqual(signet.v, 1);
     });
-    it('onSign callback fires with receipt', async () => {
+    it('fires onDispatch callback at send time', async () => {
+        let dispatched = null;
         const mock = new MockTransport();
-        let callbackReceipt = null;
         const signing = new SigningTransport(mock, kp.secretKey, 'test-agent', 'owner', {
-            onSign: (r) => { callbackReceipt = r; },
+            target: 'mcp://test-server',
+            transport: 'stdio',
+            onDispatch: (r) => { dispatched = r; },
         });
-        await signing.send(toolCallMessage('test', {}));
-        assert(callbackReceipt !== null, 'callback should have been called');
-        const r = callbackReceipt;
-        assert(r.id.startsWith('rec_'));
-        assert.strictEqual(r.signer.name, 'test-agent');
+        await signing.send(toolCallMessage(8, 'echo', { message: 'hello' }));
+        assert(dispatched !== null, 'onDispatch should have been called');
+        assert.strictEqual(dispatched.v, 1);
+        assert(dispatched.sig.startsWith('ed25519:'));
+    });
+    it('dispatch receipt is verifiable with correct key', async () => {
+        const { mock, signing } = createTransport();
+        await signing.send(toolCallMessage(9, 'echo', { message: 'hello' }));
+        const params = mock.sent[0].params;
+        const meta = params._meta;
+        const signet = meta._signet;
+        const valid = verifyAny(JSON.stringify(signet), kp.publicKey);
+        assert(valid, 'dispatch receipt should verify with the signer public key');
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signet-auth/mcp",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "MCP middleware for Signet cryptographic action receipts",
   "type": "module",
   "main": "dist/src/index.js",