nostr-bray 0.0.0-development

package/dist/social/dm.d.ts

@@ -0,0 +1,28 @@
+import type { Event as NostrEvent } from 'nostr-tools';
+import type { IdentityContext } from '../context.js';
+import type { RelayPool } from '../relay-pool.js';
+import type { PublishResult } from '../types.js';
+export interface DmSendResult {
+    event: NostrEvent;
+    protocol: 'nip17' | 'nip04-deprecated';
+    publish: PublishResult;
+}
+export interface DmReadEntry {
+    id: string;
+    from: string;
+    content?: string;
+    createdAt: number;
+    protocol: 'nip17' | 'nip04-deprecated';
+    decrypted: boolean;
+    error?: string;
+}
+/** Send a DM. Uses NIP-17 gift wrap by default. NIP-04 only if explicitly requested and enabled. */
+export declare function handleDmSend(ctx: IdentityContext, pool: RelayPool, args: {
+    recipientPubkeyHex: string;
+    message: string;
+    nip04?: boolean;
+    nip04Enabled?: boolean;
+    recipientRelay?: string;
+}): Promise<DmSendResult>;
+/** Read DMs addressed to the active identity */
+export declare function handleDmRead(ctx: IdentityContext, pool: RelayPool): Promise<DmReadEntry[]>;

package/dist/social/dm.js

@@ -0,0 +1,90 @@
+import { wrapEvent } from 'nostr-tools/nip17';
+import * as nip04 from 'nostr-tools/nip04';
+import { decode } 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) {
+        if (!args.nip04Enabled) {
+            throw new Error('NIP-04 is not enabled. Set NIP04_ENABLED=1 to use legacy DMs.');
+        }
+        // NIP-04 legacy DM (kind 4)
+        const encrypted = await nip04.encrypt(ctx.activePrivateKey, args.recipientPubkeyHex, args.message);
+        const sign = ctx.getSigningFunction();
+        const event = await sign({
+            kind: 4,
+            created_at: Math.floor(Date.now() / 1000),
+            tags: [['p', args.recipientPubkeyHex]],
+            content: encrypted,
+        });
+        console.error('Warning: NIP-04 DMs are deprecated. Prefer NIP-17 gift-wrapped DMs.');
+        const publish = await pool.publish(ctx.activeNpub, event);
+        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 };
+}
+/** Read DMs addressed to the active identity */
+export async function handleDmRead(ctx, pool) {
+    // 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,
+    });
+    const results = [];
+    for (const event of events) {
+        if (event.kind === 1059) {
+            // NIP-17 gift wrap — try to unwrap
+            try {
+                const { unwrapEvent } = await import('nostr-tools/nip17');
+                const unwrapped = unwrapEvent(event, ctx.activePrivateKey);
+                results.push({
+                    id: event.id,
+                    from: unwrapped.pubkey,
+                    content: unwrapped.content,
+                    createdAt: unwrapped.created_at,
+                    protocol: 'nip17',
+                    decrypted: true,
+                });
+            }
+            catch {
+                results.push({
+                    id: event.id,
+                    from: event.pubkey,
+                    createdAt: event.created_at,
+                    protocol: 'nip17',
+                    decrypted: false,
+                    error: 'Could not decrypt NIP-17 gift wrap',
+                });
+            }
+        }
+        else if (event.kind === 4) {
+            // NIP-04 legacy DM
+            try {
+                const decrypted = await nip04.decrypt(ctx.activePrivateKey, event.pubkey, event.content);
+                results.push({
+                    id: event.id,
+                    from: event.pubkey,
+                    content: decrypted,
+                    createdAt: event.created_at,
+                    protocol: 'nip04-deprecated',
+                    decrypted: true,
+                });
+            }
+            catch {
+                results.push({
+                    id: event.id,
+                    from: event.pubkey,
+                    createdAt: event.created_at,
+                    protocol: 'nip04-deprecated',
+                    decrypted: false,
+                    error: 'Could not decrypt NIP-04 message',
+                });
+            }
+        }
+    }
+    return results;
+}

