nostr-mcp-server 2.0.0

package/build/__tests__/relay-specification.test.js

@@ -0,0 +1,136 @@
+import { describe, expect, test, jest, beforeEach } from '@jest/globals';
+import { NostrRelay } from '../utils/ephemeral-relay.js';
+// Mock the getRelayPool function
+const mockGetRelayPool = jest.fn();
+// Define a mock implementation
+const createMockPool = (relays) => {
+    return {
+        connect: jest.fn(),
+        close: jest.fn(),
+        relayUrls: relays,
+        subscribeMany: jest.fn().mockImplementation(() => {
+            return {
+                on: jest.fn(),
+                off: jest.fn()
+            };
+        }),
+    };
+};
+// Set up the mock implementation
+mockGetRelayPool.mockImplementation((relays) => createMockPool(relays || []));
+// Mock the entire module
+jest.mock('../utils/pool.js', () => {
+    return {
+        getRelayPool: (relays) => mockGetRelayPool(relays)
+    };
+});
+// Create a helper to simulate fetching profile data
+const fetchProfileWithRelays = (pubkey, customRelays) => {
+    // This simulates how the actual code would use the pool
+    const relayPool = mockGetRelayPool(customRelays);
+    // Track if we've connected to the pool
+    relayPool.connect();
+    // Simulate the subscription
+    const sub = relayPool.subscribeMany([{ kinds: [0], authors: [pubkey] }]);
+    // Return the relays that were used
+    return {
+        relaysUsed: relayPool.relayUrls,
+        pool: relayPool
+    };
+};
+// Define default relays for comparison
+const DEFAULT_RELAYS = [
+    'wss://relay.damus.io',
+    'wss://relay.nostr.band',
+    'wss://relay.primal.net',
+    'wss://nos.lol',
+    'wss://relay.current.fyi',
+    'wss://nostr.bitcoiner.social'
+];
+describe('Custom Relay Specification', () => {
+    beforeEach(() => {
+        // Clear all mocks before each test
+        jest.clearAllMocks();
+        // Set the default mockGetRelayPool implementation to use DEFAULT_RELAYS when no custom relays
+        mockGetRelayPool.mockImplementation((relays) => {
+            const trackedRelays = relays && relays.length > 0 ? relays : DEFAULT_RELAYS;
+            return createMockPool(trackedRelays);
+        });
+    });
+    test('uses default relays when no custom relays specified', () => {
+        const { relaysUsed } = fetchProfileWithRelays('test-pubkey');
+        // When no custom relays are specified, should use defaults
+        expect(relaysUsed).toEqual(DEFAULT_RELAYS);
+    });
+    test('uses custom relays when specified', () => {
+        const customRelays = ['wss://custom1.example.com', 'wss://custom2.example.com'];
+        const { relaysUsed } = fetchProfileWithRelays('test-pubkey', customRelays);
+        // Should use exactly the custom relays
+        expect(relaysUsed).toEqual(customRelays);
+        expect(relaysUsed).not.toEqual(DEFAULT_RELAYS);
+    });
+    test('empty custom relays array falls back to defaults', () => {
+        const { relaysUsed } = fetchProfileWithRelays('test-pubkey', []);
+        // When empty array is provided, should fall back to defaults
+        expect(relaysUsed).toEqual(DEFAULT_RELAYS);
+    });
+    test('maintains relay connection pool during operation', () => {
+        const customRelays = ['wss://custom1.example.com', 'wss://custom2.example.com'];
+        const { pool } = fetchProfileWithRelays('test-pubkey', customRelays);
+        // The connect method should be called
+        expect(pool.connect).toHaveBeenCalled();
+        // The subscribeMany method should be called with appropriate filters
+        expect(pool.subscribeMany).toHaveBeenCalledWith(expect.arrayContaining([
+            expect.objectContaining({
+                kinds: expect.arrayContaining([0]),
+                authors: expect.arrayContaining(['test-pubkey'])
+            })
+        ]));
+    });
+    test('invalid relay URLs are filtered out', () => {
+        // Create a special mock implementation for this test
+        mockGetRelayPool.mockImplementationOnce((relays) => {
+            // Filter invalid URLs (this simulates what the real implementation should do)
+            const filteredRelays = relays ? relays.filter((url) => url.startsWith('wss://') && url.includes('.')) : [];
+            return createMockPool(filteredRelays);
+        });
+        // Include some invalid relay URLs
+        const mixedRelays = [
+            'wss://valid.example.com',
+            'invalid-url',
+            'http://not-secure.example.com', // Not WSS
+            'wss://another-valid.example.com'
+        ];
+        const { relaysUsed } = fetchProfileWithRelays('test-pubkey', mixedRelays);
+        // Only valid WSS URLs should remain
+        expect(relaysUsed).toContain('wss://valid.example.com');
+        expect(relaysUsed).toContain('wss://another-valid.example.com');
+        expect(relaysUsed).not.toContain('invalid-url');
+        expect(relaysUsed).not.toContain('http://not-secure.example.com');
+    });
+    test('relay fallback behavior with ephemeral relay', async () => {
+        // Create an ephemeral relay for testing - using port 9000 for test
+        const relay = new NostrRelay(9000);
+        // Create a request that specifies two relays:
+        // 1. A non-existent relay that will fail
+        // 2. Our ephemeral relay that will work
+        const testRelays = [
+            'wss://non-existent-relay.example.com',
+            relay.url
+        ];
+        // This is a more advanced test that would require actual implementation
+        // of relay fallback logic. We'll outline the concept here.
+        // In a real test with actual implementation:
+        // 1. Send a request to the specified relays
+        // 2. The first relay fails to connect
+        // 3. The code falls back to the second relay
+        // 4. We get a successful response from the second relay
+        // For now, we'll just verify that both relays are attempted
+        const { relaysUsed } = fetchProfileWithRelays('test-pubkey', testRelays);
+        expect(relaysUsed).toEqual(testRelays);
+        // In a full implementation, we would:
+        // 1. Set up a callback for events from the ephemeral relay
+        // 2. Publish a test profile to the ephemeral relay
+        // 3. Verify we receive it even though the first relay fails
+    });
+});

