nostr-mcp-server 2.0.0

package/build/note/note-tools.js

@@ -0,0 +1,296 @@
+import { z } from "zod";
+import { DEFAULT_RELAYS } from "../utils/index.js";
+import { generateKeypair, createEvent, getEventHash, signEvent, decode as nip19decode } from "snstr";
+import { getFreshPool } from "../utils/index.js";
+import { schnorr } from '@noble/curves/secp256k1';
+// Schema for getProfile tool
+export const getProfileToolConfig = {
+    pubkey: z.string().describe("Public key of the Nostr user (hex format or npub format)"),
+    relays: z.array(z.string()).optional().describe("Optional list of relays to query"),
+};
+// Schema for getKind1Notes tool
+export const getKind1NotesToolConfig = {
+    pubkey: z.string().describe("Public key of the Nostr user (hex format or npub format)"),
+    limit: z.number().min(1).max(100).default(10).describe("Maximum number of notes to fetch"),
+    relays: z.array(z.string()).optional().describe("Optional list of relays to query"),
+};
+// Schema for getLongFormNotes tool
+export const getLongFormNotesToolConfig = {
+    pubkey: z.string().describe("Public key of the Nostr user (hex format or npub format)"),
+    limit: z.number().min(1).max(100).default(10).describe("Maximum number of notes to fetch"),
+    relays: z.array(z.string()).optional().describe("Optional list of relays to query"),
+};
+// Schema for postAnonymousNote tool
+export const postAnonymousNoteToolConfig = {
+    content: z.string().describe("Content of the note to post"),
+    relays: z.array(z.string()).optional().describe("Optional list of relays to publish to"),
+    tags: z.array(z.array(z.string())).optional().describe("Optional tags to include with the note"),
+};
+// Schema for createNote tool
+export const createNoteToolConfig = {
+    privateKey: z.string().describe("Private key to sign the note with (hex format or nsec format)"),
+    content: z.string().describe("Content of the note to create"),
+    tags: z.array(z.array(z.string())).optional().describe("Optional tags to include with the note"),
+};
+// Schema for signNote tool
+export const signNoteToolConfig = {
+    privateKey: z.string().describe("Private key to sign the note with (hex format or nsec format)"),
+    noteEvent: z.object({
+        kind: z.number().describe("Event kind (should be 1 for text notes)"),
+        content: z.string().describe("Content of the note"),
+        tags: z.array(z.array(z.string())).describe("Tags array"),
+        created_at: z.number().describe("Creation timestamp"),
+        pubkey: z.string().describe("Public key of the author")
+    }).describe("Unsigned note event to sign"),
+};
+// Schema for publishNote tool  
+export const publishNoteToolConfig = {
+    signedNote: z.object({
+        id: z.string().describe("Event ID"),
+        pubkey: z.string().describe("Public key of the author"),
+        created_at: z.number().describe("Creation timestamp"),
+        kind: z.number().describe("Event kind"),
+        tags: z.array(z.array(z.string())).describe("Tags array"),
+        content: z.string().describe("Content of the note"),
+        sig: z.string().describe("Event signature")
+    }).describe("Signed note event to publish"),
+    relays: z.array(z.string()).optional().describe("Optional list of relays to publish to"),
+};
+// Helper function to format profile data
+export function formatProfile(profile) {
+    if (!profile)
+        return "No profile found";
+    let metadata = {};
+    try {
+        metadata = profile.content ? JSON.parse(profile.content) : {};
+    }
+    catch (e) {
+        console.error("Error parsing profile metadata:", e);
+    }
+    return [
+        `Name: ${metadata.name || "Unknown"}`,
+        `Display Name: ${metadata.display_name || metadata.displayName || metadata.name || "Unknown"}`,
+        `About: ${metadata.about || "No about information"}`,
+        `NIP-05: ${metadata.nip05 || "Not set"}`,
+        `Lightning Address (LUD-16): ${metadata.lud16 || "Not set"}`,
+        `LNURL (LUD-06): ${metadata.lud06 || "Not set"}`,
+        `Picture: ${metadata.picture || "No picture"}`,
+        `Website: ${metadata.website || "No website"}`,
+        `Created At: ${new Date(profile.created_at * 1000).toISOString()}`,
+    ].join("\n");
+}
+// Helper function to format note content
+export function formatNote(note) {
+    if (!note)
+        return "";
+    const created = new Date(note.created_at * 1000).toLocaleString();
+    return [
+        `ID: ${note.id}`,
+        `Created: ${created}`,
+        `Content: ${note.content}`,
+        `---`,
+    ].join("\n");
+}
+/**
+ * Post an anonymous note to the Nostr network
+ * Generates a one-time keypair and publishes the note to specified relays
+ */
+export async function postAnonymousNote(content, relays = DEFAULT_RELAYS, tags = []) {
+    try {
+        // console.error(`Preparing to post anonymous note to ${relays.join(", ")}`);
+        // Create a fresh pool for this request
+        const pool = getFreshPool(relays);
+        try {
+            // Generate a one-time keypair for anonymous posting
+            const keys = await generateKeypair();
+            // Create the note event template
+            const noteTemplate = createEvent({
+                kind: 1, // kind 1 is a text note
+                content,
+                tags
+            }, keys.publicKey);
+            // Get event hash and sign it
+            const eventId = await getEventHash(noteTemplate);
+            const signature = await signEvent(eventId, keys.privateKey);
+            // Create complete signed event
+            const signedNote = {
+                ...noteTemplate,
+                id: eventId,
+                sig: signature
+            };
+            const publicKey = keys.publicKey;
+            // Publish to relays and wait for actual relay OK responses
+            const pubPromises = pool.publish(relays, signedNote);
+            // Wait for all publish attempts to complete or timeout
+            const results = await Promise.allSettled(pubPromises);
+            // Check if at least one relay actually accepted the event
+            // A fulfilled promise means relay responded, but we need to check if it accepted
+            const successCount = results.filter(r => r.status === 'fulfilled' && r.value.success === true).length;
+            if (successCount === 0) {
+                return {
+                    success: false,
+                    message: 'Failed to publish note to any relay',
+                };
+            }
+            return {
+                success: true,
+                message: `Note published to ${successCount}/${relays.length} relays`,
+                noteId: signedNote.id,
+                publicKey: publicKey,
+            };
+        }
+        catch (error) {
+            console.error("Error posting anonymous note:", error);
+            return {
+                success: false,
+                message: `Error posting anonymous note: ${error instanceof Error ? error.message : "Unknown error"}`,
+            };
+        }
+        finally {
+            // Clean up any subscriptions and close the pool
+            await pool.close();
+        }
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: `Fatal error: ${error instanceof Error ? error.message : "Unknown error"}`,
+        };
+    }
+}
+// Helper function to convert private key to hex if nsec format
+function normalizePrivateKey(privateKey) {
+    if (privateKey.startsWith('nsec')) {
+        const decoded = nip19decode(privateKey);
+        if (decoded.type !== 'nsec') {
+            throw new Error('Invalid nsec format');
+        }
+        return decoded.data;
+    }
+    return privateKey;
+}
+// Helper function to derive public key from private key
+function getPublicKeyFromPrivate(privateKey) {
+    return Buffer.from(schnorr.getPublicKey(privateKey)).toString('hex');
+}
+/**
+ * Create a new kind 1 note event (unsigned)
+ */
+export async function createNote(privateKey, content, tags = []) {
+    try {
+        // Normalize private key
+        const normalizedPrivateKey = normalizePrivateKey(privateKey);
+        // Derive public key from private key
+        const publicKey = getPublicKeyFromPrivate(normalizedPrivateKey);
+        // Create the note event template
+        const noteTemplate = createEvent({
+            kind: 1, // kind 1 is a text note
+            content,
+            tags
+        }, publicKey);
+        return {
+            success: true,
+            message: 'Note event created successfully (unsigned)',
+            noteEvent: noteTemplate,
+            publicKey: publicKey,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: `Error creating note: ${error instanceof Error ? error.message : "Unknown error"}`,
+        };
+    }
+}
+/**
+ * Sign a note event
+ */
+export async function signNote(privateKey, noteEvent) {
+    try {
+        // Normalize private key
+        const normalizedPrivateKey = normalizePrivateKey(privateKey);
+        // Verify the public key matches the private key
+        const derivedPubkey = getPublicKeyFromPrivate(normalizedPrivateKey);
+        if (derivedPubkey !== noteEvent.pubkey) {
+            return {
+                success: false,
+                message: 'Private key does not match the public key in the note event',
+            };
+        }
+        // Get event hash and sign it
+        const eventId = await getEventHash(noteEvent);
+        const signature = await signEvent(eventId, normalizedPrivateKey);
+        // Create complete signed event
+        const signedNote = {
+            ...noteEvent,
+            id: eventId,
+            sig: signature
+        };
+        return {
+            success: true,
+            message: 'Note signed successfully',
+            signedNote: signedNote,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: `Error signing note: ${error instanceof Error ? error.message : "Unknown error"}`,
+        };
+    }
+}
+/**
+ * Publish a signed note to relays
+ */
+export async function publishNote(signedNote, relays = DEFAULT_RELAYS) {
+    try {
+        // console.error(`Preparing to publish note to ${relays.join(", ")}`);
+        // If no relays specified, just return success with event validation
+        if (relays.length === 0) {
+            return {
+                success: true,
+                message: 'Note is valid and ready to publish (no relays specified)',
+                noteId: signedNote.id,
+            };
+        }
+        // Create a fresh pool for this request
+        const pool = getFreshPool(relays);
+        try {
+            // Publish to relays and wait for actual relay OK responses
+            const pubPromises = pool.publish(relays, signedNote);
+            // Wait for all publish attempts to complete or timeout
+            const results = await Promise.allSettled(pubPromises);
+            // Check if at least one relay actually accepted the event
+            // A fulfilled promise means relay responded, but we need to check if it accepted
+            const successCount = results.filter(r => r.status === 'fulfilled' && r.value.success === true).length;
+            if (successCount === 0) {
+                return {
+                    success: false,
+                    message: 'Failed to publish note to any relay',
+                };
+            }
+            return {
+                success: true,
+                message: `Note published to ${successCount}/${relays.length} relays`,
+                noteId: signedNote.id,
+            };
+        }
+        catch (error) {
+            console.error("Error publishing note:", error);
+            return {
+                success: false,
+                message: `Error publishing note: ${error instanceof Error ? error.message : "Unknown error"}`,
+            };
+        }
+        finally {
+            // Clean up any subscriptions and close the pool
+            await pool.close();
+        }
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: `Fatal error: ${error instanceof Error ? error.message : "Unknown error"}`,
+        };
+    }
+}

