Clean up push notification logging and debug endpoints

Author: chriswritescode-dev

backend/src/index.ts

@@ -209,24 +209,19 @@ if (ENV.VAPID.PUBLIC_KEY && ENV.VAPID.PRIVATE_KEY) {
   if (!ENV.VAPID.SUBJECT) {
     logger.warn('VAPID_SUBJECT is not set — push notifications require a mailto: subject (e.g. mailto:you@example.com)')
   } else if (!ENV.VAPID.SUBJECT.startsWith('mailto:')) {
-    logger.warn(`VAPID_SUBJECT="${ENV.VAPID.SUBJECT}" does not use mailto: format — iOS/Safari push notifications will fail. Use mailto:you@example.com`)
+    logger.warn(`VAPID_SUBJECT="${ENV.VAPID.SUBJECT}" does not use mailto: format — iOS/Safari push notifications will fail`)
   }
 
-  const vapidSubject = ENV.VAPID.SUBJECT || 'mailto:push@localhost'
-
   notificationService.configureVapid({
     publicKey: ENV.VAPID.PUBLIC_KEY,
     privateKey: ENV.VAPID.PRIVATE_KEY,
-    subject: vapidSubject,
+    subject: ENV.VAPID.SUBJECT || 'mailto:push@localhost',
   })
   sseAggregator.onEvent((directory, event) => {
     notificationService.handleSSEEvent(directory, event).catch((err) => {
       logger.error('Push notification dispatch error:', err)
     })
   })
-  logger.info('Push notifications enabled')
-} else {
-  logger.info('Push notifications disabled (no VAPID keys configured)')
 }
 
 app.route('/api/auth', createAuthRoutes(auth))

backend/src/routes/notifications.ts

@@ -2,8 +2,6 @@ import { Hono } from "hono";
 import { z } from "zod";
 import { PushSubscriptionRequestSchema } from "@opencode-manager/shared/schemas";
 import type { NotificationService } from "../services/notification";
-import { logger } from "../utils/logger";
-import { sseAggregator } from "../services/sse-aggregator";
 
 export function createNotificationRoutes(
   notificationService: NotificationService
@@ -32,8 +30,6 @@ export function createNotificationRoutes(
 
     const { endpoint, keys, deviceName } = parsed.data;
 
-    logger.info(`[push:subscribe] user="${userId}" device="${deviceName ?? "unknown"}" endpoint="${endpoint}"`);
-
     const subscription = notificationService.saveSubscription(
       userId,
       endpoint,
@@ -94,39 +90,9 @@ export function createNotificationRoutes(
       );
     }
 
-    const results = await notificationService.sendTestNotification(userId);
-
-    return c.json({ success: true, devicesNotified: subscriptions.length, diagnostics: results });
-  });
+    await notificationService.sendTestNotification(userId);
 
-  app.get("/debug", (c) => {
-    const userId = c.req.query('userId') || 'default'
-    const subscriptions = notificationService.getSubscriptions(userId);
-    const clients = sseAggregator.getClientVisibilityDetails();
-    const hasVisibleClients = sseAggregator.hasVisibleClients();
-    const vapidDetails = notificationService.getVapidDetails();
-
-    return c.json({
-      vapidConfigured: notificationService.isConfigured(),
-      vapidPublicKeyPrefix: vapidDetails?.publicKey.slice(0, 20) + "...",
-      vapidSubject: vapidDetails?.subject,
-      vapidPublicKeyLength: vapidDetails?.publicKey.length,
-      vapidPrivateKeyLength: vapidDetails?.privateKeyLength,
-      serverTime: new Date().toISOString(),
-      serverTimestamp: Date.now(),
-      hasVisibleClients,
-      sseClients: clients,
-      subscriptions: subscriptions.map(sub => ({
-        id: sub.id,
-        endpoint: sub.endpoint,
-        endpointDomain: new URL(sub.endpoint).hostname,
-        deviceName: sub.deviceName,
-        createdAt: new Date(sub.createdAt).toISOString(),
-        lastUsedAt: sub.lastUsedAt ? new Date(sub.lastUsedAt).toISOString() : null,
-        p256dhLength: sub.p256dh.length,
-        authLength: sub.auth.length,
-      })),
-    });
+    return c.json({ success: true, devicesNotified: subscriptions.length });
   });
 
   return app;

backend/src/services/notification.ts

