nostr-bray 1.26.1 → 1.27.1

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/catalog.js

@@ -108,11 +108,17 @@ export class ActionCatalog {
             description: 'Execute an action found via search-actions. Pass the exact action name and its parameters.',
             inputSchema: {
                 action: z.string().describe('Action name from search-actions results'),
-                params: z.record(z.string(), z.unknown()).default({}).describe('Parameters for the action (see search-actions results for expected params)'),
+                params: z.record(z.string(), z.unknown()).optional().describe('Parameters for the action (see search-actions results for expected params). Alias: parameters.'),
+                // Alias for clients that naturally reach for "parameters" rather than "params".
+                // Without this, MCP SDK strips unknown keys from the validated args and the
+                // inner action handler receives an empty object, causing spurious
+                // "expected string, received undefined" validation failures.
+                parameters: z.record(z.string(), z.unknown()).optional().describe('Alias for params. Either field is accepted.'),
             },
             annotations: { openWorldHint: true },
-        }, async ({ action, params }) => {
-            return catalog.execute(action, params);
+        }, async ({ action, params, parameters }) => {
+            const resolved = (params ?? parameters ?? {});
+            return catalog.execute(action, resolved);
         });
     }
 }

package/dist/relay/handlers.d.ts

@@ -37,6 +37,7 @@ export declare function handleRelayAdd(ctx: SigningContext, pool: RelayPool, arg
     reconfigured: boolean;
 };
 export interface RelayQueryArgs {
+    ids?: string[];
     kinds?: number[];
     authors?: string[];
     tags?: Record<string, string[]>;

package/dist/relay/handlers.js

@@ -81,6 +81,8 @@ export function handleRelayAdd(ctx, pool, args) {
 /** 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.ids?.length)
+        filter.ids = args.ids;
     if (args.kinds?.length)
         filter.kinds = args.kinds;
     if (args.authors?.length)

package/dist/relay/tools.js

@@ -50,21 +50,49 @@ export function registerRelayTools(server, deps) {
         };
     });
     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.',
+        description: 'Query events from Nostr relays by kind, author, ids, 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. Filter fields may be supplied either as top-level arguments or wrapped in a single "filter" object (both shapes are accepted).',
         inputSchema: {
+            ids: z.array(z.string()).optional().describe('Event IDs (hex) to fetch directly'),
             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)'),
+            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).optional().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)'),
             search: z.string().optional().describe('Full-text search query (NIP-50). Only works on relays that support NIP-50; others will ignore it.'),
+            // Alias: some MCP clients naturally wrap the whole filter in a single "filter" object.
+            // Without this alias the MCP SDK silently strips the unknown key, leaving the handler
+            // with an empty argument set and returning a broad firehose of events.
+            filter: z.object({
+                ids: z.array(z.string()).optional(),
+                kinds: z.array(z.number().int()).optional(),
+                authors: z.array(z.string()).optional(),
+                tags: z.record(z.string(), z.array(z.string())).optional(),
+                since: z.number().int().optional(),
+                until: z.number().int().optional(),
+                limit: z.number().int().min(1).max(500).optional(),
+                search: z.string().optional(),
+            }).optional().describe('Alias: all filter fields wrapped in a single object. Merged with any top-level fields; top-level values win on conflict.'),
         },
         annotations: { readOnlyHint: true },
-    }, async ({ kinds, authors, tags, since, until, limit, relays, search }) => {
+    }, async (args) => {
+        // Merge nested "filter" alias with top-level fields. Top-level values win on conflict so
+        // the canonical form stays authoritative, but a caller that only supplies "filter" still
+        // gets everything through. Without this merge the MCP SDK strips the unknown top-level
+        // "filter" key and the handler receives an empty object, yielding a firehose response.
+        const f = args.filter ?? {};
+        const mergedLimit = args.limit ?? f.limit ?? 50;
         const events = await handleRelayQuery(deps.pool, deps.ctx.activeNpub, {
-            kinds, authors, tags, since, until, limit, relays, search,
+            ids: args.ids ?? f.ids,
+            kinds: args.kinds ?? f.kinds,
+            authors: args.authors ?? f.authors,
+            tags: args.tags ?? f.tags,
+            since: args.since ?? f.since,
+            until: args.until ?? f.until,
+            limit: mergedLimit,
+            relays: args.relays,
+            search: args.search ?? f.search,
         });
         const summary = events.map(e => ({
             id: e.id,

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nostr-bray",
-  "version": "1.26.1",
+  "version": "1.27.1",
   "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",