refactor: add encryption support detection for server communication

Author: gzuuus

packages/dvmcp-bridge/src/announcer.ts

@@ -11,6 +11,7 @@ import {
   TAG_UNIQUE_IDENTIFIER,
   TAG_KIND,
   TAG_SERVER_IDENTIFIER,
+  TAG_SUPPORT_ENCRYPTION,
 } from '@dvmcp/commons/core';
 import type { Event } from 'nostr-tools/pure';
 import { loggerBridge } from '@dvmcp/commons/core';
@@ -24,6 +25,7 @@ import {
   type ListResourceTemplatesResult,
 } from '@modelcontextprotocol/sdk/types.js';
 import { slugify } from '@dvmcp/commons/core';
+import { EncryptionMode } from '@dvmcp/commons/encryption';
 
 function getNip89Tags(cfg: DvmcpBridgeConfig['mcp']): string[][] {
   const keys = ['name', 'about', 'picture', 'website', 'banner'] as const;
@@ -91,6 +93,11 @@ export class NostrAnnouncer {
       [TAG_KIND, `${REQUEST_KIND}`],
       ...getNip89Tags(this.config.mcp),
     ];
+
+    // Add encryption support tag conditionally
+    if (this.config.encryption?.mode !== EncryptionMode.DISABLED) {
+      tags.push([TAG_SUPPORT_ENCRYPTION, 'true']);
+    }
     const event = this.keyManager.signEvent({
       ...this.keyManager.createEventTemplate(SERVER_ANNOUNCEMENT_KIND),
       content: announcementContent,

packages/dvmcp-commons/src/config/utils.ts

@@ -6,30 +6,57 @@ import type { ValidationError } from './types';
  * @returns Object with default values
  */
 export function getDefaults(schema: any): any {
-  if (!schema) return undefined;
+  // Base case: if schema is null, undefined, or not an object, it has no defaults.
+  if (!schema || typeof schema !== 'object') {
+    return undefined;
+  }
 
-  if (schema.type === 'object') {
-    const result: any = {};
-    if (schema.fields) {
+  // Case 1: schema is a ConfigFieldMeta object (it has a 'type' property).
+  if ('type' in schema) {
+    // If the field itself has an explicit 'default' value, that takes precedence.
+    if ('default' in schema) {
+      return schema.default;
+    }
+
+    // If it's an 'object' type with 'fields', recurse to build defaults for its children.
+    if (schema.type === 'object' && schema.fields) {
+      const subDefaults: Record<string, any> = {};
+      let hasSubContent = false;
       for (const key in schema.fields) {
-        const field = schema.fields[key];
-        if ('default' in field) {
-          result[key] = field.default;
-        } else {
-          const value = getDefaults(field);
-          if (value !== undefined) {
-            result[key] = value;
+        if (Object.prototype.hasOwnProperty.call(schema.fields, key)) {
+          const fieldValue = getDefaults(schema.fields[key]); // Recursive call
+          if (fieldValue !== undefined) {
+            subDefaults[key] = fieldValue;
+            hasSubContent = true;
           }
         }
       }
+      return hasSubContent ? subDefaults : undefined;
     }
-    return result; // Always return the result object even if empty
+
+    // If it's an 'array' type (and no explicit 'default' was found above), default to an empty array.
+    if (schema.type === 'array') {
+      return [];
+    }
+
+    // Other types (string, number, boolean) without an explicit 'default' have no default value.
+    return undefined;
   }
-  if (schema.type === 'array') {
-    return [];
+  // Case 2: schema is the root ConfigSchema (a plain object of ConfigFieldMeta, no 'type' property).
+  else {
+    const rootDefaults: Record<string, any> = {};
+    let hasRootContent = false;
+    for (const key in schema) {
+      if (Object.prototype.hasOwnProperty.call(schema, key)) {
+        const fieldValue = getDefaults(schema[key]); // Recursive call for each top-level field
+        if (fieldValue !== undefined) {
+          rootDefaults[key] = fieldValue;
+          hasRootContent = true;
+        }
+      }
+    }
+    return hasRootContent ? rootDefaults : undefined;
   }
-  if ('default' in schema) return schema.default;
-  return undefined;
 }
 
 /**

packages/dvmcp-commons/src/core/constants.ts

@@ -9,6 +9,8 @@ export const REQUEST_KIND = 25910; // Ephemeral: Client Requests
 export const RESPONSE_KIND = 26910; // Ephemeral: Server Responses
 export const NOTIFICATION_KIND = 21316; // Ephemeral: Feedback/Notifications
 export const GIFT_WRAP_KIND = 1059; // Gift Wrap (NIP-59): Encrypted messages
+export const SEALED_DIRECT_MESSAGE_KIND = 13;
+export const PRIVATE_DIRECT_MESSAGE_KIND = 14;
 
 // Common Tags for DVMCP Events
 export const TAG_UNIQUE_IDENTIFIER = 'd'; // Unique identifier (addressable events) or Server ID (init response)
@@ -21,6 +23,7 @@ export const TAG_KIND = 'k'; // Accepted request kind (server announcement)
 export const TAG_STATUS = 'status'; // Nostr-specific notification status (e.g., 'payment-required')
 export const TAG_AMOUNT = 'amount'; // Nostr-specific notification amount/invoice
 export const TAG_INVOICE = 'invoice'; // Nostr-specific notification invoice
+export const TAG_SUPPORT_ENCRYPTION = 'support_encryption';
 export const MCPMETHODS = {
   toolsList: 'tools/list',
   toolsCall: 'tools/call',

packages/dvmcp-commons/src/encryption/encryption-manager.ts

@@ -6,10 +6,10 @@ import { hexToBytes } from '@noble/hashes/utils';
 import type { EncryptionConfig } from './types';
 import { EncryptionMode } from './types';
 import {
-  SEALED_DIRECT_MESSAGE_KIND,
+  GIFT_WRAP_KIND,
   PRIVATE_DIRECT_MESSAGE_KIND,
-} from './types';
-import { GIFT_WRAP_KIND } from '../core/constants';
+  SEALED_DIRECT_MESSAGE_KIND,
+} from '../core/constants';
 
 export interface DecryptedMessage {
   content: any;

packages/dvmcp-commons/src/encryption/types.ts

@@ -20,10 +20,3 @@ export interface EncryptionConfig {
    */
   mode?: EncryptionMode;
 }
-
-// TODO: move this kinds to constants
-/**
- * NIP-17 constants
- */
-export const SEALED_DIRECT_MESSAGE_KIND = 13;
-export const PRIVATE_DIRECT_MESSAGE_KIND = 14;

packages/dvmcp-discovery/src/base-executor.ts

@@ -6,11 +6,13 @@ import {
   NOTIFICATION_KIND,
   GIFT_WRAP_KIND,
   TAG_PUBKEY,
+  loggerDiscovery,
 } from '@dvmcp/commons/core';
 import type { RelayHandler } from '@dvmcp/commons/nostr';
 import type { KeyManager } from '@dvmcp/commons/nostr';
 import type { NWCPaymentHandler } from './nwc-payment';
 import { type EncryptionManager } from '@dvmcp/commons/encryption';
+import type { ServerRegistry } from './server-registry'; // Import ServerRegistry type
 
 export abstract class BaseExecutor<T extends Capability, P, R> {
   protected executionSubscriptions: Map<string, () => void> = new Map();
@@ -22,6 +24,7 @@ export abstract class BaseExecutor<T extends Capability, P, R> {
     protected relayHandler: RelayHandler,
     protected keyManager: KeyManager,
     protected registry: BaseRegistry<T>,
+    protected serverRegistry: ServerRegistry, // Add ServerRegistry to constructor
     encryptionManager?: EncryptionManager | null
   ) {
     this.encryptionManager = encryptionManager || null;
@@ -153,27 +156,39 @@ export abstract class BaseExecutor<T extends Capability, P, R> {
           const recipientPubkey = request.tags.find(
             (tag) => tag[0] === TAG_PUBKEY
           )?.[1];
+
           if (recipientPubkey) {
-            try {
-              const encryptedEvent =
-                await this.encryptionManager.encryptMessage(
-                  this.keyManager.getPrivateKey(),
-                  recipientPubkey,
-                  {
-                    kind: request.kind,
-                    content: request.content,
-                    tags: request.tags,
-                    created_at: request.created_at,
-                  }
+            const serverInfo =
+              this.serverRegistry.getServerByPubkey(recipientPubkey);
+
+            // Check if the recipient server supports encryption
+            if (serverInfo?.supportsEncryption) {
+              try {
+                const encryptedEvent =
+                  await this.encryptionManager.encryptMessage(
+                    this.keyManager.getPrivateKey(),
+                    recipientPubkey,
+                    {
+                      kind: request.kind,
+                      content: request.content,
+                      tags: request.tags,
+                      created_at: request.created_at,
+                    }
+                  );
+                if (encryptedEvent) {
+                  eventToPublish = encryptedEvent;
+                }
+              } catch (encryptError) {
+                // If encryption fails, send the original unencrypted request
+                console.warn(
+                  'Failed to encrypt request, sending unencrypted:',
+                  encryptError
                 );
-              if (encryptedEvent) {
-                eventToPublish = encryptedEvent;
               }
-            } catch (encryptError) {
-              // If encryption fails, send the original unencrypted request
-              console.warn(
-                'Failed to encrypt request, sending unencrypted:',
-                encryptError
+            } else {
+              // If server does not support encryption, send unencrypted
+              loggerDiscovery(
+                `Recipient server ${recipientPubkey} does not support encryption or encryption mode disabled. Sending unencrypted.`
               );
             }
           }

packages/dvmcp-discovery/src/base-interfaces.ts

@@ -6,7 +6,8 @@ export interface Capability {
     | 'resource'
     | 'resourceTemplate'
     | 'server'
-    | 'completion';
+    | 'completion'
+    | 'ping';
 }
 
 export interface DVMCPBridgeServer extends Capability {

packages/dvmcp-discovery/src/discovery-server.ts

@@ -14,6 +14,7 @@ import {
   PROMPTS_LIST_KIND,
   TAG_SERVER_IDENTIFIER,
   TAG_UNIQUE_IDENTIFIER,
+  TAG_SUPPORT_ENCRYPTION,
 } from '@dvmcp/commons/core';
 import {
   type Tool,
@@ -82,6 +83,7 @@ export class DiscoveryServer {
       this.relayHandler,
       this.keyManager,
       this.toolRegistry,
+      this.serverRegistry,
       this.config,
       this.encryptionManager || undefined
     );
@@ -91,6 +93,7 @@ export class DiscoveryServer {
       this.relayHandler,
       this.keyManager,
       this.resourceRegistry,
+      this.serverRegistry,
       this.config,
       this.encryptionManager || undefined
     );
@@ -100,6 +103,7 @@ export class DiscoveryServer {
       this.relayHandler,
       this.keyManager,
       this.promptRegistry,
+      this.serverRegistry,
       this.config,
       this.encryptionManager || undefined
     );
@@ -116,6 +120,7 @@ export class DiscoveryServer {
     this.pingExecutor = new PingExecutor(
       this.relayHandler,
       this.keyManager,
+      this.serverRegistry,
       this.encryptionManager || undefined
     );
 
@@ -342,8 +347,24 @@ export class DiscoveryServer {
         loggerDiscovery('Server announcement missing server ID');
         return;
       }
-      this.serverRegistry.registerServer(serverId, event.pubkey, event.content);
-      loggerDiscovery(`Registered server: ${serverId} from ${event.pubkey}`);
+      // Extract support_encryption tag
+      const supportsEncryptionTag = event.tags.find(
+        (tag) => tag[0] === TAG_SUPPORT_ENCRYPTION
+      );
+      const supportsEncryption =
+        supportsEncryptionTag && supportsEncryptionTag[1] === 'true'
+          ? true
+          : false;
+
+      this.serverRegistry.registerServer(
+        serverId,
+        event.pubkey,
+        event.content,
+        supportsEncryption
+      );
+      loggerDiscovery(
+        `Registered server: ${serverId} from ${event.pubkey}, encryption support: ${supportsEncryption}`
+      );
     } catch (error) {
       console.error('Error processing server announcement:', error);
     }
@@ -677,7 +698,12 @@ export class DiscoveryServer {
           capabilities: announcement.capabilities || {},
           serverInfo: announcement.serverInfo,
           instructions: announcement.instructions,
-        })
+        }),
+        // For direct servers, assuming no explicit 'support_encryption' tag in InitializeResult.
+        // If the MCP protocol or InitializeResult type is extended to include encryption info,
+        // this logic would need to be updated to extract it.
+        // For now, we default to false for direct servers unless explicitly handled.
+        false // Defaulting to false for direct server encryption support
       );
       loggerDiscovery(
         `Registered direct server: ${announcement.serverInfo.name || serverId} (${serverId})`