nostr-bray 1.9.1 → 1.10.0

package/dist/cli.js

@@ -20,6 +20,7 @@ import { handleDuressConfigure, handleDuressActivate } from './safety/handlers.j
 import { handleZapSend, handleZapBalance, handleZapMakeInvoice, handleZapLookupInvoice, handleZapListTransactions, handleZapReceipts, handleZapDecode } from './zap/handlers.js';
 import { handleDecode, handleEncodeNpub, handleEncodeNote, handleEncodeNprofile, handleEncodeNevent, handleVerify, handleEncrypt, handleDecrypt, handleCount, handleFetch, handleKeyPublic, handleEncodeNsec, handleFilter, handleNipList, handleNipShow } from './util/handlers.js';
 import { getCommandHelp } from './help.js';
+import * as fmt from './format.js';
 const args = process.argv.slice(2);
 const command = args[0];
 // No command = start MCP server
@@ -147,6 +148,10 @@ Quick examples:
   nostr-bray nips                             # browse official NIPs
   nostr-bray shell                            # interactive mode
 
+Flags:
+  --json                              Output raw JSON instead of human-readable
+  --help                              Show help for a command
+
 Use 'nostr-bray <command> --help' for detailed help on any command.
 
 Learn more:
@@ -171,8 +176,16 @@ config.secretKey = '';
 config.nwcUri = undefined;
 const masterRelays = await nip65.loadForIdentity(ctx.activeNpub);
 pool.reconfigure(ctx.activeNpub, masterRelays);
