chore: improve debug

Author: gzuuus

packages/dvmcp-bridge/index.ts

@@ -25,7 +25,7 @@ export async function startBridge(options: BridgeStartOptions = {}) {
     const bridge = new DVMBridge(config);
 
     const shutdown = async () => {
-      loggerBridge('Shutting down...');
+      loggerBridge.info('Shutting down...');
       try {
         await bridge.stop();
         process.exit(0);

packages/dvmcp-bridge/src/announcer.ts

@@ -67,13 +67,15 @@ export class NostrAnnouncer {
     });
 
     await this.relayHandler.publishEvent(event);
-    loggerBridge('Announced relay list metadata');
+    loggerBridge.info('Announced relay list metadata');
   }
 
   async announceServer() {
     const mainClient = this.mcpPool.getDefaultClient();
     if (!mainClient) {
-      loggerBridge('No MCP server client available for server announcement.');
+      loggerBridge.warn(
+        'No MCP server client available for server announcement.'
+      );
       return;
     }
 
@@ -91,7 +93,7 @@ export class NostrAnnouncer {
 
     const announcementContent = JSON.stringify(announcementObject);
 
-    loggerBridge(`Using server ID: ${this.serverId}`);
+    loggerBridge.info(`Using server ID: ${this.serverId}`);
 
     const tags: string[][] = [
       [TAG_UNIQUE_IDENTIFIER, this.serverId],
@@ -110,7 +112,7 @@ export class NostrAnnouncer {
     });
 
     await this.relayHandler.publishEvent(event);
-    loggerBridge('Server announced');
+    loggerBridge.info('Server announced');
     return { event, serverId: this.serverId, announcementObject };
   }
 
@@ -142,7 +144,7 @@ export class NostrAnnouncer {
     });
 
     await this.relayHandler.publishEvent(event);
-    loggerBridge('Tools list announced');
+    loggerBridge.info('Tools list announced');
   }
 
   async announceResourcesList(resources?: ListResourcesResult) {
@@ -175,7 +177,7 @@ export class NostrAnnouncer {
     });
 
     await this.relayHandler.publishEvent(event);
-    loggerBridge('Resources list announced');
+    loggerBridge.info('Resources list announced');
   }
 
   async announceResourceTemplatesList(
@@ -187,7 +189,7 @@ export class NostrAnnouncer {
       !resourceTemplatesResult.resourceTemplates ||
       resourceTemplatesResult.resourceTemplates.length === 0
     ) {
-      loggerBridge('No resource templates to announce');
+      loggerBridge.info('No resource templates to announce');
       return;
     }
 
@@ -210,7 +212,7 @@ export class NostrAnnouncer {
     });
 
     await this.relayHandler.publishEvent(event);
-    loggerBridge(
+    loggerBridge.info(
       `Resource templates list announced with ${resourceTemplatesResult.resourceTemplates.length} templates`
     );
   }
@@ -245,12 +247,14 @@ export class NostrAnnouncer {
     });
 
     await this.relayHandler.publishEvent(event);
-    loggerBridge('Prompts list announced');
+    loggerBridge.info('Prompts list announced');
   }
 
   async announce() {
     if (this.isPrivateServer) {
-      loggerBridge('Private server: Skipping public updates to announcement.');
+      loggerBridge.info(
+        'Private server: Skipping public updates to announcement.'
+      );
       return;
     }
     const serverInfo = await this.announceServer();
@@ -328,7 +332,7 @@ export class NostrAnnouncer {
   ): Promise<Event[]> {
     const mainClient = this.mcpPool.getDefaultClient();
     if (!mainClient) {
-      loggerBridge('No MCP server client available for deletion.');
+      loggerBridge.warn('No MCP server client available for deletion.');
       return [];
     }
 
@@ -361,7 +365,9 @@ export class NostrAnnouncer {
       });
 
       await this.relayHandler.publishEvent(deletionEvent);
-      loggerBridge(`Published deletion event for kind ${kind} (serverId tag)`);
+      loggerBridge.info(
+        `Published deletion event for kind ${kind} (serverId tag)`
+      );
       allDeletionEvents.push(deletionEvent);
     }
 

packages/dvmcp-bridge/src/dvm-bridge.ts

