nostr-bray 1.24.0 → 1.25.0

package/dist/format.d.ts

@@ -54,3 +54,4 @@ export declare function formatWikiList(topics: any[]): string;
 export declare function formatScheduleResult(result: any): string;
 export declare function formatScheduledQueue(entries: any[]): string;
 export declare function formatDispatchReplyResult(result: any): string;
+export declare function formatHandlers(handlers: any[]): string;

package/dist/format.js

@@ -467,3 +467,24 @@ export function formatDispatchReplyResult(result) {
     const del = result.deleted ? ' (original message deleted)' : '';
     return `Sent ${result.messageType}${del}`;
 }
+// --- Handler formatters ---
+export function formatHandlers(handlers) {
+    if (handlers.length === 0)
+        return 'No MCP handlers found.';
+    return handlers.map(h => {
+        const lines = [`${h.name}  (${h.pubkey?.slice(0, 12)}...)`];
+        if (h.about)
+            lines.push(`  ${h.about}`);
+        if (h.kinds?.length > 0)
+            lines.push(`  Kinds: ${h.kinds.join(', ')}`);
+        if (h.transports?.length > 0) {
+            const transports = h.transports.map((t) => `${t.transport}: ${t.endpoint}`).join(', ');
+            lines.push(`  Transports: ${transports}`);
+        }
+        if (h.dTag)
+            lines.push(`  d-tag: ${h.dTag}`);
+        if (h.picture)
+            lines.push(`  Picture: ${h.picture}`);
+        return lines.join('\n');
+    }).join('\n\n');
+}

package/dist/handler/handlers.d.ts

@@ -0,0 +1,50 @@
+/**
+ * NIP-XX Machine Application Handler tools.
+ *
+ * Publishes kind 31990 events with MCP transport tags, and discovers
+ * MCP-capable handlers on Nostr.
+ */
+import type { Event as NostrEvent } from 'nostr-tools';
+import type { SigningContext } from '../signing-context.js';
+import type { RelayPool } from '../relay-pool.js';
+import type { PublishResult } from '../types.js';
+export interface HandlerTransport {
+    endpoint: string;
+    transport: 'stdio' | 'http';
+}
+export interface HandlerCard {
+    pubkey: string;
+    name: string;
+    about: string;
+    kinds: string[];
+    transports: HandlerTransport[];
+    dTag: string;
+    picture?: string;
+}
+export interface HandlerPublishResult {
+    event: NostrEvent;
+    publish: PublishResult;
+}
+/**
+ * Publish a kind 31990 event advertising MCP handler capabilities.
+ *
+ * At least one of stdioCommand or httpUrl must be provided.
+ */
+export declare function handleHandlerPublish(ctx: SigningContext, pool: RelayPool, args: {
+    name: string;
+    about: string;
+    kinds: string[];
+    stdioCommand?: string;
+    httpUrl?: string;
+    picture?: string;
+    dTag?: string;
+}): Promise<HandlerPublishResult>;
+/**
+ * Discover MCP-capable handlers on Nostr via kind 31990 events.
+ *
+ * Filters results to only include events that contain at least one mcp tag.
+ */
+export declare function handleHandlerDiscover(pool: RelayPool, npub: string, args: {
+    kind?: string;
+    limit?: number;
+}): Promise<HandlerCard[]>;

package/dist/handler/handlers.js

@@ -0,0 +1,110 @@
+/**
+ * NIP-XX Machine Application Handler tools.
+ *
+ * Publishes kind 31990 events with MCP transport tags, and discovers
+ * MCP-capable handlers on Nostr.
+ */
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Slugify a name into a URL-safe d-tag identifier */
+function slugify(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+/** Parse a kind 31990 event into a HandlerCard, returning null if it has no mcp tags */
+function parseHandlerEvent(event) {
+    try {
+        const mcpTags = event.tags.filter(t => t[0] === 'mcp');
+        if (mcpTags.length === 0)
+            return null;
+        const content = JSON.parse(event.content);
+        const dTag = event.tags.find(t => t[0] === 'd');
+        const kTags = event.tags.filter(t => t[0] === 'k');
+        const transports = mcpTags.map(t => ({
+            endpoint: t[1] ?? '',
+            transport: (t[2] ?? 'stdio'),
+        }));
+        return {
+            pubkey: event.pubkey,
+            name: content.name ?? '',
+            about: content.about ?? '',
+            picture: content.picture,
+            kinds: kTags.map(t => t[1]),
+            transports,
+            dTag: dTag?.[1] ?? '',
+        };
+    }
+    catch {
+        return null;
+    }
+}
+// ---------------------------------------------------------------------------
+// handleHandlerPublish
+// ---------------------------------------------------------------------------
+/**
+ * Publish a kind 31990 event advertising MCP handler capabilities.
+ *
+ * At least one of stdioCommand or httpUrl must be provided.
+ */
+export async function handleHandlerPublish(ctx, pool, args) {
+    if (!args.stdioCommand && !args.httpUrl) {
+        throw new Error('At least one of stdioCommand or httpUrl must be provided.');
+    }
+    const dTag = args.dTag ?? slugify(args.name);
+    const now = Math.floor(Date.now() / 1000);
+    const contentObj = {
+        name: args.name,
+        about: args.about,
+    };
+    if (args.picture)
+        contentObj.picture = args.picture;
+    const content = JSON.stringify(contentObj);
+    const kindList = args.kinds.join(', ');
+    const tags = [
+        ['d', dTag],
+        ...args.kinds.map(k => ['k', k]),
+        ['alt', `MCP handler for kind ${kindList}`],
+    ];
+    if (args.stdioCommand)
+        tags.push(['mcp', args.stdioCommand, 'stdio']);
+    if (args.httpUrl)
+        tags.push(['mcp', args.httpUrl, 'http']);
+    const sign = ctx.getSigningFunction();
+    const event = await sign({
+        kind: 31990,
+        created_at: now,
+        tags,
+        content,
+    });
+    const publish = await pool.publish(ctx.activeNpub, event);
+    return { event, publish };
+}
+// ---------------------------------------------------------------------------
+// handleHandlerDiscover
+// ---------------------------------------------------------------------------
+/**
+ * Discover MCP-capable handlers on Nostr via kind 31990 events.
+ *
+ * Filters results to only include events that contain at least one mcp tag.
+ */
+export async function handleHandlerDiscover(pool, npub, args) {
+    const limit = args.limit ?? 20;
+    const filter = {
+        kinds: [31990],
+        limit,
+    };
+    if (args.kind) {
+        filter['#k'] = [args.kind];
+    }
+    const events = await pool.query(npub, filter);
+    const cards = [];
+    for (const event of events) {
+        const card = parseHandlerEvent(event);
+        if (card)
+            cards.push(card);
+    }
+    return cards;
+}

package/dist/handler/tools.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ToolDeps } from '../identity/tools.js';
+export declare function registerHandlerTools(server: McpServer, deps: ToolDeps): void;