package/dist/social/handlers.d.ts

@@ -0,0 +1,42 @@
+import type { Event as NostrEvent } from 'nostr-tools';
+import type { IdentityContext } from '../context.js';
+import type { RelayPool } from '../relay-pool.js';
+import type { PublishResult } from '../types.js';
+export interface PostResult {
+    event: NostrEvent;
+    publish: PublishResult;
+}
+/** Create and publish a kind 1 text note */
+export declare function handleSocialPost(ctx: IdentityContext, pool: RelayPool, args: {
+    content: string;
+    tags?: string[][];
+}): Promise<PostResult>;
+/** Create and publish a reply (kind 1 with e-tag and p-tag) */
+export declare function handleSocialReply(ctx: IdentityContext, pool: RelayPool, args: {
+    content: string;
+    replyTo: string;
+    replyToPubkey: string;
+    relay?: string;
+}): Promise<PostResult>;
+/** Create and publish a reaction (kind 7) */
+export declare function handleSocialReact(ctx: IdentityContext, pool: RelayPool, args: {
+    eventId: string;
+    eventPubkey: string;
+    reaction?: string;
+}): Promise<PostResult>;
+/** Fetch and parse the kind 0 profile for a pubkey */
+export declare function handleSocialProfileGet(pool: RelayPool, npub: string, pubkeyHex: string): Promise<Record<string, unknown>>;
+export interface ProfileSetResult {
+    published: boolean;
+    event: NostrEvent;
+    warning?: string;
+    diff?: Record<string, {
+        old: unknown;
+        new: unknown;
+    }>;
+}
+/** Set the kind 0 profile for the active identity, with overwrite safety guard */
+export declare function handleSocialProfileSet(ctx: IdentityContext, pool: RelayPool, args: {
+    profile: Record<string, unknown>;
+    confirm?: boolean;
+}): Promise<ProfileSetResult>;

package/dist/social/handlers.js

@@ -0,0 +1,107 @@
+/** Create and publish a kind 1 text note */
+export async function handleSocialPost(ctx, pool, args) {
+    const sign = ctx.getSigningFunction();
+    const event = await sign({
+        kind: 1,
+        created_at: Math.floor(Date.now() / 1000),
+        tags: args.tags ?? [],
+        content: args.content,
+    });
+    const publish = await pool.publish(ctx.activeNpub, event);
+    return { event, publish };
+}
+/** Create and publish a reply (kind 1 with e-tag and p-tag) */
+export async function handleSocialReply(ctx, pool, args) {
+    const tags = [
+        ['e', args.replyTo, args.relay ?? '', 'reply'],
+        ['p', args.replyToPubkey],
+    ];
+    const sign = ctx.getSigningFunction();
+    const event = await sign({
+        kind: 1,
+        created_at: Math.floor(Date.now() / 1000),
+        tags,
+        content: args.content,
+    });
+    const publish = await pool.publish(ctx.activeNpub, event);
+    return { event, publish };
+}
+/** Create and publish a reaction (kind 7) */
+export async function handleSocialReact(ctx, pool, args) {
+    const sign = ctx.getSigningFunction();
+    const event = await sign({
+        kind: 7,
+        created_at: Math.floor(Date.now() / 1000),
+        tags: [
+            ['e', args.eventId],
+            ['p', args.eventPubkey],
+        ],
+        content: args.reaction ?? '+',
+    });
+    const publish = await pool.publish(ctx.activeNpub, event);
+    return { event, publish };
+}
+/** Fetch and parse the kind 0 profile for a pubkey */
+export async function handleSocialProfileGet(pool, npub, pubkeyHex) {
+    const events = await pool.query(npub, {
+        kinds: [0],
+        authors: [pubkeyHex],
+    });
+    if (events.length === 0)
+        return {};
+    // Take highest created_at
+    const best = events.reduce((a, b) => b.created_at > a.created_at ? b : a);
+    try {
+        return JSON.parse(best.content);
+    }
+    catch {
+        return {};
+    }
+}
+/** Set the kind 0 profile for the active identity, with overwrite safety guard */
+export async function handleSocialProfileSet(ctx, pool, args) {
+    // Check for existing profile
+    const existing = await pool.query(ctx.activeNpub, {
+        kinds: [0],
+        authors: [ctx.activeNpub], // simplified — in production, use hex pubkey
+    });
+    if (existing.length > 0 && !args.confirm) {
+        // Build diff
+        let oldProfile = {};
+        try {
+            const best = existing.reduce((a, b) => b.created_at > a.created_at ? b : a);
+            oldProfile = JSON.parse(best.content);
+        }
+        catch { /* ignore */ }
+        const diff = {};
+        const allKeys = new Set([...Object.keys(oldProfile), ...Object.keys(args.profile)]);
+        for (const key of allKeys) {
+            if (oldProfile[key] !== args.profile[key]) {
+                diff[key] = { old: oldProfile[key], new: args.profile[key] };
+            }
+        }
+        const sign = ctx.getSigningFunction();
+        const event = await sign({
+            kind: 0,
+            created_at: Math.floor(Date.now() / 1000),
+            tags: [],
+            content: JSON.stringify(args.profile),
+        });
+        return {
+            published: false,
+            event,
+            warning: 'Profile already exists. Set confirm: true to overwrite.',
+            diff,
+        };
+    }
+    // Publish
+    const sign = ctx.getSigningFunction();
+    const event = await sign({
+        kind: 0,
+        created_at: Math.floor(Date.now() / 1000),
+        tags: [],
+        content: JSON.stringify(args.profile),
+    });
+    await pool.publish(ctx.activeNpub, event);
+    return { published: true, event };
+}

