nostr-bray 1.26.0 → 1.27.0

package/dist/bunker-context.d.ts

@@ -20,6 +20,8 @@ export interface BunkerConfig {
 }
 /** Parse a bunker:// URI */
 export declare function parseBunkerUri(uri: string): BunkerConfig;
+/** Resolve the client secret key: URI secret > cached > generate & persist. */
+export declare function resolveClientKey(config: BunkerConfig, stateDir?: string): Uint8Array;
 export declare class BunkerContext implements SigningContext {
     protected signer: BunkerSigner;
     protected pool: SimplePool;

package/dist/bunker-context.js

@@ -14,6 +14,7 @@ import { useWebSocketImplementation, SimplePool } from 'nostr-tools/pool';
 import { generateSecretKey } from 'nostr-tools/pure';
 import { npubEncode } from 'nostr-tools/nip19';
 import WebSocket from 'ws';
+import { readStateFile, writeStateFile } from './state.js';
 useWebSocketImplementation(WebSocket);
 /** Parse a bunker:// URI */
 export function parseBunkerUri(uri) {
@@ -27,6 +28,21 @@ export function parseBunkerUri(uri) {
     }
     return { pubkey, relays, secret };
 }
+const CLIENT_KEYS_FILE = 'client-keys.json';
+/** Resolve the client secret key: URI secret > cached > generate & persist. */
+export function resolveClientKey(config, stateDir) {
+    if (config.secret) {
+        return Buffer.from(config.secret, 'hex');
+    }
+    const cache = readStateFile(CLIENT_KEYS_FILE, stateDir);
+    if (cache[config.pubkey]) {
+        return Buffer.from(cache[config.pubkey], 'hex');
+    }
+    const sk = generateSecretKey();
+    cache[config.pubkey] = Buffer.from(sk).toString('hex');
+    writeStateFile(CLIENT_KEYS_FILE, cache, stateDir);
+    return sk;
+}
 export class BunkerContext {
     signer;
     pool;
@@ -40,9 +56,7 @@ export class BunkerContext {
     /** Connect to a remote bunker. Blocks until the connection is established. */
     static async connect(uri, timeoutMs = 15_000) {
         const config = parseBunkerUri(uri);
-        const clientSk = config.secret
-            ? Buffer.from(config.secret, 'hex')
-            : generateSecretKey();
+        const clientSk = resolveClientKey(config);
         const pool = new SimplePool();
         const signer = BunkerSigner.fromBunker(clientSk, { pubkey: config.pubkey, relays: config.relays, secret: null }, { pool });
         // Connect and verify

package/dist/bunker.d.ts

@@ -17,6 +17,7 @@ export interface BunkerOptions {
     bunkerKeyHex?: string;
     quiet?: boolean;
     heartwoodExtensions?: boolean;
+    stateDir?: string;
 }
 export interface BunkerInstance {
     url: string;

package/dist/bunker.js

@@ -14,17 +14,26 @@ 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';
+import { readStateFile, writeStateFile } from './state.js';
 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);
-    // Use persistent key if provided, otherwise generate ephemeral
+    // Bunker keypair — must be computed first so we can load persisted approvals
     const bunkerSk = opts.bunkerKeyHex
         ? Buffer.from(opts.bunkerKeyHex, 'hex')
         : generateSecretKey();
     const bunkerPk = getPublicKey(bunkerSk);
     const bunkerNpub = npubEncode(bunkerPk);
+    // Authorised clients: CLI flag controls the gate, persisted approvals supplement
+    const APPROVALS_FILE = 'approved-clients.json';
+    const persisted = readStateFile(APPROVALS_FILE, opts.stateDir);
+    const bunkerApprovals = persisted[bunkerPk] ?? [];
+    const cliAuthorizedKeys = new Set(opts.authorizedKeys ?? []);
+    const authorizedKeys = new Set([
+        ...cliAuthorizedKeys,
+        ...bunkerApprovals,
+    ]);
     const pool = new SimplePool();
     // Subscribe to kind 24133 events addressed to us
     const sub = pool.subscribeMany(relays, { kinds: [24133], '#p': [bunkerPk] }, {
@@ -39,8 +48,8 @@ export function startBunker(opts) {
     });
     async function handleRequest(event) {
         const clientPk = event.pubkey;
-        // Check authorization
-        if (authorizedKeys.size > 0 && !authorizedKeys.has(clientPk)) {
+        // Check authorization — gate only activates when CLI --authorized-keys were set
+        if (cliAuthorizedKeys.size > 0 && !authorizedKeys.has(clientPk)) {
             log(`Rejected request from unauthorized key: ${clientPk.slice(0, 12)}...`);
             return;
         }
@@ -60,6 +69,15 @@ export function startBunker(opts) {
         let error;
         switch (request.method) {
             case 'connect':
+                // Persist newly-approved client
+                if (!bunkerApprovals.includes(clientPk)) {
+                    bunkerApprovals.push(clientPk);
+                    authorizedKeys.add(clientPk);
+                    const current = readStateFile(APPROVALS_FILE, opts.stateDir);
+                    current[bunkerPk] = bunkerApprovals;
+                    writeStateFile(APPROVALS_FILE, current, opts.stateDir);
+                    log(`Approved and persisted client: ${clientPk.slice(0, 12)}...`);
+                }
                 result = 'ack';
                 break;
             case 'ping':
@@ -188,8 +206,8 @@ export function startBunker(opts) {
     log(`Bunker started: ${bunkerNpub}`);
     log(`URI: ${bunkerUrl}`);
     log(`Signing as: ${ctx.activeNpub}`);
-    if (authorizedKeys.size > 0) {
-        log(`Authorized keys: ${authorizedKeys.size}`);
+    if (cliAuthorizedKeys.size > 0) {
+        log(`Authorized keys: ${authorizedKeys.size} (${cliAuthorizedKeys.size} CLI + ${bunkerApprovals.length} persisted)`);
     }
     else {
         log('WARNING: No authorized keys set — accepting requests from anyone');

package/dist/nip17-wrap.d.ts

@@ -0,0 +1,43 @@
+/**
+ * NIP-17 gift-wrap helpers that work with any SigningContext (local keys OR remote bunker).
+ *
+ * nostr-tools' wrapEvent/unwrapEvent require raw private key bytes, which are
+ * unavailable when signing is delegated to a NIP-46 bunker. These helpers
+ * reimplement the NIP-59 gift-wrap flow using the SigningContext interface
+ * (nip44Encrypt, nip44Decrypt, getSigningFunction) so that both local-key
+ * and bunker modes work identically.
+ */
+import type { Event as NostrEvent } from 'nostr-tools';
+import type { SigningContext } from './signing-context.js';
+interface Recipient {
+    publicKey: string;
+    relayUrl?: string;
+}
+/**
+ * Wrap a DM as a NIP-17 gift-wrapped event using the SigningContext.
+ *
+ * Flow (NIP-59):
+ *   1. Build unsigned rumor (kind 14) with sender pubkey + message
+ *   2. Create seal (kind 13): NIP-44 encrypt rumor with sender key, sign with sender key
+ *   3. Create gift wrap (kind 1059): NIP-44 encrypt seal with random ephemeral key
+ *
+ * The sender's private key is never accessed directly -- all crypto operations
+ * go through ctx.nip44Encrypt() and ctx.getSigningFunction(), which delegate
+ * to the bunker in NIP-46 mode.
+ */
+export declare function wrapEventAsync(ctx: SigningContext, recipient: Recipient, message: string): Promise<NostrEvent>;
+/**
+ * Unwrap a NIP-17 gift-wrapped event using the SigningContext.
+ *
+ * Flow:
+ *   1. Decrypt the gift wrap (kind 1059) content to get the seal
+ *   2. Decrypt the seal (kind 13) content to get the rumor
+ *   3. Return the rumor (the actual DM content)
+ */
+export declare function unwrapEventAsync(ctx: SigningContext, wrap: NostrEvent): Promise<{
+    pubkey: string;
+    content: string;
+    created_at: number;
+    tags: string[][];
+}>;
+export {};

package/dist/nip17-wrap.js

@@ -0,0 +1,91 @@
+/**
+ * NIP-17 gift-wrap helpers that work with any SigningContext (local keys OR remote bunker).
+ *
+ * nostr-tools' wrapEvent/unwrapEvent require raw private key bytes, which are
+ * unavailable when signing is delegated to a NIP-46 bunker. These helpers
+ * reimplement the NIP-59 gift-wrap flow using the SigningContext interface
+ * (nip44Encrypt, nip44Decrypt, getSigningFunction) so that both local-key
+ * and bunker modes work identically.
+ */
+import { generateSecretKey, finalizeEvent, getEventHash } from 'nostr-tools/pure';
+const TWO_DAYS = 2 * 24 * 60 * 60;
+const now = () => Math.round(Date.now() / 1000);
+const randomNow = () => Math.round(now() - Math.random() * TWO_DAYS);
+/** Build the unsigned kind-14 rumor (inner DM event). */
+function createRumor(senderPubkeyHex, recipient, message) {
+    const recipients = Array.isArray(recipient) ? recipient : [recipient];
+    const tags = [];
+    for (const r of recipients) {
+        tags.push(r.relayUrl ? ['p', r.publicKey, r.relayUrl] : ['p', r.publicKey]);
+    }
+    const rumor = {
+        created_at: Math.ceil(Date.now() / 1000),
+        kind: 14,
+        tags,
+        content: message,
+        pubkey: senderPubkeyHex,
+    };
+    rumor.id = getEventHash(rumor);
+    return rumor;
+}
+/**
+ * Wrap a DM as a NIP-17 gift-wrapped event using the SigningContext.
+ *
+ * Flow (NIP-59):
+ *   1. Build unsigned rumor (kind 14) with sender pubkey + message
+ *   2. Create seal (kind 13): NIP-44 encrypt rumor with sender key, sign with sender key
+ *   3. Create gift wrap (kind 1059): NIP-44 encrypt seal with random ephemeral key
+ *
+ * The sender's private key is never accessed directly -- all crypto operations
+ * go through ctx.nip44Encrypt() and ctx.getSigningFunction(), which delegate
+ * to the bunker in NIP-46 mode.
+ */
+export async function wrapEventAsync(ctx, recipient, message) {
+    const senderPubkeyHex = ctx.activePublicKeyHex;
+    // 1. Build the rumor (unsigned kind-14)
+    const rumor = createRumor(senderPubkeyHex, recipient, message);
+    // 2. Create the seal (kind 13) -- encrypted with sender's key, signed by sender
+    const sealContent = await ctx.nip44Encrypt(recipient.publicKey, JSON.stringify(rumor));
+    const sign = ctx.getSigningFunction();
+    const seal = await sign({
+        kind: 13,
+        content: sealContent,
+        created_at: randomNow(),
+        tags: [],
+    });
+    // 3. Create the gift wrap (kind 1059) -- encrypted with random ephemeral key
+    const randomSk = generateSecretKey();
+    const { getConversationKey, encrypt } = await import('nostr-tools/nip44');
+    const ck = getConversationKey(randomSk, recipient.publicKey);
+    const wrapContent = encrypt(JSON.stringify(seal), ck);
+    const wrap = finalizeEvent({
+        kind: 1059,
+        content: wrapContent,
+        created_at: randomNow(),
+        tags: [['p', recipient.publicKey]],
+    }, randomSk);
+    // Zeroise the ephemeral key
+    randomSk.fill(0);
+    return wrap;
+}
+/**
+ * Unwrap a NIP-17 gift-wrapped event using the SigningContext.
+ *
+ * Flow:
+ *   1. Decrypt the gift wrap (kind 1059) content to get the seal
+ *   2. Decrypt the seal (kind 13) content to get the rumor
+ *   3. Return the rumor (the actual DM content)
+ */
+export async function unwrapEventAsync(ctx, wrap) {
+    // 1. Decrypt outer layer (gift wrap -> seal)
+    //    The wrap was encrypted by a random ephemeral key; we decrypt using
+    //    our key + the wrap's pubkey (the ephemeral key's public half).
+    const sealJson = await ctx.nip44Decrypt(wrap.pubkey, wrap.content);
+    const seal = JSON.parse(sealJson);
+    // 2. Decrypt inner layer (seal -> rumor)
+    //    The seal was encrypted by the sender's key; we decrypt using
+    //    our key + the seal's pubkey (the sender's public key).
+    const rumorJson = await ctx.nip44Decrypt(seal.pubkey, seal.content);
+    const rumor = JSON.parse(rumorJson);
+    return rumor;
+}

package/dist/social/dm.js

@@ -1,15 +1,19 @@
-import { wrapEvent } from 'nostr-tools/nip17';
 import * as nip04 from 'nostr-tools/nip04';
 import { decode, npubEncode } from 'nostr-tools/nip19';
 import { toAnnotation } from '../trust-context.js';
+import { wrapEventAsync, unwrapEventAsync } from '../nip17-wrap.js';
 /** 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);
+        // NIP-04 legacy DM (kind 4) — requires local key (not available in bunker mode)
+        const localCtx = ctx;
+        if (!localCtx.activePrivateKey) {
+            throw new Error('NIP-04 is not supported in bunker mode. Use NIP-17 (the default) instead.');
+        }
+        const encrypted = await nip04.encrypt(localCtx.activePrivateKey, args.recipientPubkeyHex, args.message);
         const sign = ctx.getSigningFunction();
         const event = await sign({
             kind: 4,
@@ -34,7 +38,7 @@ export async function handleDmSend(ctx, pool, args) {
     }
     const recipientRelayHint = args.recipientRelay ?? recipientRelays[0];
     // Wrap for recipient
-    const event = wrapEvent(ctx.activePrivateKey, { publicKey: args.recipientPubkeyHex, relayUrl: recipientRelayHint }, args.message);
+    const event = await wrapEventAsync(ctx, { publicKey: args.recipientPubkeyHex, relayUrl: recipientRelayHint }, args.message);
     // Publish to recipient's relays (primary) and sender's relays (fallback)
     let publish;
     if (recipientRelays.length > 0) {
@@ -47,10 +51,10 @@ export async function handleDmSend(ctx, pool, args) {
         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
+    // The inner rumor's p-tag (set by wrapEventAsync) 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 senderCopy = await wrapEventAsync(ctx, { publicKey: senderHex, relayUrl: recipientRelayHint }, args.message);
     const senderCopyPublish = await pool.publish(ctx.activeNpub, senderCopy);
     const result = { event, senderCopy, protocol: 'nip17', publish, senderCopyPublish };
     if (recipientRelays.length > 0 && publish.accepted.length === 0) {
@@ -97,8 +101,7 @@ async function decryptDmEvents(ctx, 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);
+                const unwrapped = await unwrapEventAsync(ctx, event);
                 results.push({
                     id: event.id,
                     from: unwrapped.pubkey,
@@ -120,9 +123,21 @@ async function decryptDmEvents(ctx, events) {
             }
         }
         else if (event.kind === 4) {
-            // NIP-04 legacy DM
+            // NIP-04 legacy DM — needs local key; silently skip in bunker mode
+            const localCtx = ctx;
+            if (!localCtx.activePrivateKey) {
+                results.push({
+                    id: event.id,
+                    from: event.pubkey,
+                    createdAt: event.created_at,
+                    protocol: 'nip04-deprecated',
+                    decrypted: false,
+                    error: 'NIP-04 decryption not available in bunker mode',
+                });
+                continue;
+            }
             try {
-                const decrypted = await nip04.decrypt(ctx.activePrivateKey, event.pubkey, event.content);
+                const decrypted = await nip04.decrypt(localCtx.activePrivateKey, event.pubkey, event.content);
                 results.push({
                     id: event.id,
                     from: event.pubkey,

package/dist/state.d.ts

@@ -0,0 +1,4 @@
+/** Read and parse a JSON state file. Returns `{}` if missing or corrupt. */
+export declare function readStateFile<T = Record<string, unknown>>(name: string, stateDir?: string): T;
+/** Write a JSON state file with 0600 permissions. Creates directory if needed. */
+export declare function writeStateFile(name: string, data: unknown, stateDir?: string): void;

package/dist/state.js

@@ -0,0 +1,23 @@
+import { readFileSync, writeFileSync, mkdirSync, chmodSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+const DEFAULT_STATE_DIR = join(process.env.XDG_CONFIG_HOME ?? join(homedir(), '.config'), 'bray');
+/** Read and parse a JSON state file. Returns `{}` if missing or corrupt. */
+export function readStateFile(name, stateDir = DEFAULT_STATE_DIR) {
+    const path = join(stateDir, name);
+    try {
+        return JSON.parse(readFileSync(path, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+/** Write a JSON state file with 0600 permissions. Creates directory if needed. */
+export function writeStateFile(name, data, stateDir = DEFAULT_STATE_DIR) {
+    if (!existsSync(stateDir)) {
+        mkdirSync(stateDir, { recursive: true });
+    }
+    const path = join(stateDir, name);
+    writeFileSync(path, JSON.stringify(data, null, 2), { mode: 0o600 });
+    chmodSync(path, 0o600);
+}

package/dist/trust/handlers.js

@@ -1,10 +1,10 @@
 import { createAttestation, createRevocation } from 'nostr-attestations';
 import { validateAttestation } from 'nostr-attestations';
 import { attestationFilter } from 'nostr-attestations';
-import { wrapEvent } from 'nostr-tools/nip17';
 import { toUnsignedEvent } from 'nsec-tree/event';
 import { decode } from 'nostr-tools/nip19';
 import { hasExtendedIdentity } from '../signing-context.js';
+import { wrapEventAsync } from '../nip17-wrap.js';
 /** Create and publish a kind 31000 attestation */
 export async function handleTrustAttest(ctx, pool, args) {
     if (!args.type && !args.assertionId) {
@@ -88,7 +88,7 @@ export async function handleTrustRequest(ctx, pool, args) {
         attestation_type: args.attestationType,
         message: args.message,
     });
-    const event = wrapEvent(ctx.activePrivateKey, { publicKey: args.recipientPubkeyHex }, payload);
+    const event = await wrapEventAsync(ctx, { publicKey: args.recipientPubkeyHex }, payload);
     const publish = await pool.publish(ctx.activeNpub, event);
     return { event, publish };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nostr-bray",
-  "version": "1.26.0",
+  "version": "1.27.0",
   "description": "Trust-aware Nostr for AI and humans. Three dimensions of trust -- verification, proximity, and access -- woven into every interaction.",
   "type": "module",
   "main": "dist/index.js",