@@ -81,22 +81,12 @@ export class NotificationService {
   configureVapid(config: VapidConfig): void {
     this.vapidConfig = config;
     webpush.setVapidDetails(config.subject, config.publicKey, config.privateKey);
-    logger.info(`VAPID configured — subject="${config.subject}" publicKeyLength=${config.publicKey.length} privateKeyLength=${config.privateKey.length}`);
   }
 
   getVapidPublicKey(): string | null {
     return this.vapidConfig?.publicKey ?? null;
   }
 
-  getVapidDetails(): { publicKey: string; privateKeyLength: number; subject: string } | null {
-    if (!this.vapidConfig) return null;
-    return {
-      publicKey: this.vapidConfig.publicKey,
-      privateKeyLength: this.vapidConfig.privateKey.length,
-      subject: this.vapidConfig.subject,
-    };
-  }
-
   isConfigured(): boolean {
     return this.vapidConfig !== null;
   }
@@ -136,8 +126,6 @@ export class NotificationService {
       last_used_at: number | null;
     };
 
-    logger.info(`Saved push subscription for user ${userId}`);
-
     return {
       id: row.id,
       userId: row.user_id,
@@ -212,39 +200,21 @@ export class NotificationService {
     event: SSEEvent
   ): Promise<void> {
     const config = EVENT_CONFIG[event.type];
-    if (!config) {
-      logger.debug(`[push] Ignoring SSE event type="${event.type}" (no notification config)`);
-      return;
-    }
+    if (!config) return;
 
-    logger.info(`[push] Processing SSE event type="${event.type}" for directory="${_directory}"`);
+    if (this.hasActiveSSEClients()) return;
 
-    if (this.hasActiveSSEClients()) {
-      logger.info(`[push] Skipping push — active visible SSE clients detected`);
-      return;
-    }
-
-    if (!this.isConfigured()) {
-      logger.warn(`[push] Skipping push — VAPID not configured`);
-      return;
-    }
+    if (!this.isConfigured()) return;
 
     const userIds = this.getAllUserIds();
-    logger.info(`[push] Found ${userIds.length} user(s) with push subscriptions`);
 
     for (const userId of userIds) {
       const settings = this.settingsService.getSettings(userId);
       const notifPrefs =
         settings.preferences.notifications ?? DEFAULT_NOTIFICATION_PREFERENCES;
 
-      if (!notifPrefs.enabled) {
-        logger.info(`[push] Skipping user="${userId}" — notifications disabled`);
-        continue;
-      }
-      if (!notifPrefs.events[config.preferencesKey]) {
-        logger.info(`[push] Skipping user="${userId}" — event "${config.preferencesKey}" disabled`);
-        continue;
-      }
+      if (!notifPrefs.enabled) continue;
+      if (!notifPrefs.events[config.preferencesKey]) continue;
 
       const sessionId = event.properties.sessionID as string | undefined;
 
@@ -271,86 +241,56 @@ export class NotificationService {
         },
       };
 
-      logger.info(`[push] Sending push to user="${userId}" title="${payload.title}"`);
       await this.sendToUser(userId, payload);
     }
   }
 
-  async sendTestNotification(userId: string): Promise<{ sent: number; failed: number; results: Array<{ endpoint: string; status: string; statusCode?: number; error?: string }> }> {
-    const subscriptions = this.getSubscriptions(userId);
-    logger.info(`[push:test] Sending test notification to user="${userId}" (${subscriptions.length} subscription(s))`);
-    for (const sub of subscriptions) {
-      logger.info(`[push:test] Subscription endpoint: ${sub.endpoint}`);
-    }
-    const results = await this.sendToUserWithResults(userId, {
+  async sendTestNotification(userId: string): Promise<void> {
+    await this.sendToUser(userId, {
       title: "Test Notification",
       body: "Push notifications are working correctly",
       tag: "test",
       data: { eventType: "test", url: "/" },
     });
-    logger.info(`[push:test] Results: ${JSON.stringify(results)}`);
-    return results;
   }
 
   private async sendToUser(
     userId: string,
     payload: PushNotificationPayload
   ): Promise<void> {
-    await this.sendToUserWithResults(userId, payload);
-  }
-
-  private async sendToUserWithResults(
-    userId: string,
-    payload: PushNotificationPayload
-  ): Promise<{ sent: number; failed: number; results: Array<{ endpoint: string; status: string; statusCode?: number; error?: string }> }> {
     const subscriptions = this.getSubscriptions(userId);
     const expiredEndpoints: string[] = [];
-    const results: Array<{ endpoint: string; status: string; statusCode?: number; error?: string }> = [];
-
-    logger.info(`[push] Delivering to ${subscriptions.length} subscription(s) for user="${userId}"`);
 
     await Promise.allSettled(
       subscriptions.map(async (sub) => {
-        const endpointPreview = sub.endpoint.slice(0, 80);
         try {
-          const response = await webpush.sendNotification(
+          await webpush.sendNotification(
             {
               endpoint: sub.endpoint,
               keys: { p256dh: sub.p256dh, auth: sub.auth },
             },
             JSON.stringify(payload)
           );
 
-          logger.info(`[push] Success for ${endpointPreview}... — statusCode=${response.statusCode} headers=${JSON.stringify(response.headers)}`);
-          results.push({ endpoint: endpointPreview, status: "success", statusCode: response.statusCode });
-
           this.db
             .prepare(
               "UPDATE push_subscriptions SET last_used_at = ? WHERE id = ?"
             )
             .run(Date.now(), sub.id);
         } catch (error) {
           const statusCode = (error as { statusCode?: number }).statusCode;
-          const body = (error as { body?: string }).body;
-          const message = (error as Error).message;
-
-          logger.error(`[push] Failed for ${endpointPreview}... — statusCode=${statusCode} body="${body}" message="${message}"`);
-          results.push({ endpoint: endpointPreview, status: "failed", statusCode, error: body ?? message });
 
           if (statusCode === 404 || statusCode === 410) {
             expiredEndpoints.push(sub.endpoint);
+          } else {
+            logger.error(`Push delivery failed for ${sub.endpoint.slice(0, 50)}:`, error);
           }
         }
       })
     );
 
     for (const endpoint of expiredEndpoints) {
       this.removeSubscription(endpoint);
-      logger.info(`[push] Removed expired push subscription: ${endpoint.slice(0, 50)}...`);
     }
-
-    const sent = results.filter(r => r.status === "success").length;
-    const failed = results.filter(r => r.status === "failed").length;
-    return { sent, failed, results };
   }
 }

backend/src/services/sse-aggregator.ts

@@ -370,14 +370,6 @@ class SSEAggregator {
     return false
   }
 
-  getClientVisibilityDetails(): Array<{ id: string; visible: boolean; directories: string[] }> {
-    return Array.from(this.clients.values()).map(client => ({
-      id: client.id,
-      visible: client.visible,
-      directories: Array.from(client.directories),
-    }))
-  }
-
   getActiveDirectories(): string[] {
     return Array.from(this.connections.keys())
   }

frontend/src/sw.ts

@@ -22,36 +22,24 @@ interface PushNotificationData {
   };
 }
 
-console.warn("[sw] Service worker loaded");
-
 self.addEventListener("activate", (event) => {
-  console.warn("[sw] Service worker activated");
   event.waitUntil(self.clients.claim());
 });
 
 self.addEventListener("install", () => {
-  console.warn("[sw] Service worker installed");
   self.skipWaiting();
 });
 
 self.addEventListener("push", (event: PushEvent) => {
-  console.warn("[sw:push] Push event received", { hasData: !!event.data });
-
-  if (!event.data) {
-    console.warn("[sw:push] No data in push event, ignoring");
-    return;
-  }
+  if (!event.data) return;
 
   let payload: PushNotificationData;
   try {
     payload = event.data.json() as PushNotificationData;
-    console.warn("[sw:push] Parsed payload", JSON.stringify(payload));
-  } catch (parseError) {
-    const rawText = event.data.text();
-    console.warn("[sw:push] Failed to parse JSON, using raw text", rawText, parseError);
+  } catch {
     payload = {
       title: "OpenCode Manager",
-      body: rawText,
+      body: event.data.text(),
       data: { eventType: "unknown" },
     };
   }
@@ -65,22 +53,10 @@ self.addEventListener("push", (event: PushEvent) => {
     requireInteraction: isHighPriority(payload.data?.eventType),
   };
 
-  console.warn("[sw:push] Showing notification", { title: payload.title, options: JSON.stringify(options) });
-
-  const notificationPromise = self.registration
-    .showNotification(payload.title, options)
-    .then(() => {
-      console.warn("[sw:push] showNotification resolved successfully");
-    })
-    .catch((err: unknown) => {
-      console.error("[sw:push] showNotification FAILED", err);
-    });
-
-  event.waitUntil(notificationPromise);
+  event.waitUntil(self.registration.showNotification(payload.title, options));
 });
 
 self.addEventListener("notificationclick", (event: NotificationEvent) => {
-  console.warn("[sw:click] Notification clicked", event.notification.data);
   event.notification.close();
 
   const url = (event.notification.data?.url as string) ?? "/";