package/dist/social/notifications.d.ts

@@ -0,0 +1,32 @@
+import type { IdentityContext } from '../context.js';
+import type { RelayPool } from '../relay-pool.js';
+export interface Notification {
+    id: string;
+    type: 'reply' | 'reaction' | 'mention' | 'zap' | 'other';
+    kind: number;
+    from: string;
+    content: string;
+    createdAt: number;
+    replyToEventId?: string;
+    amountMsats?: number;
+    zapSender?: string;
+    zapMessage?: string;
+}
+export interface FeedEntry {
+    id: string;
+    pubkey: string;
+    content: string;
+    createdAt: number;
+    tags: string[][];
+}
+/** Fetch notifications (mentions, replies, reactions, zaps) for the active identity */
+export declare function handleNotifications(ctx: IdentityContext, pool: RelayPool, opts?: {
+    since?: number;
+    limit?: number;
+}): Promise<Notification[]>;
+/** Fetch feed (kind 1 events) */
+export declare function handleFeed(ctx: IdentityContext, pool: RelayPool, opts: {
+    authors?: string[];
+    since?: number;
+    limit?: number;
+}): Promise<FeedEntry[]>;

package/dist/social/notifications.js

@@ -0,0 +1,74 @@
+/** Fetch notifications (mentions, replies, reactions, zaps) for the active identity */
+export async function handleNotifications(ctx, pool, opts) {
+    const events = await pool.query(ctx.activeNpub, {
+        kinds: [1, 7, 9735],
+        '#p': [ctx.activeNpub],
+        limit: opts?.limit ?? 50,
+        ...(opts?.since ? { since: opts.since } : {}),
+    });
+    return events
+        .filter(e => e.kind !== 3) // exclude follows
+        .map(event => classifyNotification(event, ctx.activeNpub))
+        .sort((a, b) => b.createdAt - a.createdAt);
+}
+/** Classify a single event into a notification type */
+function classifyNotification(event, activeNpub) {
+    const base = {
+        id: event.id,
+        kind: event.kind,
+        from: event.pubkey,
+        content: event.content,
+        createdAt: event.created_at,
+    };
+    if (event.kind === 7) {
+        return { ...base, type: 'reaction' };
+    }
+    if (event.kind === 9735) {
+        return parseZapReceipt(event, base);
+    }
+    if (event.kind === 1) {
+        // Check if it's a reply (has e-tag with 'reply' marker) or just a mention
+        const eTag = event.tags.find(t => t[0] === 'e');
+        if (eTag) {
+            return { ...base, type: 'reply', replyToEventId: eTag[1] };
+        }
+        return { ...base, type: 'mention' };
+    }
+    return { ...base, type: 'other' };
+}
+/** Parse zap receipt (kind 9735) for amount and sender */
+function parseZapReceipt(event, base) {
+    let amountMsats;
+    let zapSender;
+    let zapMessage;
+    const descTag = event.tags.find(t => t[0] === 'description');
+    if (descTag?.[1]) {
+        try {
+            const zapRequest = JSON.parse(descTag[1]);
+            zapSender = zapRequest.pubkey;
+            zapMessage = zapRequest.content;
+            const amountTag = zapRequest.tags?.find((t) => t[0] === 'amount');
+            if (amountTag?.[1]) {
+                amountMsats = parseInt(amountTag[1], 10);
+            }
+        }
+        catch { /* ignore malformed zap request */ }
+    }
+    return { ...base, type: 'zap', amountMsats, zapSender, zapMessage };
+}
+/** Fetch feed (kind 1 events) */
+export async function handleFeed(ctx, pool, opts) {
+    const events = await pool.query(ctx.activeNpub, {
+        kinds: [1],
+        ...(opts.authors ? { authors: opts.authors } : {}),
+        ...(opts.since ? { since: opts.since } : {}),
+        limit: opts.limit ?? 20,
+    });
+    return events.map(e => ({
+        id: e.id,
+        pubkey: e.pubkey,
+        content: e.content,
+        createdAt: e.created_at,
+        tags: e.tags,
+    }));
+}

