nostr-bray 1.2.0 → 1.4.0

package/dist/cli.js

@@ -3,7 +3,7 @@ import { loadConfig } from './config.js';
 import { IdentityContext } from './context.js';
 import { RelayPool } from './relay-pool.js';
 import { Nip65Manager } from './nip65.js';
-import { handleSocialPost, handleSocialReply, handleSocialReact, handleSocialProfileGet, handleSocialProfileSet } from './social/handlers.js';
+import { handleSocialPost, handleSocialReply, handleSocialReact, handleSocialProfileGet, handleSocialProfileSet, handleContactsGet, handleContactsFollow, handleContactsUnfollow } from './social/handlers.js';
 import { handleDmSend, handleDmRead } from './social/dm.js';
 import { handleNotifications, handleFeed } from './social/notifications.js';
 import { handleIdentityList, handleIdentityProve, handleIdentityCreate } from './identity/handlers.js';
@@ -47,6 +47,9 @@ Social:
   react <event-id> <pubkey> [emoji]   React to an event
   profile <pubkey-hex>                Fetch a profile
   profile-set <json>                  Set profile (add --confirm to overwrite)
+  contacts <pubkey-hex>               List who a pubkey follows
+  follow <pubkey-hex> [relay] [name]  Follow a pubkey
+  unfollow <pubkey-hex>               Unfollow a pubkey
   dm <pubkey-hex> "message"           Send NIP-17 encrypted DM
   dm-read                             Read received DMs
   feed [--limit N]                    Fetch text note feed
@@ -248,6 +251,21 @@ async function run(cmdArgs) {
             out(await handleSocialProfileSet(ctx, pool, { profile, confirm: hasFlag('confirm') }));
             break;
         }
