nostr-bray 1.13.0 → 1.14.0

package/dist/bunker.d.ts

@@ -0,0 +1,25 @@
+/**
+ * NIP-46 Bunker — remote signing daemon.
+ *
+ * Holds the user's secret key and responds to signing requests from
+ * authorised clients over Nostr relays. Clients never see the nsec.
+ *
+ * Protocol: NIP-46 (Nostr Connect)
+ * - Client sends kind 24133 encrypted request
+ * - Bunker responds with kind 24133 encrypted response
+ * - All communication NIP-44 encrypted between client and bunker
+ */
+import type { IdentityContext } from './context.js';
+export interface BunkerOptions {
+    ctx: IdentityContext;
+    relays: string[];
+    authorizedKeys?: string[];
+    quiet?: boolean;
+}
+export interface BunkerInstance {
+    url: string;
+    pubkey: string;
+    npub: string;
+    close: () => void;
+}
+export declare function startBunker(opts: BunkerOptions): BunkerInstance;

package/dist/bunker.js

@@ -0,0 +1,140 @@
+/**
+ * NIP-46 Bunker — remote signing daemon.
+ *
+ * Holds the user's secret key and responds to signing requests from
+ * authorised clients over Nostr relays. Clients never see the nsec.
+ *
+ * Protocol: NIP-46 (Nostr Connect)
+ * - Client sends kind 24133 encrypted request
+ * - Bunker responds with kind 24133 encrypted response
+ * - All communication NIP-44 encrypted between client and bunker
+ */
+import { getConversationKey, encrypt, decrypt } from 'nostr-tools/nip44';
+import { finalizeEvent, getPublicKey, generateSecretKey } from 'nostr-tools/pure';
+import { npubEncode } from 'nostr-tools/nip19';
+import { useWebSocketImplementation, SimplePool } from 'nostr-tools/pool';
+import WebSocket from 'ws';
+useWebSocketImplementation(WebSocket);
+export function startBunker(opts) {
+    const { ctx, relays, quiet } = opts;
+    const authorizedKeys = new Set(opts.authorizedKeys ?? []);
+    const log = quiet ? () => { } : (...args) => console.error('[bunker]', ...args);
+    // Generate a bunker-specific keypair for NIP-46 communication
+    const bunkerSk = generateSecretKey();
+    const bunkerPk = getPublicKey(bunkerSk);
+    const bunkerNpub = npubEncode(bunkerPk);
+    const pool = new SimplePool();
+    // Subscribe to kind 24133 events addressed to us
+    const sub = pool.subscribeMany(relays, { kinds: [24133], '#p': [bunkerPk] }, {
+        onevent: async (event) => {
+            try {
+                await handleRequest(event);
+            }
+            catch (e) {
+                log(`Error handling request: ${e.message}`);
+            }
+        },
+    });
+    async function handleRequest(event) {
+        const clientPk = event.pubkey;
+        // Check authorization
+        if (authorizedKeys.size > 0 && !authorizedKeys.has(clientPk)) {
+            log(`Rejected request from unauthorized key: ${clientPk.slice(0, 12)}...`);
+            return;
+        }
+        // Decrypt the request
+        const conversationKey = getConversationKey(bunkerSk, clientPk);
+        let request;
+        try {
+            const plaintext = decrypt(event.content, conversationKey);
+            request = JSON.parse(plaintext);
+        }
+        catch {
+            log('Failed to decrypt request');
+            return;
+        }
+        log(`Request ${request.id}: ${request.method}`);
+        let result;
+        let error;
+        switch (request.method) {
+            case 'connect':
+                result = 'ack';
+                break;
+            case 'ping':
+                result = 'pong';
+                break;
+            case 'get_public_key':
+                result = ctx.activePublicKeyHex;
+                break;
+            case 'sign_event': {
+                const template = JSON.parse(request.params[0]);
+                const sign = ctx.getSigningFunction();
+                const signed = await sign(template);
+                result = JSON.stringify(signed);
+                break;
+            }
+            case 'nip04_encrypt': {
+                const [thirdPartyPk, plaintext] = request.params;
+                const { encrypt: nip04encrypt } = await import('nostr-tools/nip04');
+                result = nip04encrypt(ctx.activePrivateKey, thirdPartyPk, plaintext);
+                break;
+            }
+            case 'nip04_decrypt': {
+                const [thirdPartyPk, ciphertext] = request.params;
+                const { decrypt: nip04decrypt } = await import('nostr-tools/nip04');
+                result = nip04decrypt(ctx.activePrivateKey, thirdPartyPk, ciphertext);
+                break;
+            }
+            case 'nip44_encrypt': {
+                const [thirdPartyPk, plaintext] = request.params;
+                const ck = getConversationKey(ctx.activePrivateKey, thirdPartyPk);
+                result = encrypt(plaintext, ck);
+                break;
+            }
+            case 'nip44_decrypt': {
+                const [thirdPartyPk, ciphertext] = request.params;
+                const ck = getConversationKey(ctx.activePrivateKey, thirdPartyPk);
+                result = decrypt(ciphertext, ck);
+                break;
+            }
+            default:
+                result = '';
+                error = `unsupported method: ${request.method}`;
+        }
+        // Encrypt and send response
+        const response = error
+            ? JSON.stringify({ id: request.id, result: '', error })
+            : JSON.stringify({ id: request.id, result });
+        const encrypted = encrypt(response, conversationKey);
+        const responseEvent = finalizeEvent({
+            kind: 24133,
+            created_at: Math.floor(Date.now() / 1000),
+            tags: [['p', clientPk]],
+            content: encrypted,
+        }, bunkerSk);
+        await Promise.any(pool.publish(relays, responseEvent));
+        log(`Response ${request.id}: ${error ?? 'ok'}`);
+    }
+    // Build bunker:// URI
+    const relayParams = relays.map(r => `relay=${encodeURIComponent(r)}`).join('&');
+    const bunkerUrl = `bunker://${bunkerPk}?${relayParams}`;
+    log(`Bunker started: ${bunkerNpub}`);
+    log(`URI: ${bunkerUrl}`);
+    log(`Signing as: ${ctx.activeNpub}`);
+    if (authorizedKeys.size > 0) {
+        log(`Authorized keys: ${authorizedKeys.size}`);
+    }
+    else {
+        log('WARNING: No authorized keys set — accepting requests from anyone');
+    }
+    return {
+        url: bunkerUrl,
+        pubkey: bunkerPk,
+        npub: bunkerNpub,
+        close: () => {
+            sub.close();
+            pool.destroy();
+            bunkerSk.fill(0);
+        },
+    };
+}