package/build/__tests__/search-nips-simple.test.js

@@ -0,0 +1,96 @@
+import { searchNips } from '../nips/nips-tools.js';
+// Since the NIPs tool uses a real cache, we'll test with the actual cache behavior
+describe('Search NIPs Tool - Simple Tests', () => {
+    describe('basic search functionality', () => {
+        it('should search NIPs by keyword', async () => {
+            // This will use the real cache if available, or fetch from GitHub
+            const result = await searchNips('protocol', 5);
+            expect(Array.isArray(result)).toBe(true);
+            // Should find NIP-01 when searching for "protocol"
+            const nip01 = result.find(searchResult => searchResult.nip.number === 1);
+            if (nip01) {
+                expect(nip01.nip.title.toLowerCase()).toContain('protocol');
+            }
+        });
+        it('should return limited results', async () => {
+            const limit = 3;
+            const result = await searchNips('event', limit);
+            expect(Array.isArray(result)).toBe(true);
+            expect(result.length).toBeLessThanOrEqual(limit);
+        });
+        it('should return results with correct structure', async () => {
+            // Use a more common search term that's likely to return results
+            const result = await searchNips('event', 5);
+            expect(Array.isArray(result)).toBe(true);
+            // Each result should have the expected structure
+            if (result.length > 0) {
+                result.forEach(searchResult => {
+                    expect(searchResult).toHaveProperty('nip');
+                    expect(searchResult).toHaveProperty('relevance');
+                    expect(searchResult).toHaveProperty('matchedTerms');
+                    // Check the nested nip structure
+                    expect(searchResult.nip).toHaveProperty('number');
+                    expect(searchResult.nip).toHaveProperty('title');
+                    expect(searchResult.nip).toHaveProperty('status');
+                });
+            }
+        });
+        it('should handle no results gracefully', async () => {
+            const result = await searchNips('xyz123nonexistentterm456', 10);
+            expect(Array.isArray(result)).toBe(true);
+            expect(result).toEqual([]);
+        });
+        it('should handle case-insensitive search', async () => {
+            const result1 = await searchNips('PROTOCOL', 5);
+            const result2 = await searchNips('protocol', 5);
+            expect(Array.isArray(result1)).toBe(true);
+            expect(Array.isArray(result2)).toBe(true);
+            // Both searches should return results
+            if (result1.length > 0 && result2.length > 0) {
+                // The results should be similar (may not be identical due to scoring)
+                expect(result1.length).toBeGreaterThan(0);
+                expect(result2.length).toBeGreaterThan(0);
+            }
+        });
+    });
+    describe('search relevance', () => {
+        it('should return relevant results for common terms', async () => {
+            // Test with terms we know exist in NIPs
+            const result = await searchNips('event', 5);
+            expect(Array.isArray(result)).toBe(true);
+            if (result.length > 0) {
+                // At least one result should have a relevance score
+                const hasRelevantResult = result.some(searchResult => searchResult.relevance > 0);
+                expect(hasRelevantResult).toBe(true);
+                // Results should be sorted by relevance score
+                expect(result[0].relevance).toBeGreaterThan(0);
+            }
+        });
+        it('should rank results by relevance score', async () => {
+            const result = await searchNips('encryption', 10);
+            expect(Array.isArray(result)).toBe(true);
+            if (result.length > 1) {
+                // Results should be sorted by relevance score (descending)
+                for (let i = 1; i < result.length; i++) {
+                    if (result[i - 1].relevance !== undefined && result[i].relevance !== undefined) {
+                        expect(result[i - 1].relevance).toBeGreaterThanOrEqual(result[i].relevance);
+                    }
+                }
+            }
+        });
+    });
+    describe('error handling', () => {
+        it('should handle empty search query', async () => {
+            const result = await searchNips('', 10);
+            // Empty query should return empty array
+            expect(Array.isArray(result)).toBe(true);
+            expect(result).toEqual([]);
+        });
+        it('should handle very long search queries gracefully', async () => {
+            const longQuery = 'a'.repeat(1000);
+            const result = await searchNips(longQuery, 10);
+            // Should return an array (possibly empty)
+            expect(Array.isArray(result)).toBe(true);
+        });
+    });
+});

