nostr-mcp-server 2.0.0 → 2.1.0

package/build/__tests__/format-conversion.test.js

@@ -1,137 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import * as nip19 from 'nostr-tools/nip19';
-// Import local conversion utilities
-import { npubToHex, hexToNpub } from '../utils/conversion.js';
-describe('Nostr format conversion', () => {
-    // Known test vectors - generate these dynamically to ensure they match
-    const testHexPubkeys = [
-        '3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d',
-        '63fe6318dc58583cfe16810f86dd09e18bfd76aabc24a0081ce2856f330504ed'
-    ];
-    // Generate matching npubs using the library directly
-    const knownPairs = testHexPubkeys.map(hex => ({
-        hex,
-        npub: nip19.npubEncode(hex)
-    }));
-    // Generate test event IDs and their encoded forms
-    const testEventIds = [
-        '5c83da77af1dec6d7289834998ad7aafbd9e2191396d75ec3cc27f5a77226f36',
-        '9ae37aa68f48645127299e9595f545f942a8314455cbafd9d913ed19c7fc0462'
-    ];
-    const eventIdPairs = testEventIds.map(hex => ({
-        hex,
-        note: nip19.noteEncode(hex)
-    }));
-    test('hex to npub conversion', () => {
-        knownPairs.forEach(pair => {
-            expect(hexToNpub(pair.hex)).toBe(pair.npub);
-        });
-    });
-    test('npub to hex conversion', () => {
-        knownPairs.forEach(pair => {
-            const result = npubToHex(pair.npub);
-            expect(result).toBe(pair.hex);
-        });
-    });
-    test('hex to note conversion using nostr-tools', () => {
-        eventIdPairs.forEach(pair => {
-            expect(nip19.noteEncode(pair.hex)).toBe(pair.note);
-        });
-    });
-    test('note to hex conversion using nostr-tools', () => {
-        eventIdPairs.forEach(pair => {
-            const decoded = nip19.decode(pair.note);
-            expect(decoded.type).toBe('note');
-            expect(decoded.data).toBe(pair.hex);
-        });
-    });
-    test('nevent encoding and decoding using nostr-tools', () => {
-        const eventPointer = {
-            id: '5c83da77af1dec6d7289834998ad7aafbd9e2191396d75ec3cc27f5a77226f36',
-            relays: ['wss://relay.example.com', 'wss://relay.nostr.org'],
-            author: '3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d',
-            kind: 1
-        };
-        const nevent = nip19.neventEncode(eventPointer);
-        expect(nevent).toMatch(/^nevent1/);
-        const decoded = nip19.decode(nevent);
-        expect(decoded.type).toBe('nevent');
-        const data = decoded.data;
-        expect(data.id).toBe(eventPointer.id);
-        expect(data.author).toBe(eventPointer.author);
-        expect(data.kind).toBe(eventPointer.kind);
-        expect(data.relays).toEqual(eventPointer.relays);
-    });
-    test('naddr encoding and decoding using nostr-tools', () => {
-        const addressPointer = {
-            identifier: 'test-article',
-            pubkey: '3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d',
-            kind: 30023,
-            relays: ['wss://relay.example.com']
-        };
-        const naddr = nip19.naddrEncode(addressPointer);
-        expect(naddr).toMatch(/^naddr1/);
-        const decoded = nip19.decode(naddr);
-        expect(decoded.type).toBe('naddr');
-        const data = decoded.data;
-        expect(data.identifier).toBe(addressPointer.identifier);
-        expect(data.pubkey).toBe(addressPointer.pubkey);
-        expect(data.kind).toBe(addressPointer.kind);
-        expect(data.relays).toEqual(addressPointer.relays);
-    });
-    test('validate Nostr identifiers using regex', () => {
-        // Valid identifiers
-        expect(/^npub1[a-z0-9]{58}$/.test(knownPairs[0].npub)).toBe(true);
-        expect(/^note1[a-z0-9]{58}$/.test(eventIdPairs[0].note)).toBe(true);
-        // Invalid identifiers with correct regex patterns
-        expect(/^npub1[a-z0-9]{58}$/.test('npub1invalid')).toBe(false);
-        expect(/^note1[a-z0-9]{58}$/.test('note1invalid')).toBe(false);
-        // Fix the regex patterns to be more specific
-        expect(/^nevent1[a-z0-9]{58,}$/.test('nevent1invalid')).toBe(false);
-        expect(/^naddr1[a-z0-9]{58,}$/.test('naddr1invalid')).toBe(false);
-    });
-    test('error handling for npub conversion', () => {
-        expect(npubToHex('npub1invalid')).toBeNull();
-        expect(hexToNpub('invalidhex')).toBeNull();
-    });
-    test('partial nevent data', () => {
-        // Test with minimal data
-        const minimalPointer = {
-            id: '5c83da77af1dec6d7289834998ad7aafbd9e2191396d75ec3cc27f5a77226f36'
-        };
-        const nevent = nip19.neventEncode(minimalPointer);
-        expect(nevent).toMatch(/^nevent1/);
-        const decoded = nip19.decode(nevent);
-        expect(decoded.type).toBe('nevent');
-        const data = decoded.data;
-        expect(data.id).toBe(minimalPointer.id);
-        expect(data.relays).toEqual([]);
-        expect(data.author).toBeUndefined();
-        expect(data.kind).toBeUndefined();
-    });
-    test('bech32 conversion limits', () => {
-        // Test with very long relay list
-        const manyRelays = Array(20).fill(0).map((_, i) => `wss://relay${i}.example.com`);
-        const eventPointer = {
-            id: '5c83da77af1dec6d7289834998ad7aafbd9e2191396d75ec3cc27f5a77226f36',
-            relays: manyRelays
-        };
-        const nevent = nip19.neventEncode(eventPointer);
-        expect(nevent).toMatch(/^nevent1/);
-        const decoded = nip19.decode(nevent);
-        expect(decoded.type).toBe('nevent');
-        const data = decoded.data;
-        expect(data.id).toBe(eventPointer.id);
-        expect(data.relays.length).toBe(manyRelays.length);
-    });
-    test('edge case: nostr URI handling', () => {
-        // Generate a fresh npub
-        const hex = '3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d';
-        const npub = nip19.npubEncode(hex);
-        // Test with nostr: prefix
-        const nostrUriNpub = 'nostr:' + npub;
-        // When handling the nostr: prefix in our conversion functions
-        const result = npubToHex(nostrUriNpub.replace('nostr:', ''));
-        expect(result).toBe(hex);
-    });
-});

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