package/dist/cli.js

@@ -19,6 +19,7 @@ import { handleTrustSpokenChallenge, handleTrustSpokenVerify } from './trust/spo
 import { handleDuressConfigure, handleDuressActivate } from './safety/handlers.js';
 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 { handleKeyEncrypt, handleKeyDecrypt } from './util/ncryptsec.js';
 import { getCommandHelp } from './help.js';
 import * as fmt from './format.js';
 const args = process.argv.slice(2);
@@ -28,6 +29,30 @@ if (!command) {
     await import('./index.js');
     process.exit(0);
 }
+// Bunker = NIP-46 remote signer
+if (command === 'bunker' && !args.includes('--help')) {
+    const { startBunker } = await import('./bunker.js');
+    const config = (await import('./config.js')).loadConfig();
+    const { IdentityContext: IC } = await import('./context.js');
+    const bCtx = new IC(config.secretKey, config.secretFormat);
+    config.secretKey = '';
+    const authorizedKeys = args.includes('--authorized-keys')
+        ? args[args.indexOf('--authorized-keys') + 1].split(',')
+        : undefined;
+    const bunker = startBunker({
+        ctx: bCtx,
+        relays: config.relays,
+        authorizedKeys,
+        quiet: args.includes('--quiet'),
+    });
+    console.error(`nostr-bray bunker running`);
+    console.error(`URI: ${bunker.url}`);
+    console.error(`Signing as: ${bCtx.activeNpub}`);
+    console.error('Press Ctrl+C to stop');
+    process.on('SIGINT', () => { bunker.close(); bCtx.destroy(); process.exit(0); });
+    process.on('SIGTERM', () => { bunker.close(); bCtx.destroy(); process.exit(0); });
+    await new Promise(() => { });
+}
 // Serve = in-memory test relay
 if (command === 'serve' && !args.includes('--help')) {
     const { startRelay } = await import('./serve.js');
@@ -133,6 +158,8 @@ Utility:
   encode-nevent <hex> [relay,...]     Encode event ID + relays as nevent
   encode-nsec <hex>                   Encode hex private key as nsec
   key-public <nsec-or-hex>            Derive pubkey from secret key
+  key-encrypt <nsec-or-hex> <pass>    Encrypt key as ncryptsec (NIP-49)
+  key-decrypt <ncryptsec> <pass>      Decrypt ncryptsec to verify pubkey
   filter <event-json> <filter-json>   Test if event matches filter
   nips                                List all official NIPs
   nip <number>                        Show a specific NIP
@@ -145,6 +172,7 @@ Utility:
 Modes:
   (no command)                        Start MCP server (stdio)
   serve [--port N] [--events file]    Start in-memory test relay
+  bunker [--authorized-keys pk,pk]    Start NIP-46 remote signer daemon
   shell                               Interactive REPL (persistent relay connection)
 
 Environment:
@@ -601,6 +629,12 @@ async function run(cmdArgs) {
         case 'key-public':
             out(handleKeyPublic(req(1, 'key-public <nsec-or-hex>')));
             break;
+        case 'key-encrypt':
+            out(handleKeyEncrypt(req(1, 'key-encrypt <nsec-or-hex> <password>'), req(2, 'key-encrypt <nsec-or-hex> <password>')));
+            break;
+        case 'key-decrypt':
+            out(handleKeyDecrypt(req(1, 'key-decrypt <ncryptsec> <password>'), req(2, 'key-decrypt <ncryptsec> <password>')));
+            break;
         case 'filter':
             out(handleFilter(JSON.parse(req(1, 'filter <event-json> <filter-json>')), JSON.parse(req(2, 'filter <event-json> <filter-json>'))));
             break;
@@ -660,7 +694,8 @@ const ALL_COMMANDS = [
     'blossom-upload', 'blossom-list', 'blossom-delete',
     'group-info', 'group-chat', 'group-send', 'group-members',
     'decode', 'encode-npub', 'encode-note', 'encode-nprofile', 'encode-nevent', 'encode-nsec',
-    'key-public', 'filter', 'nips', 'nip', 'verify', 'encrypt', 'decrypt', 'count', 'fetch',
+    'key-public', 'key-encrypt', 'key-decrypt', 'filter', 'nips', 'nip', 'verify', 'encrypt', 'decrypt', 'count', 'fetch',
+    'bunker',
     'help', 'exit',
 ];
 async function shell() {

package/dist/help.js

@@ -84,6 +84,9 @@ export const COMMAND_HELP = {
     count: { usage: 'count [--kinds N,N] [--authors X,X] [--since N]', description: 'Count events matching a filter on relays.', examples: ['nostr-bray count --kinds 1', 'nostr-bray count --kinds 1,7 --authors abc123...'] },
     fetch: { usage: 'fetch <nip19>', description: 'Fetch events by nip19 code (note, nevent, nprofile, npub, naddr). Resolves the entity and queries relays.', examples: ['nostr-bray fetch note1...', 'nostr-bray fetch nevent1...', 'nostr-bray fetch npub1...'] },
     shell: { usage: 'shell', description: 'Start an interactive REPL with a persistent relay connection. Supports tab autocomplete. Type "help" for commands, "exit" to quit.', examples: ['nostr-bray shell'] },
+    'key-encrypt': { usage: 'key-encrypt <nsec-or-hex> <password>', description: 'Encrypt a secret key with a password using NIP-49. Returns an ncryptsec string safe for storage. Also returns the derived pubkey for verification.', examples: ['nostr-bray key-encrypt nsec1... mypassword'], notes: 'WARNING: secret key is passed as a CLI argument. Use only on trusted systems.' },
+    'key-decrypt': { usage: 'key-decrypt <ncryptsec> <password>', description: 'Decrypt an ncryptsec (NIP-49) with a password. Returns the pubkey for verification — never the raw secret key.', examples: ['nostr-bray key-decrypt ncryptsec1... mypassword'] },
+    bunker: { usage: 'bunker [--authorized-keys pk1,pk2] [--quiet]', description: 'Start a NIP-46 remote signer daemon. Holds your secret key and responds to signing requests from authorised clients over Nostr relays. Clients never see your nsec.', examples: ['nostr-bray bunker', 'nostr-bray bunker --authorized-keys abc123...,def456...', 'nostr-bray bunker --quiet'], notes: 'Without --authorized-keys, accepts requests from anyone. Set authorized keys for production use.' },
     serve: { usage: 'serve [--port N] [--hostname H] [--events file.jsonl] [--quiet]', description: 'Start an in-memory Nostr relay for testing. Implements NIP-01 (events, subscriptions, EOSE) and NIP-11 (relay info). Events live in memory only — no persistence. Optionally pre-load events from a JSONL file.', examples: ['nostr-bray serve', 'nostr-bray serve --port 7777', 'nostr-bray serve --events test-data.jsonl', 'nostr-bray serve --port 7777 --quiet'] },
 };
 /** Get formatted help for a single command */

package/dist/util/ncryptsec.d.ts

@@ -0,0 +1,17 @@
+/**
+ * NIP-49 ncryptsec — password-encrypted secret keys.
+ *
+ * Encrypt an nsec with a passphrase for safe storage.
+ * Decrypt an ncryptsec back to the raw key.
+ */
+/** Encrypt a secret key (nsec or hex) with a password. Returns ncryptsec string. */
+export declare function handleKeyEncrypt(secret: string, password: string): {
+    ncryptsec: string;
+    pubkeyHex: string;
+    npub: string;
+};
+/** Decrypt an ncryptsec with a password. Returns the derived pubkey (never the raw key). */
+export declare function handleKeyDecrypt(ncryptsec: string, password: string): {
+    pubkeyHex: string;
+    npub: string;
+};

package/dist/util/ncryptsec.js

@@ -0,0 +1,39 @@
+/**
+ * NIP-49 ncryptsec — password-encrypted secret keys.
+ *
+ * Encrypt an nsec with a passphrase for safe storage.
+ * Decrypt an ncryptsec back to the raw key.
+ */
+import { encrypt, decrypt } from 'nostr-tools/nip49';
+import { decode } from 'nostr-tools/nip19';
+import { getPublicKey } from 'nostr-tools/pure';
+import { npubEncode } from 'nostr-tools/nip19';
+/** Encrypt a secret key (nsec or hex) with a password. Returns ncryptsec string. */
+export function handleKeyEncrypt(secret, password) {
+    let bytes;
+    if (secret.startsWith('nsec1')) {
+        bytes = decode(secret).data;
+    }
+    else {
+        bytes = Buffer.from(secret, 'hex');
+    }
+    try {
+        const ncryptsec = encrypt(bytes, password);
+        const pubkeyHex = getPublicKey(bytes);
+        return { ncryptsec, pubkeyHex, npub: npubEncode(pubkeyHex) };
+    }
+    finally {
+        bytes.fill(0);
+    }
+}
+/** Decrypt an ncryptsec with a password. Returns the derived pubkey (never the raw key). */
+export function handleKeyDecrypt(ncryptsec, password) {
+    const bytes = decrypt(ncryptsec, password);
+    try {
+        const pubkeyHex = getPublicKey(bytes);
+        return { pubkeyHex, npub: npubEncode(pubkeyHex) };
+    }
+    finally {
+        bytes.fill(0);
+    }
+}

package/dist/util/tools.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { hexId } from '../validation.js';
+import { handleKeyEncrypt, handleKeyDecrypt } from './ncryptsec.js';
 import { handleDecode, handleEncodeNpub, handleEncodeNote, handleEncodeNprofile, handleEncodeNevent, handleEncodeNaddr, handleVerify, handleEncrypt, handleDecrypt, handleCount, handleFetch, handleKeyPublic, handleEncodeNsec, handleFilter, handleNipList, handleNipShow, } from './handlers.js';
 export function registerUtilTools(server, deps) {
     server.registerTool('decode', {
@@ -167,4 +168,26 @@ export function registerUtilTools(server, deps) {
         const nip = await handleNipShow(number);
         return { content: [{ type: 'text', text: nip.content }] };
     });
+    server.registerTool('key_encrypt', {
+        description: 'Encrypt a secret key with a password (NIP-49 ncryptsec). Returns the ncryptsec string and the derived pubkey. WARNING: secret key is transmitted through the MCP transport.',
+        inputSchema: {
+            secret: z.string().describe('Secret key (nsec or hex)'),
+            password: z.string().describe('Password to encrypt with'),
+        },
+        annotations: { readOnlyHint: true },
+    }, async ({ secret, password }) => {
+        const result = handleKeyEncrypt(secret, password);
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    });
+    server.registerTool('key_decrypt', {
+        description: 'Decrypt an ncryptsec (NIP-49) with a password. Returns the derived pubkey for verification — never the raw key.',
+        inputSchema: {
+            ncryptsec: z.string().describe('ncryptsec string to decrypt'),
+            password: z.string().describe('Password used during encryption'),
+        },
+        annotations: { readOnlyHint: true },
+    }, async ({ ncryptsec, password }) => {
+        const result = handleKeyDecrypt(ncryptsec, password);
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    });
 }

package/package.json

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