nostr-mcp-server 2.0.0

package/build/utils/ephemeral-relay.js

@@ -0,0 +1,438 @@
+import { z } from 'zod';
+import { schnorr } from '@noble/curves/secp256k1';
+import { sha256 } from '@noble/hashes/sha256';
+import EventEmitter from 'events';
+import { WebSocket, WebSocketServer } from 'ws';
+/* ================ [ Configuration ] ================ */
+const HOST = 'ws://localhost';
+const DEBUG = process.env['DEBUG'] === 'true';
+const VERBOSE = process.env['VERBOSE'] === 'true' || DEBUG;
+// Only log output mode in non-test environments
+if (process.env.NODE_ENV !== 'test') {
+    console.error('output mode:', DEBUG ? 'debug' : VERBOSE ? 'verbose' : 'silent');
+}
+/* ================ [ Schema ] ================ */
+const num = z.number().max(Number.MAX_SAFE_INTEGER), str = z.string(), stamp = num.min(500_000_000), hex = str.regex(/^[0-9a-fA-F]*$/).refine(e => e.length % 2 === 0), hash = hex.refine((e) => e.length === 64), sig = hex.refine((e) => e.length === 128), tags = str.array();
+const event_schema = z.object({
+    content: str,
+    created_at: stamp,
+    id: hash,
+    kind: num,
+    pubkey: hash,
+    sig: sig,
+    tags: tags.array()
+});
+const filter_schema = z.object({
+    ids: hash.array().optional(),
+    authors: hash.array().optional(),
+    kinds: num.array().optional(),
+    since: stamp.optional(),
+    until: stamp.optional(),
+    limit: num.optional(),
+}).catchall(tags);
+const sub_schema = z.tuple([str]).rest(filter_schema);
+/* ================ [ Server Class ] ================ */
+export class NostrRelay {
+    _emitter;
+    _port;
+    _purge;
+    _subs;
+    _wss;
+    _cache;
+    _isClosing = false;
+    conn;
+    constructor(port, purge_ival) {
+        this._cache = [];
+        this._emitter = new EventEmitter();
+        this._port = port;
+        this._purge = purge_ival ?? null;
+        this._subs = new Map();
+        this._wss = null;
+        this.conn = 0;
+    }
+    get cache() {
+        return this._cache;
+    }
+    get subs() {
+        return this._subs;
+    }
+    get url() {
+        return `${HOST}:${this._port}`;
+    }
+    get wss() {
+        if (this._wss === null) {
+            throw new Error('websocket server not initialized');
+        }
+        return this._wss;
+    }
+    async start() {
+        this._wss = new WebSocketServer({ port: this._port });
+        this._isClosing = false;
+        DEBUG && console.log('[ relay ] running on port:', this._port);
+        this.wss.on('connection', socket => {
+            const instance = new ClientSession(this, socket);
+            socket.on('message', msg => instance._handler(msg.toString()));
+            socket.on('error', err => instance._onerr(err));
+            socket.on('close', code => instance._cleanup(code));
+            this.conn += 1;
+        });
+        return new Promise(res => {
+            this.wss.on('listening', () => {
+                if (this._purge !== null) {
+                    DEBUG && console.log(`[ relay ] purging events every ${this._purge} seconds`);
+                    setInterval(() => {
+                        this._cache = [];
+                    }, this._purge * 1000);
+                }
+                this._emitter.emit('connected');
+                res(this);
+            });
+        });
+    }
+    onconnect(cb) {
+        this._emitter.on('connected', cb);
+    }
+    close() {
+        return new Promise(resolve => {
+            if (this._isClosing) {
+                DEBUG && console.log('[ relay ] already closing, skipping duplicate close call');
+                resolve();
+                return;
+            }
+            this._isClosing = true;
+            if (this._wss) {
+                // Clean up clients first
+                if (this._wss.clients && this._wss.clients.size > 0) {
+                    this._wss.clients.forEach(client => {
+                        try {
+                            client.close(1000, 'Server shutting down');
+                        }
+                        catch (e) {
+                            // Ignore errors
+                        }
+                    });
+                }
+                // Clear state
+                this._subs.clear();
+                this._cache = [];
+                // Close server with timeout
+                const timeout = setTimeout(() => {
+                    DEBUG && console.log('[ relay ] server close timed out, forcing cleanup');
+                    this._wss = null;
+                    resolve();
+                }, 500);
+                const wss = this._wss;
+                this._wss = null;
+                wss.close(() => {
+                    clearTimeout(timeout);
+                    resolve();
+                });
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    store(event) {
+        this._cache = this._cache.concat(event).sort((a, b) => a > b ? -1 : 1);
+    }
+}
+/* ================ [ Instance Class ] ================ */
+class ClientSession {
+    _sid;
+    _relay;
+    _socket;
+    _subs;
+    constructor(relay, socket) {
+        this._relay = relay;
+        this._sid = Math.random().toString().slice(2, 8);
+        this._socket = socket;
+        this._subs = new Set();
+        this.log.client('client connected');
+    }
+    get sid() {
+        return this._sid;
+    }
+    get relay() {
+        return this._relay;
+    }
+    get socket() {
+        return this._socket;
+    }
+    _cleanup(code) {
+        try {
+            // First remove all subscriptions associated with this client
+            for (const subId of this._subs) {
+                this.remSub(subId);
+            }
+            this._subs.clear();
+            // Close the socket if it's still open
+            if (this.socket.readyState === WebSocket.OPEN) {
+                this.socket.close();
+            }
+            this.relay.conn -= 1;
+            this.log.client(`[ ${this._sid} ]`, 'client disconnected with code:', code);
+        }
+        catch (e) {
+            DEBUG && console.error(`[ client ][ ${this._sid} ]`, 'error during cleanup:', e);
+        }
+    }
+    _handler(message) {
+        let verb, payload;
+        try {
+            // Try to parse as JSON
+            const parsed = JSON.parse(message);
+            // Handle NIP-46 messages (which might not follow standard Nostr format)
+            if (parsed && Array.isArray(parsed) && parsed.length > 0) {
+                // Check if it's a standard Nostr message
+                if (['EVENT', 'REQ', 'CLOSE'].includes(parsed[0])) {
+                    // Handle standard Nostr messages
+                    [verb, ...payload] = parsed;
+                    switch (verb) {
+                        case 'EVENT':
+                            if (parsed.length !== 2) {
+                                DEBUG && console.log(`[ ${this._sid} ]`, 'EVENT message missing params:', parsed);
+                                return this.send(['NOTICE', 'invalid: EVENT message missing params']);
+                            }
+                            return this._onevent(parsed[1]);
+                        case 'REQ':
+                            if (parsed.length < 2) {
+                                DEBUG && console.log(`[ ${this._sid} ]`, 'REQ message missing params:', parsed);
+                                return this.send(['NOTICE', 'invalid: REQ message missing params']);
+                            }
+                            const sub_id = parsed[1];
+                            const filters = parsed.slice(2);
+                            return this._onreq(sub_id, filters);
+                        case 'CLOSE':
+                            if (parsed.length !== 2) {
+                                DEBUG && console.log(`[ ${this._sid} ]`, 'CLOSE message missing params:', parsed);
+                                return this.send(['NOTICE', 'invalid: CLOSE message missing params']);
+                            }
+                            return this._onclose(parsed[1]);
+                    }
+                }
+                else {
+                    // This could be a direct NIP-46 message, broadcast it to other clients
+                    try {
+                        this.relay.wss.clients.forEach(client => {
+                            if (client !== this.socket && client.readyState === WebSocket.OPEN) {
+                                client.send(message);
+                            }
+                        });
+                        return;
+                    }
+                    catch (e) {
+                        DEBUG && console.error('Error broadcasting message:', e);
+                        return;
+                    }
+                }
+            }
+            this.log.debug('unhandled message format:', message);
+            return this.send(['NOTICE', '', 'Unable to handle message']);
+        }
+        catch (e) {
+            this.log.debug('failed to parse message:\n\n', message);
+            return this.send(['NOTICE', '', 'Unable to parse message']);
+        }
+    }
+    _onclose(sub_id) {
+        this.log.info('closed subscription:', sub_id);
+        this.remSub(sub_id);
+    }
+    _onerr(err) {
+        this.log.info('socket encountered an error:\n\n', err);
+    }
+    _onevent(event) {
+        try {
+            // Special handling for NIP-46 events (kind 24133)
+            if (event.kind === 24133) {
+                this.relay.store(event);
+                // Find subscriptions that match this event
+                for (const [uid, sub] of this.relay.subs.entries()) {
+                    for (const filter of sub.filters) {
+                        if (filter.kinds?.includes(24133)) {
+                            // Check for #p tag filter
+                            const pTags = event.tags.filter(tag => tag[0] === 'p').map(tag => tag[1]);
+                            const pFilters = Object.entries(filter)
+                                .filter(([key]) => key === '#p')
+                                .map(([_, value]) => value)
+                                .flat();
+                            // If there's a #p filter, make sure the event matches it
+                            if (pFilters.length > 0 && !pTags.some(tag => pFilters.includes(tag))) {
+                                continue;
+                            }
+                            // Send to matching subscription
+                            const [clientId, subId] = uid.split('/');
+                            sub.instance.send(['EVENT', subId, event]);
+                            break;
+                        }
+                    }
+                }
+                // Send OK message
+                this.send(['OK', event.id, true, '']);
+                return;
+            }
+            // Standard event processing
+            this.log.client('received event id:', event.id);
+            this.log.debug('event:', event);
+            if (!verify_event(event)) {
+                this.log.debug('event failed validation:', event);
+                this.send(['OK', event.id, false, 'event failed validation']);
+                return;
+            }
+            this.send(['OK', event.id, true, '']);
+            this.relay.store(event);
+            for (const { filters, instance, sub_id } of this.relay.subs.values()) {
+                for (const filter of filters) {
+                    if (match_filter(event, filter)) {
+                        instance.log.client(`event matched subscription: ${sub_id}`);
+                        instance.send(['EVENT', sub_id, event]);
+                    }
+                }
+            }
+        }
+        catch (e) {
+            DEBUG && console.error('Error processing event:', e);
+        }
+    }
+    _onreq(sub_id, filters) {
+        if (filters.length === 0) {
+            this.log.client('request has no filters');
+            return;
+        }
+        this.log.client('received subscription request:', sub_id);
+        this.log.debug('filters:', filters);
+        // Add subscription
+        this.addSub(sub_id, ...filters);
+        // Check for NIP-46 subscription
+        const hasNip46Filter = filters.some(f => f.kinds?.includes(24133));
+        // For each filter
+        let count = 0;
+        for (const filter of filters) {
+            // Set the limit count, if any
+            let limitCount = filter.limit;
+            for (const event of this.relay.cache) {
+                // If limit is reached, stop sending events
+                if (limitCount !== undefined && limitCount <= 0)
+                    break;
+                // Check if event matches filter
+                if (match_filter(event, filter)) {
+                    this.send(['EVENT', sub_id, event]);
+                    count++;
+                    this.log.client(`event matched in cache: ${event.id}`);
+                    this.log.client(`event matched subscription: ${sub_id}`);
+                    // Update limit counter
+                    if (limitCount !== undefined)
+                        limitCount--;
+                }
+            }
+        }
+        DEBUG && this.log.debug(`sent ${count} matching events from cache`);
+        // Send EOSE
+        this.send(['EOSE', sub_id]);
+    }
+    get log() {
+        return {
+            client: (...msg) => VERBOSE && console.log(`[ client ][ ${this._sid} ]`, ...msg),
+            debug: (...msg) => DEBUG && console.log(`[ debug  ][ ${this._sid} ]`, ...msg),
+            info: (...msg) => VERBOSE && console.log(`[ info   ][ ${this._sid} ]`, ...msg),
+        };
+    }
+    addSub(sub_id, ...filters) {
+        const uid = `${this.sid}/${sub_id}`;
+        this.relay.subs.set(uid, { filters, instance: this, sub_id });
+        this._subs.add(sub_id);
+    }
+    remSub(subId) {
+        try {
+            const uid = `${this.sid}/${subId}`;
+            this.relay.subs.delete(uid);
+            this._subs.delete(subId);
+        }
+        catch (e) {
+            // Ignore errors
+        }
+    }
+    send(message) {
+        try {
+            if (this.socket.readyState === WebSocket.OPEN) {
+                this.socket.send(JSON.stringify(message));
+            }
+        }
+        catch (e) {
+            DEBUG && console.error(`Failed to send message to client ${this._sid}:`, e);
+        }
+    }
+}
+/* ================ [ Methods ] ================ */
+function assert(value) {
+    if (value === false)
+        throw new Error('assertion failed!');
+}
+function match_filter(event, filter = {}) {
+    const { authors, ids, kinds, since, until, limit, ...rest } = filter;
+    const tag_filters = Object.entries(rest)
+        .filter(e => e[0].startsWith('#'))
+        .map(e => [e[0].slice(1, 2), ...e[1]]);
+    if (ids !== undefined && !ids.includes(event.id)) {
+        return false;
+    }
+    else if (since !== undefined && event.created_at < since) {
+        return false;
+    }
+    else if (until !== undefined && event.created_at > until) {
+        return false;
+    }
+    else if (authors !== undefined && !authors.includes(event.pubkey)) {
+        return false;
+    }
+    else if (kinds !== undefined && !kinds.includes(event.kind)) {
+        return false;
+    }
+    else if (tag_filters.length > 0) {
+        return match_tags(tag_filters, event.tags);
+    }
+    else {
+        return true;
+    }
+}
+function match_tags(filters, tags) {
+    // For each filter, we need to find at least one match in event tags
+    for (const [key, ...terms] of filters) {
+        let filterMatched = false;
+        // Skip empty filter terms
+        if (terms.length === 0) {
+            filterMatched = true;
+            continue;
+        }
+        // For each tag that matches the filter key
+        for (const [tag, ...params] of tags) {
+            if (tag !== key)
+                continue;
+            // For each term in the filter
+            for (const term of terms) {
+                // If any term matches any parameter, this filter condition is satisfied
+                if (params.includes(term)) {
+                    filterMatched = true;
+                    break;
+                }
+            }
+            // If we found a match for this filter, we can stop checking tags
+            if (filterMatched)
+                break;
+        }
+        // If no match was found for this filter condition, event doesn't match
+        if (!filterMatched)
+            return false;
+    }
+    // All filter conditions were satisfied
+    return true;
+}
+function verify_event(event) {
+    const { content, created_at, id, kind, pubkey, sig, tags } = event;
+    const pimg = JSON.stringify([0, pubkey, created_at, kind, tags, content]);
+    const dig = Buffer.from(sha256(pimg)).toString('hex');
+    if (dig !== id)
+        return false;
+    return schnorr.verify(sig, id, pubkey);
+}

package/build/utils/formatting.js

@@ -0,0 +1,34 @@
+import { hexToNpub } from './conversion.js';
+/**
+ * Format a pubkey for display, converting to npub format
+ * @param pubkey The pubkey in hex format
+ * @param useShortFormat Whether to use a shortened format
+ * @returns The formatted pubkey
+ */
+export function formatPubkey(pubkey, useShortFormat = false) {
+    try {
+        if (!pubkey)
+            return 'unknown';
+        // Convert to npub
+        const npub = hexToNpub(pubkey);
+        // If converting to npub failed, return a shortened hex
+        if (!npub) {
+            return useShortFormat
+                ? `${pubkey.substring(0, 4)}...${pubkey.substring(60)}`
+                : pubkey;
+        }
+        // Return appropriately formatted npub
+        if (useShortFormat) {
+            // For short format, show the first 8 and last 4 characters of the npub
+            return `${npub.substring(0, 8)}...${npub.substring(npub.length - 4)}`;
+        }
+        else {
+            // For regular format, use the full npub
+            return npub;
+        }
+    }
+    catch (error) {
+        console.error('Error formatting pubkey:', error);
+        return 'error';
+    }
+}

package/build/utils/index.js

@@ -0,0 +1,6 @@
+// Re-export all utilities from their modules
+export * from './constants.js';
+export * from './conversion.js';
+export * from './formatting.js';
+export * from './pool.js';
+export * from './ephemeral-relay.js';

package/build/utils/nip19-tools.js

@@ -0,0 +1,117 @@
+import { z } from "zod";
+import { convertNip19Entity, analyzeNip19Entity } from "./conversion.js";
+// Schema for convertNip19 tool
+export const convertNip19ToolConfig = {
+    input: z.string().describe("The NIP-19 entity or hex string to convert"),
+    targetType: z.enum(['npub', 'nsec', 'note', 'hex', 'nprofile', 'nevent', 'naddr']).describe("The target format to convert to"),
+    relays: z.array(z.string()).optional().describe("Optional relay URLs for complex entities (nprofile, nevent, naddr)"),
+    author: z.string().optional().describe("Optional author pubkey (hex format) for nevent/naddr"),
+    kind: z.number().optional().describe("Optional event kind for nevent/naddr"),
+    identifier: z.string().optional().describe("Required identifier for naddr conversion"),
+};
+// Schema for analyzeNip19 tool
+export const analyzeNip19ToolConfig = {
+    input: z.string().describe("The NIP-19 entity or hex string to analyze"),
+};
+/**
+ * Convert any NIP-19 entity to another format
+ */
+export async function convertNip19(input, targetType, relays, author, kind, identifier) {
+    try {
+        const options = {
+            input,
+            targetType,
+            entityData: {
+                ...(relays && { relays }),
+                ...(author && { author }),
+                ...(kind && { kind }),
+                ...(identifier && { identifier })
+            }
+        };
+        const result = convertNip19Entity(options);
+        if (!result.success) {
+            return {
+                success: false,
+                message: result.message || 'Conversion failed'
+            };
+        }
+        return {
+            success: true,
+            message: result.message || 'Conversion successful',
+            result: result.result,
+            originalType: result.originalType,
+            data: result.data
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: `Error during conversion: ${error instanceof Error ? error.message : 'Unknown error'}`
+        };
+    }
+}
+/**
+ * Analyze any NIP-19 entity to get its type and decoded data
+ */
+export async function analyzeNip19(input) {
+    try {
+        const result = analyzeNip19Entity(input);
+        if (!result.success) {
+            return {
+                success: false,
+                message: result.message || 'Analysis failed'
+            };
+        }
+        return {
+            success: true,
+            message: result.message || 'Analysis successful',
+            type: result.originalType,
+            data: result.data
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: `Error during analysis: ${error instanceof Error ? error.message : 'Unknown error'}`
+        };
+    }
+}
+/**
+ * Format analysis result for display
+ */
+export function formatAnalysisResult(type, data) {
+    switch (type) {
+        case 'hex':
+            return `Hex String: ${data}`;
+        case 'npub':
+            return `Public Key (npub): ${data}`;
+        case 'nsec':
+            return `Private Key (nsec): ${data}`;
+        case 'note':
+            return `Note ID: ${data}`;
+        case 'nprofile':
+            return [
+                `Profile Entity:`,
+                `  Public Key: ${data.pubkey}`,
+                `  Relays: ${data.relays?.length ? data.relays.join(', ') : 'None'}`
+            ].join('\n');
+        case 'nevent':
+            return [
+                `Event Entity:`,
+                `  Event ID: ${data.id}`,
+                `  Author: ${data.author || 'Not specified'}`,
+                `  Kind: ${data.kind || 'Not specified'}`,
+                `  Relays: ${data.relays?.length ? data.relays.join(', ') : 'None'}`
+            ].join('\n');
+        case 'naddr':
+            return [
+                `Address Entity:`,
+                `  Identifier: ${data.identifier}`,
+                `  Public Key: ${data.pubkey}`,
+                `  Kind: ${data.kind}`,
+                `  Relays: ${data.relays?.length ? data.relays.join(', ') : 'None'}`
+            ].join('\n');
+        default:
+            return `Unknown type: ${type}`;
+    }
+}

package/build/utils/pool.js

@@ -0,0 +1,55 @@
+import { RelayPool } from "snstr";
+/**
+ * Extended RelayPool with compatibility methods for existing codebase
+ */
+export class CompatibleRelayPool extends RelayPool {
+    constructor(relays = []) {
+        super(relays);
+    }
+    /**
+     * Compatibility method to match existing codebase API
+     * Maps to snstr's querySync method
+     */
+    async get(relays, filter) {
+        try {
+            const events = await this.querySync(relays, filter, { timeout: 8000 });
+            return events.length > 0 ? events[0] : null;
+        }
+        catch (error) {
+            console.error('Error in pool.get:', error);
+            return null;
+        }
+    }
+    /**
+     * Compatibility method to match existing codebase API
+     * Maps to snstr's querySync method for multiple events
+     */
+    async getMany(relays, filter) {
+        try {
+            return await this.querySync(relays, filter, { timeout: 8000 });
+        }
+        catch (error) {
+            console.error('Error in pool.getMany:', error);
+            return [];
+        }
+    }
+    /**
+     * Compatibility method to match existing codebase API
+     * Maps to snstr's close method but ignores relay parameter
+     */
+    async close(_relays) {
+        try {
+            await super.close();
+        }
+        catch (error) {
+            console.error('Error in pool.close:', error);
+        }
+    }
+}
+/**
+ * Create a fresh RelayPool instance for making Nostr requests
+ * @returns A new CompatibleRelayPool instance
+ */
+export function getFreshPool(relays = []) {
+    return new CompatibleRelayPool(relays);
+}