package/dist/social/tools.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ToolDeps } from '../identity/tools.js';
+export declare function registerSocialTools(server: McpServer, deps: ToolDeps): void;

package/dist/social/tools.js

@@ -0,0 +1,168 @@
+import { z } from 'zod';
+import { hexId } from '../validation.js';
+import { handleSocialPost, handleSocialReply, handleSocialReact, handleSocialProfileGet, handleSocialProfileSet, } from './handlers.js';
+import { handleDmSend, handleDmRead } from './dm.js';
+import { handleNotifications, handleFeed } from './notifications.js';
+export function registerSocialTools(server, deps) {
+    server.registerTool('social_post', {
+        description: 'Post a text note (kind 1) as the active identity. Returns the signed event.',
+        inputSchema: {
+            content: z.string().describe('Text content of the note'),
+        },
+        annotations: { readOnlyHint: false },
+    }, async ({ content }) => {
+        const result = await handleSocialPost(deps.ctx, deps.pool, { content });
+        return {
+            content: [{ type: 'text', text: JSON.stringify({
+                        id: result.event.id,
+                        pubkey: result.event.pubkey,
+                        publish: result.publish,
+                    }, null, 2) }],
+        };
+    });
+    server.registerTool('social_reply', {
+        description: 'Reply to a Nostr event (kind 1 with e-tag and p-tag) as the active identity.',
+        inputSchema: {
+            content: z.string().describe('Reply text'),
+            replyTo: hexId.describe('Event ID being replied to (hex)'),
+            replyToPubkey: hexId.describe('Pubkey of the event author (hex)'),
+            relay: z.string().optional().describe('Relay URL where the parent event was seen'),
+        },
+        annotations: { readOnlyHint: false },
+    }, async ({ content, replyTo, replyToPubkey, relay }) => {
+        const result = await handleSocialReply(deps.ctx, deps.pool, { content, replyTo, replyToPubkey, relay });
+        return {
+            content: [{ type: 'text', text: JSON.stringify({
+                        id: result.event.id,
+                        publish: result.publish,
+                    }, null, 2) }],
+        };
+    });
+    server.registerTool('social_react', {
+        description: 'React to a Nostr event (kind 7) as the active identity. Default reaction is "+".',
+        inputSchema: {
+            eventId: hexId.describe('Event ID to react to (hex)'),
+            eventPubkey: hexId.describe('Pubkey of the event author (hex)'),
+            reaction: z.string().default('+').describe('Reaction content (default "+", or emoji)'),
+        },
+        annotations: { readOnlyHint: false },
+    }, async ({ eventId, eventPubkey, reaction }) => {
+        const result = await handleSocialReact(deps.ctx, deps.pool, { eventId, eventPubkey, reaction });
+        return {
+            content: [{ type: 'text', text: JSON.stringify({
+                        id: result.event.id,
+                        publish: result.publish,
+                    }, null, 2) }],
+        };
+    });
+    server.registerTool('social_profile_get', {
+        description: 'Fetch the kind 0 profile for a Nostr pubkey. Returns parsed profile fields.',
+        inputSchema: {
+            pubkeyHex: hexId.describe('Hex pubkey to fetch profile for'),
+            npub: z.string().optional().describe('Bech32 npub (used for relay routing, defaults to active identity)'),
+        },
+        annotations: { readOnlyHint: true },
+    }, async ({ pubkeyHex, npub }) => {
+        const resolvedNpub = npub ?? deps.ctx.activeNpub;
+        const profile = await handleSocialProfileGet(deps.pool, resolvedNpub, pubkeyHex);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(profile, null, 2) }],
+        };
+    });
+    server.registerTool('social_profile_set', {
+        description: 'Set the kind 0 profile for the active identity. Warns if profile already exists — set confirm: true to overwrite.',
+        inputSchema: {
+            name: z.string().optional().describe('Display name'),
+            about: z.string().optional().describe('About / bio text'),
+            picture: z.string().optional().describe('Profile picture URL'),
+            nip05: z.string().optional().describe('NIP-05 identifier'),
+            banner: z.string().optional().describe('Banner image URL'),
+            lud16: z.string().optional().describe('Lightning address'),
+            confirm: z.boolean().default(false).describe('Set true to overwrite existing profile'),
+        },
+        annotations: { readOnlyHint: false },
+    }, async ({ confirm, ...fields }) => {
+        // Filter out undefined fields
+        const profile = {};
+        for (const [k, v] of Object.entries(fields)) {
+            if (v !== undefined)
+                profile[k] = v;
+        }
+        const result = await handleSocialProfileSet(deps.ctx, deps.pool, { profile, confirm });
+        if (!result.published && result.warning) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({
+                            warning: result.warning,
+                            diff: result.diff,
+                        }, null, 2) }],
+            };
+        }
+        return {
+            content: [{ type: 'text', text: JSON.stringify({
+                        published: true,
+                        id: result.event.id,
+                    }, null, 2) }],
+        };
+    });
+    server.registerTool('dm_send', {
+        description: 'Send a direct message to a Nostr pubkey. Uses NIP-17 gift wrap by default. Set nip04: true for legacy NIP-04 (requires NIP04_ENABLED).',
+        inputSchema: {
+            recipientPubkeyHex: hexId.describe('Recipient hex pubkey'),
+            message: z.string().describe('Message text'),
+            nip04: z.boolean().default(false).describe('Use legacy NIP-04 instead of NIP-17'),
+            recipientRelay: z.string().optional().describe('Relay URL hint for recipient'),
+        },
+        annotations: { readOnlyHint: false },
+    }, async ({ recipientPubkeyHex, message, nip04, recipientRelay }) => {
+        const result = await handleDmSend(deps.ctx, deps.pool, {
+            recipientPubkeyHex,
+            message,
+            nip04,
+            nip04Enabled: false, // TODO: wire from config
+            recipientRelay,
+        });
+        return {
+            content: [{ type: 'text', text: JSON.stringify({
+                        protocol: result.protocol,
+                        id: result.event.id,
+                        publish: result.publish,
+                    }, null, 2) }],
+        };
+    });
+    server.registerTool('dm_read', {
+        description: 'Read direct messages addressed to the active identity. Decrypts NIP-17 and NIP-04 messages.',
+        annotations: { readOnlyHint: true },
+    }, async () => {
+        const messages = await handleDmRead(deps.ctx, deps.pool);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(messages, null, 2) }],
+        };
+    });
+    server.registerTool('social_notifications', {
+        description: 'Fetch notifications for the active identity — mentions, replies, reactions, and zap receipts.',
+        inputSchema: {
+            since: z.number().optional().describe('Unix timestamp — only fetch notifications after this time'),
+            limit: z.number().int().min(1).max(200).default(50).describe('Max notifications to return'),
+        },
+        annotations: { readOnlyHint: true },
+    }, async ({ since, limit }) => {
+        const notifications = await handleNotifications(deps.ctx, deps.pool, { since, limit });
+        return {
+            content: [{ type: 'text', text: JSON.stringify(notifications, null, 2) }],
+        };
+    });
+    server.registerTool('social_feed', {
+        description: 'Fetch the kind 1 text note feed. Optionally filter by authors.',
+        inputSchema: {
+            authors: z.array(hexId).optional().describe('Hex pubkeys to filter by'),
+            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'),
+        },
+        annotations: { readOnlyHint: true },
+    }, async ({ authors, since, limit }) => {
+        const feed = await handleFeed(deps.ctx, deps.pool, { authors, since, limit });
+        return {
+            content: [{ type: 'text', text: JSON.stringify(feed, null, 2) }],
+        };
+    });
+}