package/build/note-tools.js

@@ -0,0 +1,53 @@
+import { z } from "zod";
+// Schema for getProfile tool
+export const getProfileToolConfig = {
+    pubkey: z.string().describe("Public key of the Nostr user (hex format or npub format)"),
+    relays: z.array(z.string()).optional().describe("Optional list of relays to query"),
+};
+// Schema for getKind1Notes tool
+export const getKind1NotesToolConfig = {
+    pubkey: z.string().describe("Public key of the Nostr user (hex format or npub format)"),
+    limit: z.number().min(1).max(100).default(10).describe("Maximum number of notes to fetch"),
+    relays: z.array(z.string()).optional().describe("Optional list of relays to query"),
+};
+// Schema for getLongFormNotes tool
+export const getLongFormNotesToolConfig = {
+    pubkey: z.string().describe("Public key of the Nostr user (hex format or npub format)"),
+    limit: z.number().min(1).max(100).default(10).describe("Maximum number of notes to fetch"),
+    relays: z.array(z.string()).optional().describe("Optional list of relays to query"),
+};
+// Helper function to format profile data
+export function formatProfile(profile) {
+    if (!profile)
+        return "No profile found";
+    let metadata = {};
+    try {
+        metadata = profile.content ? JSON.parse(profile.content) : {};
+    }
+    catch (e) {
+        console.error("Error parsing profile metadata:", e);
+    }
+    return [
+        `Name: ${metadata.name || "Unknown"}`,
+        `Display Name: ${metadata.display_name || metadata.displayName || metadata.name || "Unknown"}`,
+        `About: ${metadata.about || "No about information"}`,
+        `NIP-05: ${metadata.nip05 || "Not set"}`,
+        `Lightning Address (LUD-16): ${metadata.lud16 || "Not set"}`,
+        `LNURL (LUD-06): ${metadata.lud06 || "Not set"}`,
+        `Picture: ${metadata.picture || "No picture"}`,
+        `Website: ${metadata.website || "No website"}`,
+        `Created At: ${new Date(profile.created_at * 1000).toISOString()}`,
+    ].join("\n");
+}
+// Helper function to format note content
+export function formatNote(note) {
+    if (!note)
+        return "";
+    const created = new Date(note.created_at * 1000).toLocaleString();
+    return [
+        `ID: ${note.id}`,
+        `Created: ${created}`,
+        `Content: ${note.content}`,
+        `---`,
+    ].join("\n");
+}

