nostr-bray 1.16.2 → 1.18.0

package/dist/bunker.d.ts

@@ -14,6 +14,7 @@ export interface BunkerOptions {
     ctx: IdentityContext;
     relays: string[];
     authorizedKeys?: string[];
+    bunkerKeyHex?: string;
     quiet?: boolean;
 }
 export interface BunkerInstance {

package/dist/bunker.js

@@ -19,8 +19,10 @@ 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();
+    // Use persistent key if provided, otherwise generate ephemeral
+    const bunkerSk = opts.bunkerKeyHex
+        ? Buffer.from(opts.bunkerKeyHex, 'hex')
+        : generateSecretKey();
     const bunkerPk = getPublicKey(bunkerSk);
     const bunkerNpub = npubEncode(bunkerPk);
     const pool = new SimplePool();

package/dist/cli.js

@@ -39,10 +39,20 @@ if (command === 'bunker' && !args.includes('--help')) {
     const authorizedKeys = args.includes('--authorized-keys')
         ? args[args.indexOf('--authorized-keys') + 1].split(',')
         : undefined;
+    // Persistent bunker key — read from file or flag
+    let bunkerKeyHex;
+    if (args.includes('--bunker-key-file')) {
+        const { readFileSync } = await import('node:fs');
+        bunkerKeyHex = readFileSync(args[args.indexOf('--bunker-key-file') + 1], 'utf-8').trim();
+    }
+    else if (args.includes('--bunker-key')) {
+        bunkerKeyHex = args[args.indexOf('--bunker-key') + 1];
+    }
     const bunker = startBunker({
         ctx: bCtx,
         relays: config.relays,
         authorizedKeys,
+        bunkerKeyHex,
         quiet: args.includes('--quiet'),
     });
     console.error(`nostr-bray bunker running`);

package/dist/relay/handlers.d.ts

@@ -30,6 +30,17 @@ export declare function handleRelayAdd(ctx: IdentityContext, pool: RelayPool, ar
 }): {
     reconfigured: boolean;
 };
+export interface RelayQueryArgs {
+    kinds?: number[];
+    authors?: string[];
+    tags?: Record<string, string[]>;
+    since?: number;
+    until?: number;
+    limit?: number;
+    relays?: string[];
+}
+/** Query events from relays by arbitrary filter. Uses explicit relays if provided, otherwise the active identity's read relays. */
+export declare function handleRelayQuery(pool: RelayPool, npub: string, args: RelayQueryArgs): Promise<NostrEvent[]>;
 /** Validate a relay URL — must be wss:// or ws://, no private networks */
 export declare function validateRelayUrl(url: string): void;
 /** Fetch NIP-11 relay information document */

package/dist/relay/handlers.js

@@ -63,6 +63,32 @@ export function handleRelayAdd(ctx, pool, args) {
     pool.reconfigure(ctx.activeNpub, { read, write });
     return { reconfigured: true };
 }
+/** Query events from relays by arbitrary filter. Uses explicit relays if provided, otherwise the active identity's read relays. */
+export async function handleRelayQuery(pool, npub, args) {
+    const filter = {};
+    if (args.kinds?.length)
+        filter.kinds = args.kinds;
+    if (args.authors?.length)
+        filter.authors = args.authors;
+    if (args.since)
+        filter.since = args.since;
+    if (args.until)
+        filter.until = args.until;
+    filter.limit = args.limit ?? 50;
+    // Map tag filters (e.g. { "#p": ["abc"], "#d": ["xyz"] })
+    if (args.tags) {
+        for (const [key, values] of Object.entries(args.tags)) {
+            const tagKey = key.startsWith('#') ? key : `#${key}`;
+            filter[tagKey] = values;
+        }
+    }
+    if (args.relays?.length) {
+        for (const url of args.relays)
+            validateRelayUrl(url);
+        return pool.queryDirect(args.relays, filter);
+    }
+    return pool.query(npub, filter);
+}
 /** Validate a relay URL — must be wss:// or ws://, no private networks */
 export function validateRelayUrl(url) {
     if (!/^wss?:\/\//i.test(url)) {

package/dist/relay/tools.js

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { relayUrl } from '../validation.js';
 import { toolResponse } from '../tool-response.js';
 import * as fmt from '../format.js';
-import { handleRelayList, handleRelaySet, handleRelayAdd, handleRelayInfo } from './handlers.js';
+import { handleRelayList, handleRelaySet, handleRelayAdd, handleRelayInfo, handleRelayQuery } from './handlers.js';
 export function registerRelayTools(server, deps) {
     server.registerTool('relay_list', {
         description: 'List the relay set (read/write) for the active identity. Optionally check for shared relays with another identity.',
@@ -46,6 +46,34 @@ export function registerRelayTools(server, deps) {
             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
         };
     });
+    server.registerTool('relay_query', {
+        description: 'Query events from Nostr relays by kind, author, tags, or time range. Useful for discovering events, scanning for specific kinds, or investigating unknown event schemas. Uses explicit relays if provided, otherwise the active identity\'s read relays.',
+        inputSchema: {
+            kinds: z.array(z.number().int()).optional().describe('Event kinds to filter by (e.g. [30301, 31000])'),
+            authors: z.array(z.string()).optional().describe('Hex pubkeys of event authors'),
+            tags: z.record(z.string(), z.array(z.string())).optional().describe('Tag filters as key-value pairs (e.g. {"#p": ["hex..."], "#d": ["prefix"]})'),
+            since: z.number().int().optional().describe('Unix timestamp — only events created after this time'),
+            until: z.number().int().optional().describe('Unix timestamp — only events created before this time'),
+            limit: z.number().int().min(1).max(500).default(50).describe('Maximum number of events to return (default 50, max 500)'),
+            relays: z.array(relayUrl).optional().describe('Explicit relay URLs to query (overrides identity relay set)'),
+        },
+        annotations: { readOnlyHint: true },
+    }, async ({ kinds, authors, tags, since, until, limit, relays }) => {
+        const events = await handleRelayQuery(deps.pool, deps.ctx.activeNpub, {
+            kinds, authors, tags, since, until, limit, relays,
+        });
+        const summary = events.map(e => ({
+            id: e.id,
+            pubkey: e.pubkey,
+            kind: e.kind,
+            tags: e.tags,
+            content: e.content.length > 500 ? e.content.slice(0, 500) + '...' : e.content,
+            created_at: e.created_at,
+        }));
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ count: events.length, events: summary }, null, 2) }],
+        };
+    });
     server.registerTool('relay_info', {
         description: 'Fetch the NIP-11 relay information document for a relay URL.',
         inputSchema: {

package/dist/relay-pool.d.ts

@@ -28,6 +28,8 @@ export declare class RelayPool {
     publish(npub: string, event: NostrEvent): Promise<PublishResult>;
     /** One-shot query from read relays for the given identity */
     query(npub: string, filter: Filter): Promise<NostrEvent[]>;
+    /** One-shot query against explicit relay URLs (not identity-bound) */
+    queryDirect(relays: string[], filter: Filter): Promise<NostrEvent[]>;
     /** Queue an event for publishing once the identity's relay list is known */
     queueWrite(npub: string, event: NostrEvent): void;
     /** Number of queued events for an identity */

package/dist/relay-pool.js

@@ -103,6 +103,11 @@ export class RelayPool {
         const relays = this.getRelays(npub);
         return pool.querySync(relays.read, filter);
     }
+    /** One-shot query against explicit relay URLs (not identity-bound) */
+    async queryDirect(relays, filter) {
+        const pool = await this.poolReady;
+        return pool.querySync(relays, filter);
+    }
     /** Queue an event for publishing once the identity's relay list is known */
     queueWrite(npub, event) {
         const queue = this.writeQueue.get(npub) ?? [];

package/package.json

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