package/build/__tests__/websocket-integration.test.js

@@ -0,0 +1,257 @@
+import { NostrRelay } from '../utils/ephemeral-relay.js';
+import { schnorr } from '@noble/curves/secp256k1';
+import { randomBytes } from 'crypto';
+import { sha256 } from '@noble/hashes/sha256';
+import WebSocket from 'ws';
+// Generate a keypair for testing
+function generatePrivateKey() {
+    return Buffer.from(randomBytes(32)).toString('hex');
+}
+function getPublicKey(privateKey) {
+    return Buffer.from(schnorr.getPublicKey(privateKey)).toString('hex');
+}
+// Create a signed event
+function createSignedEvent(privateKey, kind, content, tags = []) {
+    const pubkey = getPublicKey(privateKey);
+    const created_at = Math.floor(Date.now() / 1000);
+    // Create event
+    const event = {
+        pubkey,
+        created_at,
+        kind,
+        tags,
+        content,
+    };
+    // Calculate event ID
+    const eventData = JSON.stringify([0, event.pubkey, event.created_at, event.kind, event.tags, event.content]);
+    const id = Buffer.from(sha256(eventData)).toString('hex');
+    // Sign the event
+    const sig = Buffer.from(schnorr.sign(id, privateKey)).toString('hex');
+    return {
+        ...event,
+        id,
+        sig
+    };
+}
+describe('WebSocket Nostr Integration Tests', () => {
+    let relay;
+    const testPort = 9800;
+    let relayUrl;
+    let ws;
+    let privateKey;
+    let publicKey;
+    beforeAll(async () => {
+        privateKey = generatePrivateKey();
+        publicKey = getPublicKey(privateKey);
+        // Start the ephemeral relay
+        relay = new NostrRelay(testPort);
+        await relay.start();
+        relayUrl = `ws://localhost:${testPort}`;
+    });
+    beforeEach(async () => {
+        // Create a new WebSocket connection before each test
+        const connectPromise = new Promise((resolve, reject) => {
+            ws = new WebSocket(relayUrl);
+            ws.on('open', () => resolve());
+            ws.on('error', reject);
+        });
+        await connectPromise;
+    });
+    afterEach(async () => {
+        // Close WebSocket connection after each test
+        if (ws) {
+            if (ws.readyState === WebSocket.OPEN) {
+                ws.close();
+                // Wait for close to complete
+                await new Promise(resolve => {
+                    ws.on('close', resolve);
+                    setTimeout(resolve, 100); // Fallback timeout
+                });
+            }
+            ws.removeAllListeners();
+        }
+    });
+    afterAll(async () => {
+        // Ensure all WebSocket connections are closed
+        if (ws && ws.readyState !== WebSocket.CLOSED) {
+            ws.close();
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+        // Shutdown relay
+        await relay.close();
+        // Give time for all async operations to complete
+        await new Promise(resolve => setTimeout(resolve, 200));
+    });
+    // Helper function to send a message and wait for response
+    const sendAndWait = (message) => {
+        return new Promise((resolve, reject) => {
+            const responses = [];
+            const responseHandler = (data) => {
+                try {
+                    const response = JSON.parse(data.toString());
+                    responses.push(response);
+                    // EOSE or OK messages indicate we can resolve
+                    if ((response[0] === 'EOSE' && response[1] === 'test-sub') ||
+                        (response[0] === 'OK')) {
+                        resolve(responses);
+                        ws.off('message', responseHandler);
+                    }
+                }
+                catch (e) {
+                    reject(e);
+                }
+            };
+            ws.on('message', responseHandler);
+            ws.send(JSON.stringify(message));
+            // Add a timeout
+            setTimeout(() => {
+                resolve(responses);
+                ws.off('message', responseHandler);
+            }, 2000);
+        });
+    };
+    test('should connect to the relay', () => {
+        expect(ws.readyState).toBe(WebSocket.OPEN);
+    });
+    test('should publish an event and get OK response', async () => {
+        // Create a test event
+        const event = createSignedEvent(privateKey, 1, 'WebSocket test note');
+        // Send EVENT message
+        const responses = await sendAndWait(['EVENT', event]);
+        // Check for OK response
+        const okResponse = responses.find(resp => resp[0] === 'OK' && resp[1] === event.id);
+        expect(okResponse).toBeDefined();
+        expect(okResponse[2]).toBe(true); // Success flag
+    });
+    test('should publish an event and retrieve it with REQ', async () => {
+        // Create a test event with unique content
+        const uniqueContent = `WebSocket REQ test note ${Date.now()}`;
+        const event = createSignedEvent(privateKey, 1, uniqueContent);
+        // Send EVENT message
+        await sendAndWait(['EVENT', event]);
+        // Now send a REQ to get this event
+        const subId = 'test-sub';
+        const responses = await sendAndWait([
+            'REQ',
+            subId,
+            {
+                kinds: [1],
+                authors: [publicKey],
+            }
+        ]);
+        // Check that we got an EVENT response with our event
+        const eventResponse = responses.find(resp => resp[0] === 'EVENT' &&
+            resp[1] === subId &&
+            resp[2].content === uniqueContent);
+        expect(eventResponse).toBeDefined();
+        expect(eventResponse[2].id).toBe(event.id);
+        // Check that we got an EOSE response
+        const eoseResponse = responses.find(resp => resp[0] === 'EOSE' && resp[1] === subId);
+        expect(eoseResponse).toBeDefined();
+    });
+    test('should handle multiple subscriptions', async () => {
+        // Create events of different kinds
+        const profileEvent = createSignedEvent(privateKey, 0, JSON.stringify({ name: 'WebSocket Test' }));
+        const noteEvent = createSignedEvent(privateKey, 1, 'WebSocket multi-subscription test');
+        // Publish both events
+        await sendAndWait(['EVENT', profileEvent]);
+        await sendAndWait(['EVENT', noteEvent]);
+        // Subscribe to profiles only
+        const profileSubId = 'profile-sub';
+        const profileResponses = await sendAndWait([
+            'REQ',
+            profileSubId,
+            {
+                kinds: [0],
+                authors: [publicKey],
+            }
+        ]);
+        // Subscribe to notes only
+        const noteSubId = 'note-sub';
+        const noteResponses = await sendAndWait([
+            'REQ',
+            noteSubId,
+            {
+                kinds: [1],
+                authors: [publicKey],
+            }
+        ]);
+        // Check profile subscription got profile event
+        const profileEventResponse = profileResponses.find(resp => resp[0] === 'EVENT' &&
+            resp[1] === profileSubId &&
+            resp[2].kind === 0);
+        expect(profileEventResponse).toBeDefined();
+        // Check note subscription got note event
+        const noteEventResponse = noteResponses.find(resp => resp[0] === 'EVENT' &&
+            resp[1] === noteSubId &&
+            resp[2].kind === 1);
+        expect(noteEventResponse).toBeDefined();
+    });
+    test('should support subscription closing', async () => {
+        // Create a test event
+        const event = createSignedEvent(privateKey, 1, 'Subscription close test');
+        // Publish the event
+        await sendAndWait(['EVENT', event]);
+        // Create a subscription
+        const subId = 'close-test-sub';
+        await sendAndWait([
+            'REQ',
+            subId,
+            {
+                kinds: [1],
+                authors: [publicKey],
+            }
+        ]);
+        // Close the subscription
+        ws.send(JSON.stringify(['CLOSE', subId]));
+        // Create a new subscription with the same ID
+        // This should work if the previous subscription was properly closed
+        const newResponses = await sendAndWait([
+            'REQ',
+            subId,
+            {
+                kinds: [1],
+                authors: [publicKey],
+            }
+        ]);
+        // Verify we got an EOSE for the new subscription
+        const eoseResponse = newResponses.find(resp => resp[0] === 'EOSE' && resp[1] === subId);
+        expect(eoseResponse).toBeDefined();
+    });
+    test('should reject events with invalid signatures or silently ignore them', async () => {
+        // Create an event with invalid signature
+        const invalidEvent = {
+            pubkey: publicKey,
+            created_at: Math.floor(Date.now() / 1000),
+            kind: 1,
+            tags: [],
+            content: 'Event with invalid signature',
+            id: Buffer.from(sha256(JSON.stringify([0, publicKey, Math.floor(Date.now() / 1000), 1, [], 'Event with invalid signature']))).toString('hex'),
+            sig: 'invalid_signature_0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000'
+        };
+        // Send EVENT message with invalid signature
+        const responses = await sendAndWait(['EVENT', invalidEvent]);
+        // Check for OK response with failure flag, or no response which means silent rejection
+        const okResponse = responses.find(resp => resp[0] === 'OK' &&
+            resp[1] === invalidEvent.id);
+        // If the relay responds to invalid events, it should be with failure
+        if (okResponse) {
+            expect(okResponse[2]).toBe(false); // Success flag should be false
+        }
+        // Now verify that a valid event works properly
+        const validEvent = createSignedEvent(privateKey, 1, 'Event with valid signature');
+        // Send EVENT message with valid signature
+        const validResponses = await sendAndWait(['EVENT', validEvent]);
+        // Check for OK response with success flag
+        const validOkResponse = validResponses.find(resp => resp[0] === 'OK' &&
+            resp[1] === validEvent.id);
+        expect(validOkResponse).toBeDefined();
+        expect(validOkResponse[2]).toBe(true); // Success flag should be true
+        // Verify the valid event made it to the relay's cache
+        const eventInCache = relay.cache.find(e => e.id === validEvent.id);
+        expect(eventInCache).toBeDefined();
+        // Verify the invalid event didn't make it to the relay's cache
+        const invalidEventInCache = relay.cache.find(e => e.id === invalidEvent.id);
+        expect(invalidEventInCache).toBeUndefined();
+    });
+});

package/build/__tests__/zap-tools-simple.test.js

@@ -0,0 +1,72 @@
+// Mock the processZapReceipt function
+const processZapReceipt = (receipt, targetPubkey) => {
+    const targetTag = receipt.tags?.find(tag => tag[0] === 'p' && tag[1] === targetPubkey);
+    const direction = targetTag ? 'received' : 'sent';
+    const amountTag = receipt.tags?.find(tag => tag[0] === 'amount');
+    const amountSats = amountTag ? parseInt(amountTag[1]) / 1000 : 0; // Convert millisats to sats
+    return {
+        id: receipt.id,
+        direction,
+        amountSats,
+        created_at: receipt.created_at,
+        targetPubkey
+    };
+};
+// Simple prepareAnonymousZap function for testing
+const prepareAnonymousZap = (target, amount, comment = '') => {
+    return Promise.resolve({
+        success: true,
+        invoice: `lnbc${amount}`,
+        targetData: {
+            type: target.startsWith('note') ? 'event' : 'profile'
+        },
+        comment
+    });
+};
+describe('Zap Tools Functions', () => {
+    const testPubkey = '7e7e9c42a91bfef19fa929e5fda1b72e0ebc1a4c1141673e2794234d86addf4e';
+    test('processZapReceipt adds targetPubkey to receipt', () => {
+        // Create mock zap receipt
+        const mockZapReceipt = {
+            id: 'test-zap-id',
+            created_at: Math.floor(Date.now() / 1000) - 3600,
+            tags: [
+                ['p', testPubkey],
+                ['amount', '100000'] // 100 sats in millisats
+            ]
+        };
+        // Process the receipt
+        const result = processZapReceipt(mockZapReceipt, testPubkey);
+        // Check the result
+        expect(result).toHaveProperty('targetPubkey', testPubkey);
+        expect(result.id).toBe(mockZapReceipt.id);
+        expect(result.direction).toBe('received');
+        expect(result.amountSats).toBe(100);
+    });
+    test('prepareAnonymousZap returns invoice for profile', async () => {
+        // Test with an npub target
+        const npubTarget = 'npub180cvv07tjdrrgpa0j7j7tmnyl2yr6yr7l8j4s3evf6u64th6gkwsyjh6w6';
+        const amount = 100;
+        const comment = 'Test zap';
+        // Prepare anonymous zap
+        const result = await prepareAnonymousZap(npubTarget, amount, comment);
+        // Check the result
+        expect(result.success).toBe(true);
+        expect(result.invoice).toBe(`lnbc${amount}`);
+        expect(result.targetData.type).toBe('profile');
+        expect(result.comment).toBe(comment);
+    });
+    test('prepareAnonymousZap returns invoice for event', async () => {
+        // Test with a note ID target
+        const noteTarget = 'note1abcdef';
+        const amount = 200;
+        // Prepare anonymous zap with default empty comment
+        const result = await prepareAnonymousZap(noteTarget, amount);
+        // Check the result
+        expect(result.success).toBe(true);
+        expect(result.invoice).toBe(`lnbc${amount}`);
+        expect(result.targetData.type).toBe('event');
+        expect(result.comment).toBe('');
+    });
+});
+export {};