-/** Helper: print JSON result */
-function out(data) { console.log(JSON.stringify(data, null, 2)); }
+const jsonMode = args.includes('--json');
+/** Print JSON (always) or human-readable (default) */
+function out(data, humanFormatter) {
+    if (jsonMode || !humanFormatter) {
+        console.log(JSON.stringify(data, null, 2));
+    }
+    else {
+        console.log(humanFormatter(data));
+    }
+}
 /** Parse a shell line into args, respecting quotes */
 function parseShellLine(line) {
     const result = [];
@@ -232,7 +245,7 @@ async function run(cmdArgs) {
             out(handleIdentityCreate());
             break;
         case 'list':
-            out(handleIdentityList(ctx));
+            out(handleIdentityList(ctx), fmt.formatIdentityList);
             break;
         case 'derive':
             out(ctx.derive(req(1, 'derive <purpose> [index]'), parseInt(cmdArgs[2] ?? '0', 10)));
@@ -284,7 +297,7 @@ async function run(cmdArgs) {
             break;
         // === Social ===
         case 'post':
-            out(await handleSocialPost(ctx, pool, { content: req(1, 'post "message"') }));
+            out(await handleSocialPost(ctx, pool, { content: req(1, 'post "message"') }), fmt.formatPost);
             break;
         case 'reply':
             out(await handleSocialReply(ctx, pool, {
@@ -301,7 +314,7 @@ async function run(cmdArgs) {
             }));
             break;
         case 'profile':
-            out(await handleSocialProfileGet(pool, ctx.activeNpub, req(1, 'profile <pubkey-hex>')));
+            out(await handleSocialProfileGet(pool, ctx.activeNpub, req(1, 'profile <pubkey-hex>')), fmt.formatProfile);
             break;
         case 'profile-set': {
             const profile = JSON.parse(req(1, 'profile-set \'{"name":"..."}\''));
@@ -321,7 +334,7 @@ async function run(cmdArgs) {
             }));
             break;
         case 'contacts':
-            out(await handleContactsGet(pool, ctx.activeNpub, req(1, 'contacts <pubkey-hex>')));
+            out(await handleContactsGet(pool, ctx.activeNpub, req(1, 'contacts <pubkey-hex>')), fmt.formatContacts);
             break;
         case 'follow':
             out(await handleContactsFollow(ctx, pool, {
@@ -344,10 +357,10 @@ async function run(cmdArgs) {
             }));
             break;
         case 'dm-read':
-            out(await handleDmRead(ctx, pool));
+            out(await handleDmRead(ctx, pool), fmt.formatDms);
             break;
         case 'feed':
-            out(await handleFeed(ctx, pool, { limit: parseInt(flag('limit', '20'), 10) }));
+            out(await handleFeed(ctx, pool, { limit: parseInt(flag('limit', '20'), 10) }), fmt.formatFeed);
             break;
         case 'nip-publish': {
             const id = req(1, 'nip-publish <identifier> <title> <content-or-file>');
@@ -370,7 +383,7 @@ async function run(cmdArgs) {
             }));
             break;
         case 'notifications':
-            out(await handleNotifications(ctx, pool, { limit: parseInt(flag('limit', '50'), 10) }));
+            out(await handleNotifications(ctx, pool, { limit: parseInt(flag('limit', '50'), 10) }), fmt.formatNotifications);
             break;
         // === Trust ===
         case 'attest':
@@ -434,7 +447,7 @@ async function run(cmdArgs) {
             break;
         // === Relay ===
         case 'relay-list':
-            out(handleRelayList(ctx, pool, flag('compare')));
+            out(handleRelayList(ctx, pool, flag('compare')), fmt.formatRelays);
             break;
         case 'relay-set': {
             const urls = args.slice(1).filter(a => !a.startsWith('--'));
@@ -477,7 +490,7 @@ async function run(cmdArgs) {
             }));
             break;
         case 'zap-receipts':
-            out(await handleZapReceipts(ctx, pool, { limit: parseInt(flag('limit', '20'), 10) }));
+            out(await handleZapReceipts(ctx, pool, { limit: parseInt(flag('limit', '20'), 10) }), fmt.formatZapReceipts);
             break;
         case 'zap-decode':
             out(handleZapDecode(req(1, 'zap-decode <bolt11>')));
@@ -520,7 +533,7 @@ async function run(cmdArgs) {
             out(await handleGroupChat(pool, ctx.activeNpub, {
                 groupId: req(1, 'group-chat <group-id>'),
                 limit: parseInt(flag('limit', '20'), 10),
-            }));
+            }), fmt.formatGroupChat);
             break;
         case 'group-send':
             out(await handleGroupSend(ctx, pool, {
@@ -535,7 +548,7 @@ async function run(cmdArgs) {
             break;
         // === Utility ===
         case 'decode':
-            out(handleDecode(req(1, 'decode <nip19>')));
+            out(handleDecode(req(1, 'decode <nip19>')), fmt.formatDecode);
             break;
         case 'encode-npub':
             console.log(handleEncodeNpub(req(1, 'encode-npub <hex>')));
@@ -563,7 +576,7 @@ async function run(cmdArgs) {
             out(handleFilter(JSON.parse(req(1, 'filter <event-json> <filter-json>')), JSON.parse(req(2, 'filter <event-json> <filter-json>'))));
             break;
         case 'nips':
-            out(await handleNipList());
+            out(await handleNipList(), fmt.formatNipList);
             break;
         case 'nip': {
             const num = parseInt(req(1, 'nip <number>'), 10);

package/dist/context.d.ts

@@ -24,8 +24,11 @@ export declare class IdentityContext {
     getSigningFunction(): SignFn;
     /** List all known identities — returns public info only, never private keys */
     listIdentities(): PublicIdentity[];
-    /** Create a linkage proof for the active identity */
+    /** Create a linkage proof for the active identity.
+     *  Only works for derived identities — the master IS the raw key, not a tree child. */
     prove(mode?: 'blind' | 'full'): LinkageProof;
+    /** Get the nsec-tree root's master pubkey (the derivation anchor, distinct from the raw key's pubkey) */
+    get treeRootPubkey(): string;
     /** Get the active identity's private key for NIP-17/44/04 crypto operations */
     get activePrivateKey(): Uint8Array;
     /** Test helper — returns reference to private key bytes for verifying zeroise */

package/dist/context.js

@@ -1,7 +1,21 @@
 import { fromNsec, fromMnemonic, derive, zeroise } from 'nsec-tree';
 import { derivePersona } from 'nsec-tree/persona';
 import { createBlindProof, createFullProof } from 'nsec-tree/proof';
-import { finalizeEvent } from 'nostr-tools/pure';
+import { finalizeEvent, getPublicKey } from 'nostr-tools/pure';
+import { decode, npubEncode, nsecEncode } from 'nostr-tools/nip19';
+/** Build an Identity-compatible object from raw key bytes */
+function rawIdentity(privateKey) {
+    const publicKeyHex = getPublicKey(privateKey);
+    const publicKey = Buffer.from(publicKeyHex, 'hex');
+    return {
+        nsec: nsecEncode(privateKey),
+        npub: npubEncode(publicKeyHex),
+        privateKey: new Uint8Array(privateKey), // copy so original can be cleaned
+        publicKey: new Uint8Array(publicKey),
+        purpose: 'master',
+        index: 0,
+    };
+}
 export class IdentityContext {
     root;
     cache = new Map();
@@ -10,25 +24,33 @@ export class IdentityContext {
     maxCacheSize;
     constructor(secretKey, format, opts) {
         this.maxCacheSize = opts?.maxCache ?? 5;
+        // Parse the raw secret key bytes — this IS the user's actual Nostr identity
+        let rawKeyBytes;
         if (format === 'mnemonic') {
+            // Mnemonic: create tree root, derive a "default" identity as master
             this.root = fromMnemonic(secretKey);
+            const derived = derive(this.root, 'master', 0);
+            this.masterEntry = { identity: derived, purpose: 'master', index: 0, lastUsed: Date.now() };
+            this.activeEntry = this.masterEntry;
+            return;
         }
         else if (format === 'hex') {
-            const bytes = Buffer.from(secretKey, 'hex');
-            this.root = fromNsec(bytes);
+            rawKeyBytes = Buffer.from(secretKey, 'hex');
         }
         else {
-            this.root = fromNsec(secretKey);
+            // nsec bech32
+            rawKeyBytes = decode(secretKey).data;
         }
-        // Derive master identity — kept separate from LRU cache
-        const masterIdentity = derive(this.root, 'master', 0);
+        // Master identity = the user's actual keypair (their real npub)
         this.masterEntry = {
-            identity: masterIdentity,
+            identity: rawIdentity(rawKeyBytes),
             purpose: 'master',
             index: 0,
             lastUsed: Date.now(),
         };
         this.activeEntry = this.masterEntry;
+        // nsec-tree root for child derivation
+        this.root = fromNsec(rawKeyBytes);
     }
     /** Current active identity's npub (bech32) */
     get activeNpub() {
@@ -131,14 +153,22 @@ export class IdentityContext {
         }
         return result;
     }
-    /** Create a linkage proof for the active identity */
+    /** Create a linkage proof for the active identity.
+     *  Only works for derived identities — the master IS the raw key, not a tree child. */
     prove(mode = 'blind') {
+        if (this.activeEntry === this.masterEntry) {
+            throw new Error('Cannot prove master identity — it is the raw key, not a derived child. Switch to a derived identity first.');
+        }
         const child = this.activeEntry.identity;
         if (mode === 'full') {
             return createFullProof(this.root, child);
         }
         return createBlindProof(this.root, child);
     }
+    /** Get the nsec-tree root's master pubkey (the derivation anchor, distinct from the raw key's pubkey) */
+    get treeRootPubkey() {
+        return this.root.masterPubkey;
+    }
     /** Get the active identity's private key for NIP-17/44/04 crypto operations */
     get activePrivateKey() {
         return this.activeEntry.identity.privateKey;

package/dist/format.d.ts

@@ -0,0 +1,30 @@
+/** Human-readable formatters for CLI output */
+import type { PublicIdentity } from './types.js';
+export declare function formatIdentity(id: PublicIdentity): string;
+export declare function formatIdentityList(ids: PublicIdentity[]): string;
+export declare function formatPost(result: any): string;
+export declare function formatPublish(result: any): string;
+export declare function formatProfile(profile: Record<string, unknown>): string;
+export declare function formatContacts(contacts: Array<{
+    pubkey: string;
+    relay?: string;
+    petname?: string;
+}>): string;
+export declare function formatNotifications(notifications: any[]): string;
+export declare function formatFeed(events: any[]): string;
+export declare function formatDms(dms: any[]): string;
+export declare function formatRelays(relays: {
+    read: string[];
+    write: string[];
+    sharedWarning?: string;
+}): string;
+export declare function formatZapReceipts(receipts: any[]): string;
+export declare function formatGroupChat(messages: any[]): string;
+export declare function formatNipList(nips: Array<{
+    number: number;
+    title: string;
+}>): string;
+export declare function formatDecode(result: {
+    type: string;
+    data: unknown;
+}): string;

package/dist/format.js

@@ -0,0 +1,153 @@
+/** Human-readable formatters for CLI output */
+export function formatIdentity(id) {
+    let line = `${id.npub}`;
+    if (id.personaName)
+        line += `  (persona: ${id.personaName})`;
+    else if (id.purpose)
+        line += `  (${id.purpose}${id.index ? ` #${id.index}` : ''})`;
+    return line;
+}
+export function formatIdentityList(ids) {
+    if (ids.length === 0)
+        return 'No identities found.';
+    const lines = ids.map((id, i) => {
+        const marker = i === 0 ? '* ' : '  ';
+        return `${marker}${formatIdentity(id)}`;
+    });
+    return lines.join('\n');
+}
+export function formatPost(result) {
+    const status = result.publish?.success ? '✓' : '✗';
+    return `${status} ${result.event?.id?.slice(0, 12)}... published to ${result.publish?.accepted?.length ?? 0} relay(s)`;
+}
+export function formatPublish(result) {
+    const status = result.publish?.success ? '✓ Published' : '✗ Failed';
+    const relays = result.publish?.accepted?.length ?? 0;
+    return `${status} (${relays} relay${relays !== 1 ? 's' : ''})`;
+}
+export function formatProfile(profile) {
+    if (Object.keys(profile).length === 0)
+        return 'No profile found.';
+    const lines = [];
+    if (profile.name)
+        lines.push(`Name:    ${profile.name}`);
+    if (profile.display_name)
+        lines.push(`Display: ${profile.display_name}`);
+    if (profile.about)
+        lines.push(`About:   ${profile.about}`);
+    if (profile.nip05)
+        lines.push(`NIP-05:  ${profile.nip05}`);
+    if (profile.lud16)
+        lines.push(`LN:      ${profile.lud16}`);
+    if (profile.picture)
+        lines.push(`Picture: ${profile.picture}`);
+    if (profile.banner)
+        lines.push(`Banner:  ${profile.banner}`);
+    return lines.join('\n');
+}
+export function formatContacts(contacts) {
+    if (contacts.length === 0)
+        return 'No contacts found.';
+    const lines = contacts.map(c => {
+        let line = c.pubkey.slice(0, 12) + '...';
+        if (c.petname)
+            line += `  ${c.petname}`;
+        if (c.relay)
+            line += `  (${c.relay})`;
+        return line;
+    });
+    return `${contacts.length} contacts:\n${lines.join('\n')}`;
+}
+export function formatNotifications(notifications) {
+    if (notifications.length === 0)
+        return 'No notifications.';
+    return notifications.map(n => {
+        const time = new Date(n.createdAt * 1000).toLocaleString();
+        const from = n.from?.slice(0, 12) + '...';
+        switch (n.type) {
+            case 'reply':
+                return `💬 ${from} replied: ${n.content?.slice(0, 80)}  (${time})`;
+            case 'reaction':
+                return `${n.content === '+' ? '❤️' : n.content} ${from} reacted  (${time})`;
+            case 'mention':
+                return `@  ${from} mentioned you: ${n.content?.slice(0, 80)}  (${time})`;
+            case 'zap':
+                const sats = n.amountMsats ? `${Math.round(n.amountMsats / 1000)} sats` : 'zap';
+                return `⚡ ${n.zapSender?.slice(0, 12) ?? from}... zapped ${sats}${n.zapMessage ? `: ${n.zapMessage}` : ''}  (${time})`;
+            default:
+                return `${n.type} from ${from}  (${time})`;
+        }
+    }).join('\n');
+}
+export function formatFeed(events) {
+    if (events.length === 0)
+        return 'No posts found.';
+    return events.map(e => {
+        const time = new Date(e.createdAt * 1000).toLocaleString();
+        const author = e.pubkey?.slice(0, 12) + '...';
+        return `${author}  ${time}\n  ${e.content?.slice(0, 200)}\n`;
+    }).join('\n');
+}
+export function formatDms(dms) {
+    if (dms.length === 0)
+        return 'No messages.';
+    return dms.map(dm => {
+        const time = new Date(dm.createdAt * 1000).toLocaleString();
+        const from = dm.from?.slice(0, 12) + '...';
+        const proto = dm.protocol === 'nip04-deprecated' ? ' [NIP-04]' : '';
+        if (!dm.decrypted)
+            return `✗ ${from}  Could not decrypt${proto}  (${time})`;
+        return `${from}${proto}  ${time}\n  ${dm.content}`;
+    }).join('\n\n');
+}
+export function formatRelays(relays) {
+    const lines = [];
+    if (relays.read.length > 0) {
+        lines.push('Read:');
+        relays.read.forEach(r => lines.push(`  ${r}`));
+    }
+    if (relays.write.length > 0) {
+        lines.push('Write:');
+        relays.write.forEach(r => lines.push(`  ${r}`));
+    }
+    if (relays.sharedWarning)
+        lines.push(`\n⚠️  ${relays.sharedWarning}`);
+    return lines.join('\n');
+}
+export function formatZapReceipts(receipts) {
+    if (receipts.length === 0)
+        return 'No zap receipts.';
+    return receipts.map(r => {
+        const time = new Date(r.createdAt * 1000).toLocaleString();
+        const sats = r.amountMsats ? `${Math.round(r.amountMsats / 1000)} sats` : '? sats';
+        const from = r.sender ? r.sender.slice(0, 12) + '...' : 'unknown';
+        return `⚡ ${sats} from ${from}${r.message ? ` — ${r.message}` : ''}  (${time})`;
+    }).join('\n');
+}
+export function formatGroupChat(messages) {
+    if (messages.length === 0)
+        return 'No messages.';
+    return messages.map(m => {
+        const time = new Date(m.createdAt * 1000).toLocaleString();
+        const author = m.pubkey?.slice(0, 12) + '...';
+        return `${author}  ${time}\n  ${m.content}`;
+    }).join('\n\n');
+}
+export function formatNipList(nips) {
+    return nips.map(n => `NIP-${String(n.number).padStart(2, '0')}  ${n.title}`).join('\n');
+}
+export function formatDecode(result) {
+    const lines = [`Type: ${result.type}`];
+    if (typeof result.data === 'string') {
+        lines.push(`Data: ${result.data}`);
+    }
+    else if (typeof result.data === 'object' && result.data !== null) {
+        for (const [k, v] of Object.entries(result.data)) {
+            if (Array.isArray(v))
+                lines.push(`${k}: ${v.join(', ')}`);
+            else
+                lines.push(`${k}: ${v}`);
+        }
+    }
+    return lines.join('\n');
+}

package/dist/identity/migration.js

@@ -67,18 +67,23 @@ export async function handleIdentityMigrate(ctx, pool, args) {
     }
     // Execute migration: re-sign migratable events
     await handleIdentityRestore(ctx, pool, backup);
-    // Publish linkage proof connecting old → new
-    const proof = ctx.prove('full');
-    const sign = ctx.getSigningFunction();
-    const proofEvent = await sign({
-        kind: 30078,
-        created_at: Math.floor(Date.now() / 1000),
-        tags: [
-            ['d', `migration:${args.oldPubkeyHex}`],
-            ['p', args.oldPubkeyHex],
-        ],
-        content: JSON.stringify(proof),
-    });
-    await pool.publish(args.oldNpub, proofEvent);
+    // Publish linkage proof connecting old → new (only if operating as a derived identity)
+    try {
+        const proof = ctx.prove('full');
+        const sign = ctx.getSigningFunction();
+        const proofEvent = await sign({
+            kind: 30078,
+            created_at: Math.floor(Date.now() / 1000),
+            tags: [
+                ['d', `migration:${args.oldPubkeyHex}`],
+                ['p', args.oldPubkeyHex],
+            ],
+            content: JSON.stringify(proof),
+        });
+        await pool.publish(args.oldNpub, proofEvent);
+    }
+    catch {
+        // Master identity can't produce tree proofs — migration proceeds without linkage proof
+    }
     return { status: 'migrated', summary };
 }

package/package.json

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