+        case 'contacts':
+            out(await handleContactsGet(pool, ctx.activeNpub, req(1, 'contacts <pubkey-hex>')));
+            break;
+        case 'follow':
+            out(await handleContactsFollow(ctx, pool, {
+                pubkeyHex: req(1, 'follow <pubkey-hex> [relay] [petname]'),
+                relay: cmdArgs[2],
+                petname: cmdArgs[3],
+            }));
+            break;
+        case 'unfollow':
+            out(await handleContactsUnfollow(ctx, pool, {
+                pubkeyHex: req(1, 'unfollow <pubkey-hex>'),
+            }));
+            break;
         case 'dm':
             out(await handleDmSend(ctx, pool, {
                 recipientPubkeyHex: req(1, 'dm <pubkey-hex> "message"'),
@@ -387,9 +405,31 @@ async function run(cmdArgs) {
     }
 }
 // === Shell mode ===
+const ALL_COMMANDS = [
+    'whoami', 'create', 'list', 'derive', 'persona', 'switch', 'prove', 'proof-publish',
+    'backup', 'restore', 'identity-backup', 'identity-restore', 'migrate',
+    'post', 'reply', 'react', 'profile', 'profile-set', 'contacts', 'follow', 'unfollow', 'dm', 'dm-read', 'feed', 'notifications',
+    'attest', 'trust-read', 'trust-verify', 'trust-revoke', 'trust-request', 'trust-request-list',
+    'ring-prove', 'ring-verify', 'spoken-challenge', 'spoken-verify',
+    'relay-list', 'relay-set', 'relay-add', 'relay-info',
+    'zap-send', 'zap-balance', 'zap-invoice', 'zap-lookup', 'zap-transactions', 'zap-receipts', 'zap-decode',
+    'safety-configure', 'safety-activate',
+    'help', 'exit',
+];
 async function shell() {
     const { createInterface } = await import('node:readline');
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        completer: (line) => {
+            const parts = line.split(/\s+/);
+            if (parts.length <= 1) {
+                const hits = ALL_COMMANDS.filter(c => c.startsWith(line));
+                return [hits.length ? hits : ALL_COMMANDS, line];
+            }
+            return [[], line];
+        },
+    });
     console.log(`nostr-bray shell — ${ctx.activeNpub}`);
     console.log('Type a command, or "help" / "exit".\n');
     const prompt = () => new Promise(resolve => {

package/dist/social/handlers.d.ts

@@ -40,3 +40,20 @@ export declare function handleSocialProfileSet(ctx: IdentityContext, pool: Relay
     profile: Record<string, unknown>;
     confirm?: boolean;
 }): Promise<ProfileSetResult>;
+export interface Contact {
+    pubkey: string;
+    relay?: string;
+    petname?: string;
+}
+/** Fetch the kind 3 contact list for a pubkey */
+export declare function handleContactsGet(pool: RelayPool, npub: string, pubkeyHex: string): Promise<Contact[]>;
+/** Follow a pubkey — fetches current contacts, adds, publishes new kind 3 */
+export declare function handleContactsFollow(ctx: IdentityContext, pool: RelayPool, args: {
+    pubkeyHex: string;
+    relay?: string;
+    petname?: string;
+}): Promise<PostResult>;
+/** Unfollow a pubkey — fetches current contacts, removes, publishes new kind 3 */
+export declare function handleContactsUnfollow(ctx: IdentityContext, pool: RelayPool, args: {
+    pubkeyHex: string;
+}): Promise<PostResult>;

package/dist/social/handlers.js

@@ -105,3 +105,75 @@ export async function handleSocialProfileSet(ctx, pool, args) {
     await pool.publish(ctx.activeNpub, event);
     return { published: true, event };
 }
+/** Fetch the kind 3 contact list for a pubkey */
+export async function handleContactsGet(pool, npub, pubkeyHex) {
+    const events = await pool.query(npub, {
+        kinds: [3],
+        authors: [pubkeyHex],
+    });
+    if (events.length === 0)
+        return [];
+    const best = events.reduce((a, b) => b.created_at > a.created_at ? b : a);
+    return best.tags
+        .filter(t => t[0] === 'p' && t[1])
+        .map(t => ({
+        pubkey: t[1],
+        relay: t[2] || undefined,
+        petname: t[3] || undefined,
+    }));
+}
+/** Follow a pubkey — fetches current contacts, adds, publishes new kind 3 */
+export async function handleContactsFollow(ctx, pool, args) {
+    // Fetch existing contacts
+    const existing = await pool.query(ctx.activeNpub, {
+        kinds: [3],
+        authors: [ctx.activeNpub],
+    });
+    let tags = [];
+    if (existing.length > 0) {
+        const best = existing.reduce((a, b) => b.created_at > a.created_at ? b : a);
+        tags = best.tags.filter(t => t[0] === 'p');
+    }
+    // Don't duplicate
+    if (!tags.some(t => t[1] === args.pubkeyHex)) {
+        const newTag = ['p', args.pubkeyHex];
+        if (args.relay)
+            newTag.push(args.relay);
+        if (args.petname) {
+            if (!args.relay)
+                newTag.push('');
+            newTag.push(args.petname);
+        }
+        tags.push(newTag);
+    }
+    const sign = ctx.getSigningFunction();
+    const event = await sign({
+        kind: 3,
+        created_at: Math.floor(Date.now() / 1000),
+        tags,
+        content: '',
+    });
+    const publish = await pool.publish(ctx.activeNpub, event);
+    return { event, publish };
+}
+/** Unfollow a pubkey — fetches current contacts, removes, publishes new kind 3 */
+export async function handleContactsUnfollow(ctx, pool, args) {
+    const existing = await pool.query(ctx.activeNpub, {
+        kinds: [3],
+        authors: [ctx.activeNpub],
+    });
+    let tags = [];
+    if (existing.length > 0) {
+        const best = existing.reduce((a, b) => b.created_at > a.created_at ? b : a);
+        tags = best.tags.filter(t => t[0] === 'p' && t[1] !== args.pubkeyHex);
+    }
+    const sign = ctx.getSigningFunction();
+    const event = await sign({
+        kind: 3,
+        created_at: Math.floor(Date.now() / 1000),
+        tags,
+        content: '',
+    });
+    const publish = await pool.publish(ctx.activeNpub, event);
+    return { event, publish };
+}

package/dist/social/tools.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { hexId } from '../validation.js';
-import { handleSocialPost, handleSocialReply, handleSocialReact, handleSocialProfileGet, handleSocialProfileSet, } from './handlers.js';
+import { handleSocialPost, handleSocialReply, handleSocialReact, handleSocialProfileGet, handleSocialProfileSet, handleContactsGet, handleContactsFollow, handleContactsUnfollow, } from './handlers.js';
 import { handleDmSend, handleDmRead } from './dm.js';
 import { handleNotifications, handleFeed } from './notifications.js';
 export function registerSocialTools(server, deps) {
@@ -165,4 +165,51 @@ export function registerSocialTools(server, deps) {
             content: [{ type: 'text', text: JSON.stringify(feed, null, 2) }],
         };
     });
+    server.registerTool('contacts_get', {
+        description: 'Fetch the contact list (kind 3 follows) for a pubkey. Returns pubkeys, relay hints, and petnames.',
+        inputSchema: {
+            pubkeyHex: hexId.describe('Hex pubkey to fetch contacts for'),
+            npub: z.string().optional().describe('Bech32 npub for relay routing (defaults to active identity)'),
+        },
+        annotations: { readOnlyHint: true },
+    }, async ({ pubkeyHex, npub }) => {
+        const contacts = await handleContactsGet(deps.pool, npub ?? deps.ctx.activeNpub, pubkeyHex);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(contacts, null, 2) }],
+        };
+    });
+    server.registerTool('contacts_follow', {
+        description: 'Follow a Nostr pubkey. Fetches current contact list, adds the pubkey, publishes updated kind 3.',
+        inputSchema: {
+            pubkeyHex: hexId.describe('Hex pubkey to follow'),
+            relay: z.string().optional().describe('Relay hint for the contact'),
+            petname: z.string().optional().describe('Local petname for the contact'),
+        },
+        annotations: { readOnlyHint: false },
+    }, async ({ pubkeyHex, relay, petname }) => {
+        const result = await handleContactsFollow(deps.ctx, deps.pool, { pubkeyHex, relay, petname });
+        return {
+            content: [{ type: 'text', text: JSON.stringify({
+                        id: result.event.id,
+                        followCount: result.event.tags.filter(t => t[0] === 'p').length,
+                        publish: result.publish,
+                    }, null, 2) }],
+        };
+    });
+    server.registerTool('contacts_unfollow', {
+        description: 'Unfollow a Nostr pubkey. Fetches current contact list, removes the pubkey, publishes updated kind 3.',
+        inputSchema: {
+            pubkeyHex: hexId.describe('Hex pubkey to unfollow'),
+        },
+        annotations: { readOnlyHint: false },
+    }, async ({ pubkeyHex }) => {
+        const result = await handleContactsUnfollow(deps.ctx, deps.pool, { pubkeyHex });
+        return {
+            content: [{ type: 'text', text: JSON.stringify({
+                        id: result.event.id,
+                        followCount: result.event.tags.filter(t => t[0] === 'p').length,
+                        publish: result.publish,
+                    }, null, 2) }],
+        };
+    });
 }

package/package.json

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