nostr-bray 1.21.0 → 1.22.0

package/dist/format.d.ts

@@ -10,8 +10,16 @@ export declare function formatContacts(contacts: Array<{
     relay?: string;
     petname?: string;
 }>): string;
+export declare function formatContactSearch(contacts: Array<{
+    pubkey: string;
+    name?: string;
+    displayName?: string;
+    nip05?: string;
+    petname?: string;
+}>): string;
 export declare function formatNotifications(notifications: any[]): string;
 export declare function formatFeed(events: any[]): string;
+export declare function formatConversation(dms: any[]): string;
 export declare function formatDms(dms: any[]): string;
 export declare function formatRelays(relays: {
     read: string[];

package/dist/format.js

@@ -58,6 +58,23 @@ export function formatContacts(contacts) {
     });
     return `${contacts.length} contacts:\n${lines.join('\n')}`;
 }
+export function formatContactSearch(contacts) {
+    if (contacts.length === 0)
+        return 'No matching contacts.';
+    const lines = contacts.map(c => {
+        const label = c.displayName || c.name || c.petname || c.pubkey.slice(0, 12) + '...';
+        const parts = [label];
+        if (c.name && c.displayName && c.name !== c.displayName)
+            parts.push(`(@${c.name})`);
+        else if (c.name && !c.displayName)
+            parts.push(`(@${c.name})`);
+        if (c.nip05)
+            parts.push(`[${c.nip05}]`);
+        parts.push(c.pubkey.slice(0, 12) + '...');
+        return parts.join('  ');
+    });
+    return `${contacts.length} match${contacts.length !== 1 ? 'es' : ''}:\n${lines.join('\n')}`;
+}
 export function formatNotifications(notifications) {
     if (notifications.length === 0)
         return 'No notifications.';
@@ -88,6 +105,17 @@ export function formatFeed(events) {
         return `${author}  ${time}\n  ${e.content?.slice(0, 200)}\n`;
     }).join('\n');
 }