package/dist/handler/tools.js

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import { toolResponse } from '../tool-response.js';
+import * as fmt from '../format.js';
+import { handleHandlerPublish, handleHandlerDiscover } from './handlers.js';
+export function registerHandlerTools(server, deps) {
+    // --- handler-publish ---
+    server.registerTool('handler-publish', {
+        description: 'Publish a NIP-XX Machine Application Handler card (kind 31990) advertising MCP transport endpoints. Lets other agents and tools discover MCP servers on Nostr by the event kinds they support. Provide at least one of stdio_command or http_url.',
+        inputSchema: {
+            name: z.string().describe('Handler name (e.g. "nostr-bray", "402-mcp")'),
+            about: z.string().describe('What this handler does'),
+            kinds: z.array(z.string()).describe('Event kinds this handler supports (e.g. ["1", "31402"])'),
+            stdio_command: z.string().optional().describe('stdio transport command (e.g. "npx nostr-bray")'),
+            http_url: z.string().optional().describe('HTTP transport URL (e.g. "https://mcp.example.com/sse")'),
+            picture: z.string().optional().describe('Icon URL'),
+            d_tag: z.string().optional().describe('Custom d-tag identifier (defaults to slugified name)'),
+            output: z.enum(['json', 'human']).default('json').describe('Response format'),
+        },
+        annotations: { readOnlyHint: false },
+    }, async ({ name, about, kinds, stdio_command, http_url, picture, d_tag, output }) => {
+        const result = await handleHandlerPublish(deps.ctx, deps.pool, {
+            name,
+            about,
+            kinds,
+            stdioCommand: stdio_command,
+            httpUrl: http_url,
+            picture,
+            dTag: d_tag,
+        });
+        return toolResponse(result, output, fmt.formatPublish);
+    });
+    // --- handler-discover ---
+    server.registerTool('handler-discover', {
+        description: 'Discover MCP-capable handlers on Nostr. Searches for kind 31990 events that include mcp transport tags. Optionally filter by supported event kind. Returns handler names, descriptions, supported kinds, and transport endpoints.',
+        inputSchema: {
+            kind: z.string().optional().describe('Filter by supported event kind (e.g. "1", "31402")'),
+            limit: z.number().optional().describe('Maximum number of results (default: 20)'),
+            output: z.enum(['json', 'human']).default('human').describe('Response format'),
+        },
+        annotations: { readOnlyHint: true },
+    }, async ({ kind, limit, output }) => {
+        const result = await handleHandlerDiscover(deps.pool, deps.ctx.activeNpub, {
+            kind,
+            limit,
+        });
+        return toolResponse(result, output, fmt.formatHandlers);
+    });
+}

package/dist/index.js

@@ -20,6 +20,7 @@ import { TrustContext } from './trust-context.js';
 import { registerSignetTools } from './signet/tools.js';
 import { registerVaultTools } from './vault/tools.js';
 import { registerDispatchTools } from './dispatch/tools.js';
+import { registerHandlerTools } from './handler/tools.js';
 import { ActionCatalog, createCatalogProxy } from './catalog.js';
 const config = await loadConfig();
 const pool = new RelayPool({
@@ -112,6 +113,7 @@ registerModerationTools(proxy, deps);
 registerSignetTools(proxy, deps);
 registerVaultTools(proxy, deps);
 registerDispatchTools(proxy, { ...deps, dispatchIdentitiesPath: config.dispatchIdentities });
+registerHandlerTools(proxy, deps);
 // Add search-actions and execute-action meta-tools to the real server
 catalog.registerMetaTools(server);
 console.error(`nostr-bray: ${PROMOTED.size} promoted tools + ${catalog.size} cataloged (${PROMOTED.size + catalog.size + 2} total)`);

package/dist/serve.js

@@ -8,6 +8,7 @@ import { WebSocketServer, WebSocket } from 'ws';
 import { createServer } from 'node:http';
 import { readFileSync } from 'node:fs';
 import { verifyEvent } from 'nostr-tools/pure';
+let subCounter = 0;
 /** Check if an event matches a single filter */
 function matchFilter(filter, event) {
     if (filter.ids && !filter.ids.includes(event.id))
@@ -117,7 +118,7 @@ export function startRelay(opts = {}) {
                 const filters = msg.slice(2);
                 // Register subscription
                 const sub = { id: subId, filters, ws };
-                const key = `${subId}-${Date.now()}`;
+                const key = `${subId}-${++subCounter}`;
                 subscriptions.set(key, sub);
                 clientSubs.add(key);
                 // Send matching stored events

package/package.json

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