@@ -1,109 +0,0 @@
-import { describe, expect, test, jest } from '@jest/globals';
-// Mock NIP data for testing
-const mockNips = [
-    {
-        id: '01',
-        title: 'Basic Protocol Flow Description',
-        content: 'This NIP defines the basic protocol flow between clients and relays...',
-        keywords: ['protocol', 'relay', 'client', 'basic']
-    },
-    {
-        id: '19',
-        title: 'bech32-encoded entities',
-        content: 'This NIP defines how to encode and reference different Nostr entities...',
-        keywords: ['encoding', 'bech32', 'npub', 'note', 'nevent', 'naddr', 'identifier']
-    },
-    {
-        id: '57',
-        title: 'Lightning Zaps',
-        content: 'This NIP defines how users can send zaps to each other using lightning...',
-        keywords: ['lightning', 'zap', 'payment', 'tip', 'lnurl']
-    }
-];
-// Mock data for testing
-const mockSearchResults = (query, limit = 10, includeContent = false) => {
-    // Simple relevance scoring algorithm for testing
-    const results = mockNips.map(nip => {
-        const titleMatches = (nip.title.toLowerCase().includes(query.toLowerCase()) ? 2 : 0);
-        const keywordMatches = nip.keywords.filter(kw => kw.includes(query.toLowerCase())).length;
-        const contentMatches = (nip.content.toLowerCase().includes(query.toLowerCase()) ? 1 : 0);
-        const relevance = titleMatches + keywordMatches + contentMatches;
-        return {
-            id: nip.id,
-            title: nip.title,
-            relevance: relevance,
-            content: includeContent ? nip.content : undefined
-        };
-    })
-        .filter(result => result.relevance > 0)
-        .sort((a, b) => b.relevance - a.relevance)
-        .slice(0, limit);
-    return results;
-};
-// Mock search function
-const searchNips = jest.fn((query, options = {}) => {
-    const { limit = 10, includeContent = false } = options;
-    return Promise.resolve(mockSearchResults(query, limit, includeContent));
-});
-describe('NIP Search Functionality', () => {
-    beforeEach(() => {
-        searchNips.mockClear();
-    });
-    test('basic search returns relevant results', async () => {
-        const results = await searchNips('lightning');
-        expect(results.length).toBeGreaterThan(0);
-        expect(results[0].id).toBe('57'); // NIP-57 is most relevant for 'lightning'
-        expect(results[0].title).toBe('Lightning Zaps');
-        expect(results[0].relevance).toBeGreaterThan(0);
-        expect(results[0].content).toBeUndefined(); // Content shouldn't be included by default
-    });
-    test('search with includeContent option', async () => {
-        const results = await searchNips('protocol', { includeContent: true });
-        expect(results.length).toBeGreaterThan(0);
-        expect(results[0].id).toBe('01'); // NIP-01 is most relevant for 'protocol'
-        expect(results[0].content).toBeDefined();
-        expect(results[0].content).toContain('protocol flow');
-    });
-    test('search respects limit parameter', async () => {
-        // Create a search term that matches multiple NIPs
-        const results = await searchNips('n', { limit: 2 });
-        // Should return only two results even though more match
-        expect(results.length).toBe(2);
-    });
-    test('search with no matches returns empty array', async () => {
-        const results = await searchNips('nonexistentterm');
-        expect(results).toEqual([]);
-    });
-    test('search relevance sorting', async () => {
-        // 'encoding' appears in both NIP-19 title/keywords and NIP-57 content, but NIP-19 should rank higher
-        const results = await searchNips('encoding');
-        expect(results.length).toBeGreaterThan(0);
-        expect(results[0].id).toBe('19');
-    });
-    test('search is case insensitive', async () => {
-        const lowerResults = await searchNips('lightning');
-        const upperResults = await searchNips('LIGHTNING');
-        const mixedResults = await searchNips('LiGhTnInG');
-        expect(lowerResults.length).toBeGreaterThan(0);
-        expect(upperResults.length).toBeGreaterThan(0);
-        expect(mixedResults.length).toBeGreaterThan(0);
-        // All should find the same results
-        expect(lowerResults[0].id).toBe(upperResults[0].id);
-        expect(lowerResults[0].id).toBe(mixedResults[0].id);
-    });
-    test('search works with partial word matches', async () => {
-        const results = await searchNips('light');
-        expect(results.length).toBeGreaterThan(0);
-        expect(results[0].id).toBe('57'); // Should find 'lightning' in NIP-57
-    });
-    test('very large limit is handled gracefully', async () => {
-        // Even with a large limit, should only return matches
-        const results = await searchNips('protocol', { limit: 1000 });
-        // Should not break or return more than the available matches
-        expect(results.length).toBeLessThanOrEqual(mockNips.length);
-    });
-    test('zero limit returns empty array', async () => {
-        const results = await searchNips('protocol', { limit: 0 });
-        expect(results).toEqual([]);
-    });
-});

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

@@ -1,136 +0,0 @@
-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

@@ -1,96 +0,0 @@
-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);
-        });
-    });
-});