From 50bda2daa7d8e1ffbb66da980082513ced509e87 Mon Sep 17 00:00:00 2001 From: Laan Tungir Date: Fri, 7 Aug 2026 10:06:51 -0400 Subject: [PATCH] Filter disabled relays from publish paths (broadcast, non-broadcast, and raw) --- www/js/version.json | 6 ++-- www/ndk-worker.js | 75 +++++++++++++++++++++++++++++++++++++-------- 2 files changed, 65 insertions(+), 16 deletions(-) diff --git a/www/js/version.json b/www/js/version.json index 280970e..4af079d 100644 --- a/www/js/version.json +++ b/www/js/version.json @@ -1,5 +1,5 @@ { - "VERSION": "v0.7.100", - "VERSION_NUMBER": "0.7.100", - "BUILD_DATE": "2026-08-07T10:54:50.095Z" + "VERSION": "v0.7.101", + "VERSION_NUMBER": "0.7.101", + "BUILD_DATE": "2026-08-07T14:06:51.088Z" } diff --git a/www/ndk-worker.js b/www/ndk-worker.js index 99bc770..6b083e6 100644 --- a/www/ndk-worker.js +++ b/www/ndk-worker.js @@ -89728,6 +89728,17 @@ let disabledRelays = new Set(); // auto-connecting to discovered outbox relays. let outboxModelEnabled = true; +/** + * Check if a relay URL is temporarily disabled. + * Checks both the normalized and raw form. + */ +function isRelayDisabled(relayUrl) { + if (!relayUrl) return false; + if (disabledRelays.has(relayUrl)) return true; + const normalized = normalizeRelayUrl(relayUrl); + return normalized && disabledRelays.has(normalized); +} + // App-wide user settings state const USER_SETTINGS_DB_NAME = 'ndk-shared-settings'; const USER_SETTINGS_DB_VERSION = 2; @@ -95693,9 +95704,12 @@ async function handlePublish(requestId, event, port) { if (isBroadcast) { outboxWriteUrls = Array.from(relayTypes.entries()) .filter(([, t]) => t === 'write' || t === 'both') - .map(([url]) => url); + .map(([url]) => url) + .filter(url => !isRelayDisabled(url)); // exclude disabled relays } - const allBroadcastUrls = [...new Set([...outboxWriteUrls, ...activeBroadcastUrls])]; + // Filter disabled relays from broadcast URLs too + const activeBroadcastUrlsFiltered = activeBroadcastUrls.filter(url => !isRelayDisabled(url)); + const allBroadcastUrls = [...new Set([...outboxWriteUrls, ...activeBroadcastUrlsFiltered])]; // --- Live broadcast progress streaming ------------------------------------ // NDK's NDKEvent emits 'relay:published' and 'relay:publish:failed' per @@ -95715,7 +95729,7 @@ async function handlePublish(requestId, event, port) { if (isBroadcast && totalTarget > 0) { console.log(`[Worker] Broadcasting to ${allBroadcastUrls.length} relays ` + - `(${activeBroadcastUrls.length} broadcast + ${outboxWriteUrls.length} outbox, ` + + `(${activeBroadcastUrlsFiltered.length} broadcast + ${outboxWriteUrls.length} outbox, ` + `${skippedRelayUrls.size} skipped)`); broadcast({ @@ -95825,7 +95839,7 @@ async function handlePublish(requestId, event, port) { // --- Phase 2: Broadcast to remaining relays in batches (background) --- // Only publish to relays that aren't already in the outbox set // (those were already published in Phase 1). - const broadcastOnlyUrls = activeBroadcastUrls.filter(u => !outboxWriteUrls.includes(u)); + const broadcastOnlyUrls = activeBroadcastUrlsFiltered.filter(u => !outboxWriteUrls.includes(u)); if (broadcastOnlyUrls.length > 0) { const batches = []; for (let i = 0; i < broadcastOnlyUrls.length; i += BATCH_SIZE) { @@ -95945,12 +95959,34 @@ async function handlePublish(requestId, event, port) { // broadcasts since we've handled everything here. return; } else { - // Normal (non-broadcast) publish — await the full result as before. - try { - relaySet = await ndkEvent.publish(null, undefined, undefined); - } catch (publishError) { - console.warn('[Worker] publish() threw:', publishError?.message || publishError); + // Normal (non-broadcast) publish. + // Build a relay set that excludes disabled relays so we don't + // publish to (or reconnect) temporarily disabled relays. + const enabledRelayUrls = Array.from(ndk.pool.relays.values()) + .filter(r => !isRelayDisabled(r.url)) + .map(r => r.url); + + if (enabledRelayUrls.length > 0 && NDKRelaySet?.fromRelayUrls) { + console.log(`[Worker] Publishing to ${enabledRelayUrls.length} enabled relays (excluding ${ndk.pool.relays.size - enabledRelayUrls.length} disabled)`); + try { + const enabledSet = NDKRelaySet.fromRelayUrls(enabledRelayUrls, ndk); + relaySet = await ndkEvent.publish(enabledSet, undefined, undefined); + } catch (publishError) { + console.warn('[Worker] publish() threw:', publishError?.message || publishError); + relaySet = null; + } + } else if (enabledRelayUrls.length === 0 && ndk.pool.relays.size > 0) { + // All relays are disabled — don't publish at all + console.warn('[Worker] All relays are disabled — skipping publish'); relaySet = null; + } else { + // Fallback: no relay set builder, use default publish + try { + relaySet = await ndkEvent.publish(null, undefined, undefined); + } catch (publishError) { + console.warn('[Worker] publish() threw:', publishError?.message || publishError); + relaySet = null; + } } } @@ -96001,9 +96037,9 @@ async function handlePublish(requestId, event, port) { // for display purposes, but keep them distinguishable for skip-marking. relayResults.failed = [...Array.from(failedSoFar), ...Array.from(timedOutSoFar)]; } else { - // Check which connected relays didn't accept it + // Check which connected relays didn't accept it (skip disabled relays) for (const relay of ndk.pool.relays.values()) { - if (relay.status >= 5 && !relayResults.successful.includes(relay.url)) { + if (relay.status >= 5 && !isRelayDisabled(relay.url) && !relayResults.successful.includes(relay.url)) { relayResults.failed.push(relay.url); } } @@ -96111,7 +96147,20 @@ async function handlePublishRaw(requestId, event, port) { const ndkEvent = new NDKEvent(ndk, event); // Do not sign here: raw event is expected to be fully finalized already. - const relaySet = await ndkEvent.publish(); + // Build a relay set that excludes disabled relays. + const enabledRelayUrlsRaw = Array.from(ndk.pool.relays.values()) + .filter(r => !isRelayDisabled(r.url)) + .map(r => r.url); + + let relaySet = null; + if (enabledRelayUrlsRaw.length > 0 && NDKRelaySet?.fromRelayUrls) { + const enabledSetRaw = NDKRelaySet.fromRelayUrls(enabledRelayUrlsRaw, ndk); + relaySet = await ndkEvent.publish(enabledSetRaw); + } else if (enabledRelayUrlsRaw.length === 0 && ndk.pool.relays.size > 0) { + console.warn('[Worker] All relays are disabled — skipping raw publish'); + } else { + relaySet = await ndkEvent.publish(); + } const relayResults = { successful: [], @@ -96126,7 +96175,7 @@ async function handlePublishRaw(requestId, event, port) { } for (const relay of ndk.pool.relays.values()) { - if (relay.status >= 5 && !relayResults.successful.includes(relay.url)) { + if (relay.status >= 5 && !isRelayDisabled(relay.url) && !relayResults.successful.includes(relay.url)) { relayResults.failed.push(relay.url); } }