@@ -58,7 +58,7 @@ export class DVMBridge {
   ) {
     this.relayHandler =
       relayHandler ?? new RelayHandler(config.nostr.relayUrls);
-    loggerBridge('Initializing DVM Bridge...');
+    loggerBridge.info('Initializing DVM Bridge...');
     this.mcpPool = new MCPPool(config);
 
     this.keyManager = createKeyManager(config.nostr.privateKey);
@@ -71,17 +71,17 @@ export class DVMBridge {
     );
 
     if (this.config.mcp.serverId) {
-      loggerBridge(`Using custom server ID from config: ${this.serverId}`);
+      loggerBridge.info(`Using custom server ID from config: ${this.serverId}`);
     }
 
     // Initialize encryption manager if encryption is configured
     if (this.config.encryption) {
       this.encryptionManager = new EncryptionManager(this.config.encryption);
-      loggerBridge(
+      loggerBridge.info(
         `Encryption support enabled (${this.config.encryption.mode || 'optional'} mode)`
       );
     } else {
-      loggerBridge('Encryption support disabled');
+      loggerBridge.info('Encryption support disabled');
     }
 
     // Initialize centralized event publisher
@@ -100,8 +100,8 @@ export class DVMBridge {
       config.mcp.isPrivateServer || false
     );
 
-    loggerBridge('Public key:', publicKey);
-    loggerBridge('Server id:', this.serverId);
+    loggerBridge.info('Public key:', publicKey);
+    loggerBridge.info('Server id:', this.serverId);
   }
 
   private isWhitelisted(pubkey: string): boolean {
@@ -112,32 +112,34 @@ export class DVMBridge {
 
   async start() {
     if (this.isRunning) {
-      loggerBridge('Bridge is already running');
+      loggerBridge.warn('Bridge is already running');
       return;
     }
 
     try {
-      loggerBridge('Connecting to MCP servers...');
+      loggerBridge.info('Connecting to MCP servers...');
       await this.mcpPool.connect();
 
       const tools = await this.mcpPool.listTools();
-      loggerBridge(`Available MCP tools across all servers: ${tools.length}`);
+      loggerBridge.info(
+        `Available MCP tools across all servers: ${tools.length}`
+      );
 
       if (!this.config.mcp.isPrivateServer) {
-        loggerBridge('Announcing service to Nostr network...');
+        loggerBridge.info('Announcing service to Nostr network...');
         try {
           await this.nostrAnnouncer.announce();
         } catch (error) {
           console.warn('Failed to announce service to Nostr network:', error);
-          loggerBridge(
+          loggerBridge.warn(
             '⚠️ Warning: Failed to announce service to Nostr network. The bridge will still function, but will not be discoverable via Nostr.'
           );
         }
       } else {
-        loggerBridge('Private server mode: Skipping public announcement.');
+        loggerBridge.info('Private server mode: Skipping public announcement.');
       }
 
-      loggerBridge('Setting up request handlers...');
+      loggerBridge.info('Setting up request handlers...');
       const publicKey = this.keyManager.getPublicKey();
       const subscribe = () => {
         // Subscribe to both regular and encrypted events
@@ -156,18 +158,22 @@ export class DVMBridge {
       try {
         subscribe();
       } catch (error) {
-        loggerBridge(
+        loggerBridge.warn(
           '⚠️ Warning: Failed to subscribe to Nostr requests. Will retry on relay reconnection.'
         );
       }
 
       this.relayHandler.onRelayReconnected((url) => {
-        loggerBridge(`Relay reconnected: ${url}, re-subscribing to requests`);
+        loggerBridge.info(
+          `Relay reconnected: ${url}, re-subscribing to requests`
+        );
         subscribe();
       });
 
       this.isRunning = true;
-      loggerBridge('DVM Bridge is now running and ready to handle requests');
+      loggerBridge.info(
+        'DVM Bridge is now running and ready to handle requests'
+      );
     } catch (error) {
       console.error('Failed to start DVM Bridge:', error);
       throw error;
@@ -179,24 +185,24 @@ export class DVMBridge {
       return;
     }
 
-    loggerBridge('Stopping DVM Bridge...');
+    loggerBridge.info('Stopping DVM Bridge...');
     try {
       await this.mcpPool.disconnect();
       this.relayHandler.cleanup();
       this.isRunning = false;
-      loggerBridge('DVM Bridge stopped successfully');
+      loggerBridge.info('DVM Bridge stopped successfully');
     } catch (error) {
       console.error('Error stopping DVM Bridge:', error);
       throw error;
     }
   }
 
   async deleteAnnouncement(reason?: string) {
-    loggerBridge('Deleting service announcement from relays...');
+    loggerBridge.info('Deleting service announcement from relays...');
     try {
       const deletionEvent =
         await this.nostrAnnouncer.deleteAnnouncement(reason);
-      loggerBridge('Service announcement deleted successfully');
+      loggerBridge.info('Service announcement deleted successfully');
       return deletionEvent;
     } catch (error) {
       console.error('Error deleting service announcement:', error);
@@ -234,7 +240,7 @@ export class DVMBridge {
         realSenderPubkey: decryptionResult.sender,
       };
     } catch (error) {
-      loggerBridge('Error in decryptEventAndExtractSender:', error);
+      loggerBridge.error('Error in decryptEventAndExtractSender:', error);
       return null;
     }
   }
@@ -246,20 +252,20 @@ export class DVMBridge {
         event.kind === GIFT_WRAP_KIND &&
         this.encryptionManager?.isEncryptionEnabled()
       ) {
-        loggerBridge('Received encrypted event, attempting to decrypt...');
+        loggerBridge.info('Received encrypted event, attempting to decrypt...');
 
         // Try to decrypt the event and extract the real sender's pubkey
         const decryptionResult = await this.decryptEventAndExtractSender(event);
 
         if (!decryptionResult) {
-          loggerBridge(
+          loggerBridge.debug(
             'Failed to decrypt event - may not be intended for this server'
           );
           return;
         }
 
         // Process the decrypted event with the real sender's pubkey
-        loggerBridge('Successfully decrypted event, processing...');
+        loggerBridge.info('Successfully decrypted event, processing...');
         // Construct a NostrEvent from the decrypted template and real sender pubkey
         // The ID should be computed from the inner event content, not the gift wrap
         const innerEventId = getEventHash({
@@ -324,7 +330,7 @@ export class DVMBridge {
     const serverIdentifier =
       tags.find((tag) => tag[0] === TAG_SERVER_IDENTIFIER)?.[1] || '';
 
-    loggerBridge(
+    loggerBridge.info(
       `Processing encrypted request from real sender: ${realSenderPubkey}`
     );
     await this.processRequest(
@@ -490,7 +496,7 @@ export class DVMBridge {
             break;
           case MCPMETHODS.notificationsInitialized:
             // Do nothing yet
-            loggerBridge(`Received ${method} from ${pubkey}`);
+            loggerBridge.info(`Received ${method} from ${pubkey}`);
             break;
           default:
             const notImpl = this.keyManager.signEvent({
@@ -527,10 +533,10 @@ export class DVMBridge {
             responseContext
           );
         } else {
-          loggerBridge(`Received unhandled notification type: ${method}`);
+          loggerBridge.warn(`Received unhandled notification type: ${method}`);
         }
       } else {
-        loggerBridge(`Received unhandled event kind: ${kind}`);
+        loggerBridge.warn(`Received unhandled event kind: ${kind}`);
       }
     } catch (error) {
       console.error('Error processing request:', error);

packages/dvmcp-bridge/src/handlers/completion-handlers.ts

@@ -51,7 +51,7 @@ export async function handleCompletionComplete(
     );
     await publisher.publishResponse(response, responseContext);
   } catch (error) {
-    loggerBridge('[handleCompletionComplete] Error:', error);
+    loggerBridge.error('[handleCompletionComplete] Error:', error);
     return undefined;
   }
 }

packages/dvmcp-bridge/src/handlers/initialize-handlers.ts

@@ -42,7 +42,7 @@ export async function handleInitialize(
   config: DvmcpBridgeConfig,
   actualServerId: string
 ): Promise<void> {
-  loggerBridge(`Handling MCP Method: ${MCPMETHODS.initialize}`);
+  loggerBridge.info(`Handling MCP Method: ${MCPMETHODS.initialize}`);
 
   const eventTags = event.tags;
   const eventId = event.id;
@@ -56,7 +56,7 @@ export async function handleInitialize(
 
   // If a specific server ID was requested and it does not match this bridge's server ID do not respond
   if (requestedServerId && requestedServerId !== actualServerId) {
-    loggerBridge(
+    loggerBridge.debug(
       `Initialize request for server ID '${requestedServerId}' does not match ` +
         `this bridge's server ID '${actualServerId}'. Not responding.`
     );
@@ -65,7 +65,7 @@ export async function handleInitialize(
 
   const mainClient = mcpPool.getDefaultClient();
   if (!mainClient) {
-    loggerBridge(
+    loggerBridge.error(
       'No MCP server client available to handle initialize request.'
     );
     // Respond with an error if no MCP client is available
@@ -138,5 +138,5 @@ export async function handleInitialize(
     senderPubkey,
     responseContext.shouldEncrypt
   );
-  loggerBridge(`Sent initialize response to ${senderPubkey}`);
+  loggerBridge.info(`Sent initialize response to ${senderPubkey}`);
 }

packages/dvmcp-bridge/src/handlers/notification-handlers.ts

@@ -26,7 +26,7 @@ export async function handleNotificationsCancel(
   const eventIdToCancel = tags.find((tag) => tag[0] === TAG_EVENT_ID)?.[1];
 
   if (eventIdToCancel) {
-    loggerBridge(`Received cancel request for job: ${eventIdToCancel}`);
+    loggerBridge.info(`Received cancel request for job: ${eventIdToCancel}`);
 
     // Send cancellation acknowledgment using centralized event publisher
     const eventPublisher = new EventPublisher(
@@ -50,6 +50,6 @@ export async function handleNotificationsCancel(
       responseContext?.shouldEncrypt || false
     );
   } else {
-    loggerBridge('Received cancel notification without event ID');
+    loggerBridge.warn('Received cancel notification without event ID');
   }
 }