+export function formatConversation(dms) {
+    if (dms.length === 0)
+        return 'No messages in this conversation.';
+    return dms.map(dm => {
+        const time = new Date(dm.createdAt * 1000).toLocaleString();
+        const from = dm.from?.slice(0, 12) + '...';
+        if (!dm.decrypted)
+            return `✗ ${from}  Could not decrypt  (${time})`;
+        return `${from}  ${time}\n  ${dm.content}`;
+    }).join('\n\n');
+}
 export function formatDms(dms) {
     if (dms.length === 0)
         return 'No messages.';

package/dist/relay-pool.d.ts

@@ -26,6 +26,8 @@ export declare class RelayPool {
     getRelays(npub: string): RelaySet;
     /** Publish event to write relays for the given identity */
     publish(npub: string, event: NostrEvent): Promise<PublishResult>;
+    /** Publish event to explicit relay URLs (not identity-bound) */
+    publishDirect(relays: string[], event: NostrEvent): Promise<PublishResult>;
     /** One-shot query from read relays for the given identity */
     query(npub: string, filter: Filter): Promise<NostrEvent[]>;
     /** One-shot query against explicit relay URLs (not identity-bound) */

package/dist/relay-pool.js

@@ -97,6 +97,35 @@ export class RelayPool {
             errors,
         };
     }
+    /** Publish event to explicit relay URLs (not identity-bound) */
+    async publishDirect(relays, event) {
+        const pool = await this.poolReady;
+        if (relays.length === 0) {
+            return { success: false, accepted: [], rejected: [], errors: ['no relays specified'] };
+        }
+        const promises = pool.publish(relays, event);
+        const accepted = [];
+        const rejected = [];
+        const errors = [];
+        const results = await Promise.allSettled(promises);
+        for (let i = 0; i < results.length; i++) {
+            const result = results[i];
+            const url = relays[i] ?? `relay-${i}`;
+            if (result.status === 'fulfilled') {
+                accepted.push(url);
+            }
+            else {
+                rejected.push(url);
+                errors.push(`${url}: ${result.reason}`);
+            }
+        }
+        return {
+            success: accepted.length === relays.length,
+            accepted,
+            rejected,
+            errors,
+        };
+    }
     /** One-shot query from read relays for the given identity */
     async query(npub, filter) {
         const pool = await this.poolReady;

package/dist/social/dm.d.ts

@@ -1,11 +1,14 @@
 import type { Event as NostrEvent } from 'nostr-tools';
 import type { IdentityContext } from '../context.js';
 import type { RelayPool } from '../relay-pool.js';
+import type { Nip65Manager } from '../nip65.js';
 import type { PublishResult } from '../types.js';
 export interface DmSendResult {
     event: NostrEvent;
+    senderCopy?: NostrEvent;
     protocol: 'nip17' | 'nip04-deprecated';
     publish: PublishResult;
+    senderCopyPublish?: PublishResult;
 }
 export interface DmReadEntry {
     id: string;
@@ -23,6 +26,14 @@ export declare function handleDmSend(ctx: IdentityContext, pool: RelayPool, args
     nip04?: boolean;
     nip04Enabled?: boolean;
     recipientRelay?: string;
+    nip65?: Nip65Manager;
 }): Promise<DmSendResult>;
 /** Read DMs addressed to the active identity */
-export declare function handleDmRead(ctx: IdentityContext, pool: RelayPool): Promise<DmReadEntry[]>;
+export declare function handleDmRead(ctx: IdentityContext, pool: RelayPool, args?: {
+    limit?: number;
+}): Promise<DmReadEntry[]>;
+/** Read DM conversation with a specific pubkey — filters to messages from that person only */
+export declare function handleDmConversation(ctx: IdentityContext, pool: RelayPool, args: {
+    withPubkeyHex: string;
+    limit?: number;
+}): Promise<DmReadEntry[]>;

package/dist/social/dm.js

@@ -1,6 +1,6 @@
 import { wrapEvent } from 'nostr-tools/nip17';
 import * as nip04 from 'nostr-tools/nip04';
-import { decode } from 'nostr-tools/nip19';
+import { decode, npubEncode } from 'nostr-tools/nip19';
 /** Send a DM. Uses NIP-17 gift wrap by default. NIP-04 only if explicitly requested and enabled. */
 export async function handleDmSend(ctx, pool, args) {
     if (args.nip04) {
@@ -21,19 +21,58 @@ export async function handleDmSend(ctx, pool, args) {
         return { event, protocol: 'nip04-deprecated', publish };
     }
     // NIP-17 gift-wrapped DM (default)
-    const event = wrapEvent(ctx.activePrivateKey, { publicKey: args.recipientPubkeyHex, relayUrl: args.recipientRelay }, args.message);
-    const publish = await pool.publish(ctx.activeNpub, event);
-    return { event, protocol: 'nip17', publish };
+    // Look up recipient's inbox relays via NIP-65 for proper delivery
+    let recipientRelays = [];
+    if (args.nip65) {
+        try {
+            const recipientNpub = npubEncode(args.recipientPubkeyHex);
+            const relaySet = await args.nip65.loadForIdentity(recipientNpub, args.recipientPubkeyHex);
+            recipientRelays = relaySet.read; // recipient reads from their read relays
+        }
+        catch { /* fall back to sender's relays */ }
+    }
+    const recipientRelayHint = args.recipientRelay ?? recipientRelays[0];
+    // Wrap for recipient
+    const event = wrapEvent(ctx.activePrivateKey, { publicKey: args.recipientPubkeyHex, relayUrl: recipientRelayHint }, args.message);
+    // Publish to recipient's relays (primary) and sender's relays (fallback)
+    let publish;
+    if (recipientRelays.length > 0) {
+        // Merge recipient read relays with sender write relays for best coverage
+        const senderRelays = pool.getRelays(ctx.activeNpub).write;
+        const allRelays = [...new Set([...recipientRelays, ...senderRelays])];
+        publish = await pool.publishDirect(allRelays, event);
+    }
+    else {
+        publish = await pool.publish(ctx.activeNpub, event);
+    }
+    // Sender copy — wrap the same message addressed to ourselves so our client shows sent DMs.
+    // The inner rumor's p-tag (set by wrapEvent) points to us, but clients use the
+    // outer gift-wrap's p-tag to route, and the inner content to display.
+    const senderHex = decode(ctx.activeNpub).data;
+    const senderCopy = wrapEvent(ctx.activePrivateKey, { publicKey: senderHex, relayUrl: recipientRelayHint }, args.message);
+    const senderCopyPublish = await pool.publish(ctx.activeNpub, senderCopy);
+    return { event, senderCopy, protocol: 'nip17', publish, senderCopyPublish };
 }
 /** Read DMs addressed to the active identity */
-export async function handleDmRead(ctx, pool) {
+export async function handleDmRead(ctx, pool, args) {
     // Fetch gift wraps (kind 1059) and legacy DMs (kind 4) addressed to us
     const activeHex = decode(ctx.activeNpub).data;
     const events = await pool.query(ctx.activeNpub, {
         kinds: [1059, 4],
         '#p': [activeHex],
-        limit: 50,
+        limit: args?.limit ?? 50,
     });
+    return decryptDmEvents(ctx, events);
+}
+/** Read DM conversation with a specific pubkey — filters to messages from that person only */
+export async function handleDmConversation(ctx, pool, args) {
+    const allMessages = await handleDmRead(ctx, pool, { limit: args.limit ?? 100 });
+    return allMessages
+        .filter(m => m.from === args.withPubkeyHex)
+        .sort((a, b) => a.createdAt - b.createdAt); // chronological for conversation view
+}
+/** Decrypt a list of DM events (kind 1059 gift wrap + kind 4 legacy) */
+async function decryptDmEvents(ctx, events) {
     const results = [];
     for (const event of events) {
         if (event.kind === 1059) {

package/dist/social/handlers.d.ts

@@ -56,8 +56,15 @@ export interface Contact {
     relay?: string;
     petname?: string;
 }
+export interface EnrichedContact extends Contact {
+    name?: string;
+    displayName?: string;
+    nip05?: string;
+}
 /** Fetch the kind 3 contact list for a pubkey */
 export declare function handleContactsGet(pool: RelayPool, npub: string, pubkeyHex: string): Promise<Contact[]>;
+/** Search contacts by name/display_name/nip05 — resolves profiles in a single batch query */
+export declare function handleContactsSearch(pool: RelayPool, npub: string, pubkeyHex: string, query: string): Promise<EnrichedContact[]>;
 /** Follow a pubkey — fetches current contacts, adds, publishes new kind 3 */
 export declare function handleContactsFollow(ctx: IdentityContext, pool: RelayPool, args: {
     pubkeyHex: string;

package/dist/social/handlers.js

@@ -149,6 +149,59 @@ export async function handleContactsGet(pool, npub, pubkeyHex) {
         petname: t[3] || undefined,
     }));
 }
+/** Batch-fetch kind 0 profiles for a list of pubkeys, returning the newest per author */
+async function batchFetchProfiles(pool, npub, pubkeys) {
+    if (pubkeys.length === 0)
+        return new Map();
+    const events = await pool.query(npub, {
+        kinds: [0],
+        authors: pubkeys,
+    });
+    // Keep only the newest kind 0 per pubkey
+    const best = new Map();
+    for (const ev of events) {
+        const prev = best.get(ev.pubkey);
+        if (!prev || ev.created_at > prev.created_at) {
+            best.set(ev.pubkey, ev);
+        }
+    }
+    const profiles = new Map();
+    for (const [pk, ev] of best) {
+        try {
+            profiles.set(pk, JSON.parse(ev.content));
+        }
+        catch { /* skip unparseable */ }
+    }
+    return profiles;
+}
+/** Search contacts by name/display_name/nip05 — resolves profiles in a single batch query */
+export async function handleContactsSearch(pool, npub, pubkeyHex, query) {
+    const contacts = await handleContactsGet(pool, npub, pubkeyHex);
+    if (contacts.length === 0)
+        return [];
+    const profiles = await batchFetchProfiles(pool, npub, contacts.map(c => c.pubkey));
+    const q = query.toLowerCase();
+    const results = [];
+    for (const contact of contacts) {
+        const profile = profiles.get(contact.pubkey);
+        const name = profile?.name ?? '';
+        const displayName = profile?.display_name ?? '';
+        const nip05 = profile?.nip05 ?? '';
+        const petname = contact.petname ?? '';
+        if (name.toLowerCase().includes(q) ||
+            displayName.toLowerCase().includes(q) ||
+            nip05.toLowerCase().includes(q) ||
+            petname.toLowerCase().includes(q)) {
+            results.push({
+                ...contact,
+                name: name || undefined,
+                displayName: displayName || undefined,
+                nip05: nip05 || undefined,
+            });
+        }
+    }
+    return results;
+}
 /** Follow a pubkey — fetches current contacts, adds, publishes new kind 3 */
 export async function handleContactsFollow(ctx, pool, args) {
     // Fetch existing contacts

package/dist/social/tools.js

@@ -2,8 +2,8 @@ import { z } from 'zod';
 import { hexId } from '../validation.js';
 import { toolResponse } from '../tool-response.js';
 import * as fmt from '../format.js';
-import { handleSocialPost, handleSocialReply, handleSocialReact, handleSocialProfileGet, handleSocialProfileSet, handleContactsGet, handleContactsFollow, handleContactsUnfollow, handleSocialDelete, handleSocialRepost, } from './handlers.js';
-import { handleDmSend, handleDmRead } from './dm.js';
+import { handleSocialPost, handleSocialReply, handleSocialReact, handleSocialProfileGet, handleSocialProfileSet, handleContactsGet, handleContactsSearch, handleContactsFollow, handleContactsUnfollow, handleSocialDelete, handleSocialRepost, } from './handlers.js';
+import { handleDmSend, handleDmRead, handleDmConversation } from './dm.js';
 import { handleNotifications, handleFeed } from './notifications.js';
 import { handleNipPublish, handleNipRead } from './nips.js';
 import { handleBlossomUpload, handleBlossomList, handleBlossomDelete } from './blossom.js';
@@ -151,12 +151,14 @@ export function registerSocialTools(server, deps) {
             nip04,
             nip04Enabled: false, // TODO: wire from config
             recipientRelay,
+            nip65: deps.nip65,
         });
         return {
             content: [{ type: 'text', text: JSON.stringify({
                         protocol: result.protocol,
                         id: result.event.id,
                         publish: result.publish,
+                        senderCopyPublish: result.senderCopyPublish,
                     }, null, 2) }],
         };
     });
@@ -170,6 +172,63 @@ export function registerSocialTools(server, deps) {
         const messages = await handleDmRead(deps.ctx, deps.pool);
         return toolResponse(messages, output, fmt.formatDms);
     });
+    server.registerTool('dm-by-name', {
+        description: 'Send an encrypted DM to a contact by name — no pubkey needed. Searches your contacts, finds the match, and sends the message. Returns an error if zero or multiple matches are found (use contacts-search to disambiguate).',
+        inputSchema: {
+            name: z.string().describe('Contact name to search for (matches name, display_name, nip05 — case insensitive)'),
+            message: z.string().describe('Message text'),
+            nip04: z.boolean().default(false).describe('Use legacy NIP-04 instead of NIP-17'),
+        },
+        annotations: { readOnlyHint: false, destructiveHint: true },
+    }, async ({ name, message, nip04 }) => {
+        // Search contacts for the name
+        const matches = await handleContactsSearch(deps.pool, deps.ctx.activeNpub, deps.ctx.activePublicKeyHex, name);
+        if (matches.length === 0) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({
+                            error: `No contact found matching "${name}". Use contacts-search to check your contacts.`,
+                        }, null, 2) }],
+            };
+        }
+        if (matches.length > 1) {
+            const names = matches.map(m => m.displayName || m.name || m.pubkey.slice(0, 12) + '...');
+            return {
+                content: [{ type: 'text', text: JSON.stringify({
+                            error: `Multiple contacts match "${name}": ${names.join(', ')}. Be more specific or use dm-send with the exact pubkey.`,
+                            matches: matches.map(m => ({ pubkey: m.pubkey, name: m.name, displayName: m.displayName })),
+                        }, null, 2) }],
+            };
+        }
+        const recipient = matches[0];
+        const result = await handleDmSend(deps.ctx, deps.pool, {
+            recipientPubkeyHex: recipient.pubkey,
+            message,
+            nip04,
+            nip04Enabled: false,
+            nip65: deps.nip65,
+        });
+        return {
+            content: [{ type: 'text', text: JSON.stringify({
+                        sentTo: recipient.displayName || recipient.name || recipient.pubkey.slice(0, 12) + '...',
+                        recipientPubkey: recipient.pubkey,
+                        protocol: result.protocol,
+                        id: result.event.id,
+                        publish: result.publish,
+                    }, null, 2) }],
+        };
+    });
+    server.registerTool('dm-conversation', {
+        description: 'Read DM conversation with a specific person. Filters to messages from one pubkey and shows them in chronological order. Use contacts-search first if you only know the name.',
+        inputSchema: {
+            pubkeyHex: hexId.describe('Hex pubkey to show conversation with'),
+            limit: z.number().int().min(1).max(200).default(50).describe('Max messages to fetch before filtering'),
+            output: z.enum(['json', 'human']).default('human').describe('Response format'),
+        },
+        annotations: { readOnlyHint: true },
+    }, async ({ pubkeyHex, limit, output }) => {
+        const messages = await handleDmConversation(deps.ctx, deps.pool, { withPubkeyHex: pubkeyHex, limit });
+        return toolResponse(messages, output, fmt.formatConversation);
+    });
     server.registerTool('social-notifications', {
         description: 'Fetch notifications for the active identity — mentions, replies, reactions, and zap receipts.',
         inputSchema: {
@@ -195,6 +254,74 @@ export function registerSocialTools(server, deps) {
         const feed = await handleFeed(deps.ctx, deps.pool, { authors, since, limit });
         return toolResponse(feed, output, fmt.formatFeed);
     });
+    server.registerTool('feed-by-name', {
+        description: 'Fetch recent posts by a contact, searching by name instead of pubkey. Returns an error if zero or multiple contacts match.',
+        inputSchema: {
+            name: z.string().describe('Contact name to search for (case insensitive)'),
+            since: z.number().optional().describe('Unix timestamp — only fetch posts after this time'),
+            limit: z.number().int().min(1).max(100).default(20).describe('Max posts to return'),
+            output: z.enum(['json', 'human']).default('human').describe('Response format'),
+        },
+        annotations: { readOnlyHint: true },
+    }, async ({ name, since, limit, output }) => {
+        const matches = await handleContactsSearch(deps.pool, deps.ctx.activeNpub, deps.ctx.activePublicKeyHex, name);
+        if (matches.length === 0) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({
+                            error: `No contact found matching "${name}".`,
+                        }, null, 2) }],
+            };
+        }
+        if (matches.length > 1) {
+            const names = matches.map(m => m.displayName || m.name || m.pubkey.slice(0, 12) + '...');
+            return {
+                content: [{ type: 'text', text: JSON.stringify({
+                            error: `Multiple contacts match "${name}": ${names.join(', ')}. Be more specific.`,
+                            matches: matches.map(m => ({ pubkey: m.pubkey, name: m.name, displayName: m.displayName })),
+                        }, null, 2) }],
+            };
+        }
+        const contact = matches[0];
+        const feed = await handleFeed(deps.ctx, deps.pool, { authors: [contact.pubkey], since, limit });
+        return toolResponse({ contact: { name: contact.displayName || contact.name, pubkey: contact.pubkey }, posts: feed }, output, (data) => {
+            const header = `Posts by ${data.contact.name ?? data.contact.pubkey.slice(0, 12) + '...'}:`;
+            if (data.posts.length === 0)
+                return `${header}\n  No posts found.`;
+            return `${header}\n${fmt.formatFeed(data.posts)}`;
+        });
+    });
+    server.registerTool('profile-by-name', {
+        description: 'Look up a contact\'s full profile by name — no pubkey needed. Searches your contacts and returns the kind 0 profile for the match.',
+        inputSchema: {
+            name: z.string().describe('Contact name to search for (case insensitive)'),
+            output: z.enum(['json', 'human']).default('human').describe('Response format'),
+        },
+        annotations: { readOnlyHint: true },
+    }, async ({ name, output }) => {
+        const matches = await handleContactsSearch(deps.pool, deps.ctx.activeNpub, deps.ctx.activePublicKeyHex, name);
+        if (matches.length === 0) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({
+                            error: `No contact found matching "${name}".`,
+                        }, null, 2) }],
+            };
+        }
+        if (matches.length > 1) {
+            const names = matches.map(m => m.displayName || m.name || m.pubkey.slice(0, 12) + '...');
+            return {
+                content: [{ type: 'text', text: JSON.stringify({
+                            error: `Multiple contacts match "${name}": ${names.join(', ')}. Be more specific.`,
+                            matches: matches.map(m => ({ pubkey: m.pubkey, name: m.name, displayName: m.displayName })),
+                        }, null, 2) }],
+            };
+        }
+        const contact = matches[0];
+        const profile = await handleSocialProfileGet(deps.pool, deps.ctx.activeNpub, contact.pubkey);
+        return toolResponse({ ...profile, _pubkey: contact.pubkey }, output, (data) => {
+            const { _pubkey, ...fields } = data;
+            return `Pubkey: ${_pubkey}\n${fmt.formatProfile(fields)}`;
+        });
+    });
     server.registerTool('contacts-get', {
         description: 'Fetch the contact list (kind 3 follows) for a pubkey. Returns pubkeys, relay hints, and petnames.',
         inputSchema: {
@@ -207,6 +334,21 @@ export function registerSocialTools(server, deps) {
         const contacts = await handleContactsGet(deps.pool, npub ?? deps.ctx.activeNpub, pubkeyHex);
         return toolResponse(contacts, output, fmt.formatContacts);
     });
+    server.registerTool('contacts-search', {
+        description: 'Search your contacts by name, display name, or NIP-05. Resolves profiles in one batch — much faster than fetching each individually. Use this to find a contact when you know their name but not their pubkey.',
+        inputSchema: {
+            query: z.string().describe('Search string (matches name, display_name, nip05, petname — case insensitive)'),
+            pubkeyHex: hexId.optional().describe('Hex pubkey whose contacts to search (defaults to active identity)'),
+            npub: z.string().optional().describe('Bech32 npub for relay routing (defaults to active identity)'),
+            output: z.enum(['json', 'human']).default('human').describe('Response format'),
+        },
+        annotations: { readOnlyHint: true },
+    }, async ({ query, pubkeyHex, npub, output }) => {
+        const resolvedNpub = npub ?? deps.ctx.activeNpub;
+        const resolvedPubkey = pubkeyHex ?? deps.ctx.activePublicKeyHex;
+        const results = await handleContactsSearch(deps.pool, resolvedNpub, resolvedPubkey, query);
+        return toolResponse(results, output, fmt.formatContactSearch);
+    });
     server.registerTool('contacts-follow', {
         description: 'Follow a Nostr pubkey. Fetches current contact list, adds the pubkey, publishes updated kind 3.',
         inputSchema: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nostr-bray",
-  "version": "1.21.0",
+  "version": "1.22.0",
   "description": "MCP server giving AI agents sovereign Nostr identities — key derivation, personas, attestations, duress detection, zaps",
   "type": "module",
   "main": "dist/index.js",