package/dist/trust/handlers.d.ts

@@ -0,0 +1,65 @@
+import type { Event as NostrEvent } from 'nostr-tools';
+import type { IdentityContext } from '../context.js';
+import type { RelayPool } from '../relay-pool.js';
+import type { PublishResult } from '../types.js';
+export interface AttestResult {
+    event: NostrEvent;
+    publish: PublishResult;
+    warning?: string;
+}
+/** Create and publish a kind 31000 attestation */
+export declare function handleTrustAttest(ctx: IdentityContext, pool: RelayPool, args: {
+    type: string;
+    identifier?: string;
+    subject?: string;
+    summary?: string;
+    content?: string;
+    expiration?: number;
+}): Promise<AttestResult>;
+/** Read attestations from relays, filtered by subject/type/attestor */
+export declare function handleTrustRead(pool: RelayPool, npub: string, args: {
+    subject?: string;
+    type?: string;
+    attestor?: string;
+}): Promise<NostrEvent[]>;
+/** Validate attestation event structure */
+export declare function handleTrustVerify(event: NostrEvent): {
+    valid: boolean;
+    errors: string[];
+};
+/** Create and publish a revocation for an attestation */
+export declare function handleTrustRevoke(ctx: IdentityContext, pool: RelayPool, args: {
+    type: string;
+    identifier: string;
+    originalAttestorPubkey?: string;
+}): Promise<{
+    event: NostrEvent;
+    publish: PublishResult;
+}>;
+/** Send an attestation request as a NIP-17 structured DM */
+export declare function handleTrustRequest(ctx: IdentityContext, pool: RelayPool, args: {
+    recipientPubkeyHex: string;
+    subject: string;
+    attestationType: string;
+    message?: string;
+}): Promise<{
+    event: NostrEvent;
+    publish: PublishResult;
+}>;
+/** Scan NIP-17 DMs for attestation request payloads */
+export declare function handleTrustRequestList(ctx: IdentityContext, pool: RelayPool): Promise<Array<{
+    from: string;
+    subject: string;
+    attestationType: string;
+    message?: string;
+}>>;
+/** Publish a linkage proof as a kind 30078 event. Requires confirmation. */
+export declare function handleTrustProofPublish(ctx: IdentityContext, pool: RelayPool, args: {
+    mode?: 'blind' | 'full';
+    confirm: boolean;
+}): Promise<{
+    event?: NostrEvent;
+    published: boolean;
+    warning?: string;
+    publish?: PublishResult;
+}>;