package/build/profile/profile-tools.js

@@ -0,0 +1,260 @@
+import { z } from "zod";
+import { DEFAULT_RELAYS } from "../utils/index.js";
+import { generateKeypair, createEvent, getEventHash, signEvent, decode as nip19decode, encodePublicKey, encodePrivateKey } from "snstr";
+import { getFreshPool } from "../utils/index.js";
+import { schnorr } from '@noble/curves/secp256k1';
+// Schema for createKeypair tool
+export const createKeypairToolConfig = {
+    format: z.enum(["both", "hex", "npub"]).default("both").describe("Format to return keys in: hex only, npub only, or both"),
+};
+// Schema for createProfile tool
+export const createProfileToolConfig = {
+    privateKey: z.string().describe("Private key to sign the profile with (hex format or nsec format)"),
+    name: z.string().optional().describe("Display name for the profile"),
+    about: z.string().optional().describe("About/bio text for the profile"),
+    picture: z.string().optional().describe("URL to profile picture"),
+    nip05: z.string().optional().describe("NIP-05 identifier (like email@domain.com)"),
+    lud16: z.string().optional().describe("Lightning address for receiving payments"),
+    lud06: z.string().optional().describe("LNURL for receiving payments"),
+    website: z.string().optional().describe("Personal website URL"),
+    relays: z.array(z.string()).optional().describe("Optional list of relays to publish to"),
+};
+// Schema for updateProfile tool
+export const updateProfileToolConfig = {
+    privateKey: z.string().describe("Private key to sign the profile with (hex format or nsec format)"),
+    name: z.string().optional().describe("Display name for the profile"),
+    about: z.string().optional().describe("About/bio text for the profile"),
+    picture: z.string().optional().describe("URL to profile picture"),
+    nip05: z.string().optional().describe("NIP-05 identifier (like email@domain.com)"),
+    lud16: z.string().optional().describe("Lightning address for receiving payments"),
+    lud06: z.string().optional().describe("LNURL for receiving payments"),
+    website: z.string().optional().describe("Personal website URL"),
+    relays: z.array(z.string()).optional().describe("Optional list of relays to publish to"),
+};
+// Schema for postNote tool
+export const postNoteToolConfig = {
+    privateKey: z.string().describe("Private key to sign the note with (hex format or nsec format)"),
+    content: z.string().describe("Content of the note to post"),
+    tags: z.array(z.array(z.string())).optional().describe("Optional tags to include with the note"),
+    relays: z.array(z.string()).optional().describe("Optional list of relays to publish to"),
+};
+// Helper function to convert private key to hex if nsec format
+function normalizePrivateKey(privateKey) {
+    if (privateKey.startsWith('nsec')) {
+        // Validate nsec format before type assertion
+        if (!/^nsec1[0-9a-z]+$/.test(privateKey)) {
+            throw new Error('Invalid nsec format: must match pattern nsec1[0-9a-z]+');
+        }
+        const decoded = nip19decode(privateKey);
+        if (decoded.type !== 'nsec') {
+            throw new Error('Invalid nsec format');
+        }
+        return decoded.data;
+    }
+    // Validate hex format for non-nsec keys
+    if (!/^[0-9a-f]{64}$/.test(privateKey)) {
+        throw new Error('Invalid private key format: must be 64-character hex string or valid nsec format');
+    }
+    return privateKey;
+}
+// Helper function to derive public key from private key
+function getPublicKeyFromPrivate(privateKey) {
+    return Buffer.from(schnorr.getPublicKey(privateKey)).toString('hex');
+}
+/**
+ * Generate a new Nostr keypair
+ */
+export async function createKeypair(format = "both") {
+    try {
+        // Generate a new keypair
+        const keys = await generateKeypair();
+        const result = {};
+        if (format === "hex" || format === "both") {
+            result.publicKey = keys.publicKey;
+            result.privateKey = keys.privateKey;
+        }
+        if (format === "npub" || format === "both") {
+            result.npub = encodePublicKey(keys.publicKey);
+            result.nsec = encodePrivateKey(keys.privateKey);
+        }
+        return result;
+    }
+    catch (error) {
+        throw new Error(`Failed to generate keypair: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+}
+/**
+ * Create a new Nostr profile (kind 0 event)
+ */
+export async function createProfile(privateKey, profileData, relays = DEFAULT_RELAYS) {
+    try {
+        // Normalize private key
+        const normalizedPrivateKey = normalizePrivateKey(privateKey);
+        // Derive public key from private key
+        const publicKey = getPublicKeyFromPrivate(normalizedPrivateKey);
+        // Create profile metadata object
+        const metadata = {};
+        if (profileData.name)
+            metadata.name = profileData.name;
+        if (profileData.about)
+            metadata.about = profileData.about;
+        if (profileData.picture)
+            metadata.picture = profileData.picture;
+        if (profileData.nip05)
+            metadata.nip05 = profileData.nip05;
+        if (profileData.lud16)
+            metadata.lud16 = profileData.lud16;
+        if (profileData.lud06)
+            metadata.lud06 = profileData.lud06;
+        if (profileData.website)
+            metadata.website = profileData.website;
+        // Create a fresh pool for this request
+        const pool = getFreshPool(relays);
+        try {
+            // Create the profile event template
+            const profileTemplate = createEvent({
+                kind: 0, // kind 0 is profile metadata
+                content: JSON.stringify(metadata),
+                tags: []
+            }, publicKey);
+            // Get event hash and sign it
+            const eventId = await getEventHash(profileTemplate);
+            const signature = await signEvent(eventId, normalizedPrivateKey);
+            // Create complete signed event
+            const signedProfile = {
+                ...profileTemplate,
+                id: eventId,
+                sig: signature
+            };
+            // If no relays specified, just return success with event creation
+            if (relays.length === 0) {
+                return {
+                    success: true,
+                    message: 'Profile event created successfully (no relays specified for publishing)',
+                    eventId: signedProfile.id,
+                    publicKey: publicKey,
+                };
+            }
+            // Publish to relays - pool.publish returns array of promises
+            const pubPromises = pool.publish(relays, signedProfile);
+            // Wait for all publish attempts to complete or timeout
+            const results = await Promise.allSettled(pubPromises);
+            // Check if at least one relay accepted the profile
+            const successCount = results.filter(r => r.status === 'fulfilled' && r.value?.success === true).length;
+            if (successCount === 0) {
+                return {
+                    success: false,
+                    message: 'Failed to publish profile to any relay',
+                };
+            }
+            return {
+                success: true,
+                message: `Profile published to ${successCount}/${relays.length} relays`,
+                eventId: signedProfile.id,
+                publicKey: publicKey,
+            };
+        }
+        catch (error) {
+            console.error("Error creating profile:", error);
+            return {
+                success: false,
+                message: `Error creating profile: ${error instanceof Error ? error.message : "Unknown error"}`,
+            };
+        }
+        finally {
+            // Clean up any subscriptions and close the pool
+            await pool.close();
+        }
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: `Fatal error: ${error instanceof Error ? error.message : "Unknown error"}`,
+        };
+    }
+}
+/**
+ * Update an existing Nostr profile (kind 0 event)
+ * This creates a new profile event that replaces the previous one
+ */
+export async function updateProfile(privateKey, profileData, relays = DEFAULT_RELAYS) {
+    // For kind 0 events (profiles), updating is the same as creating
+    // The newest event replaces the older one
+    return createProfile(privateKey, profileData, relays);
+}
+/**
+ * Post a note using an existing private key (authenticated posting)
+ * This is a convenient all-in-one function that creates, signs, and publishes a note
+ */
+export async function postNote(privateKey, content, tags = [], relays = DEFAULT_RELAYS) {
+    try {
+        // console.log(`Preparing to post authenticated note to ${relays.join(", ")}`);
+        // Normalize private key
+        const normalizedPrivateKey = normalizePrivateKey(privateKey);
+        // Derive public key from private key
+        const publicKey = getPublicKeyFromPrivate(normalizedPrivateKey);
+        // Create a fresh pool for this request
+        const pool = getFreshPool(relays);
+        try {
+            // Create the note event template
+            const noteTemplate = createEvent({
+                kind: 1, // kind 1 is a text note
+                content,
+                tags
+            }, publicKey);
+            // Get event hash and sign it
+            const eventId = await getEventHash(noteTemplate);
+            const signature = await signEvent(eventId, normalizedPrivateKey);
+            // Create complete signed event
+            const signedNote = {
+                ...noteTemplate,
+                id: eventId,
+                sig: signature
+            };
+            // If no relays specified, just return success with event creation
+            if (relays.length === 0) {
+                return {
+                    success: true,
+                    message: 'Note created and signed successfully (no relays specified for publishing)',
+                    noteId: signedNote.id,
+                    publicKey: publicKey,
+                };
+            }
+            // Publish to relays - pool.publish returns array of promises
+            const pubPromises = pool.publish(relays, signedNote);
+            // Wait for all publish attempts to complete or timeout
+            const results = await Promise.allSettled(pubPromises);
+            // Check if at least one relay accepted the note
+            const successCount = results.filter(r => r.status === 'fulfilled' && r.value?.success === true).length;
+            if (successCount === 0) {
+                return {
+                    success: false,
+                    message: 'Failed to publish note to any relay',
+                };
+            }
+            return {
+                success: true,
+                message: `Note published to ${successCount}/${relays.length} relays`,
+                noteId: signedNote.id,
+                publicKey: publicKey,
+            };
+        }
+        catch (error) {
+            console.error("Error posting note:", error);
+            return {
+                success: false,
+                message: `Error posting note: ${error instanceof Error ? error.message : "Unknown error"}`,
+            };
+        }
+        finally {
+            // Clean up any subscriptions and close the pool
+            await pool.close();
+        }
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: `Fatal error: ${error instanceof Error ? error.message : "Unknown error"}`,
+        };
+    }
+}

package/build/utils/constants.js

@@ -0,0 +1,27 @@
+// Set a reasonable timeout for queries
+export const QUERY_TIMEOUT = 8000;
+// Define default relays
+export const DEFAULT_RELAYS = [
+    "wss://relay.damus.io",
+    "wss://relay.nostr.band",
+    "wss://relay.primal.net",
+    "wss://nos.lol",
+    "wss://purplerelay.com",
+    "wss://nostr.land"
+];
+// Add more popular relays that we can try if the default ones fail
+export const FALLBACK_RELAYS = [
+    "wss://nostr.mom",
+    "wss://nostr.noones.com",
+    "wss://nostr-pub.wellorder.net",
+    "wss://nostr.bitcoiner.social",
+    "wss://at.nostrworks.com",
+    "wss://lightningrelay.com",
+];
+// Define event kinds
+export const KINDS = {
+    Metadata: 0,
+    Text: 1,
+    ZapRequest: 9734,
+    ZapReceipt: 9735
+};