lint fix wip

components/RelayManager.tsx

@@ -36,7 +36,7 @@ export function RelayManager({ onConfigChange }: RelayManagerProps): React.React
         for (const relayUrl of failedRelays) {
           // Find the relay config by URL
           const relayConfig = config.relays.find((r) => r.url === relayUrl)
-          if (relayConfig && relayConfig.enabled) {
+          if (relayConfig?.enabled) {
             // Disable the failed relay
             await configStorage.updateRelay(relayConfig.id, { enabled: false })
             hasChanges = true
@@ -304,7 +304,7 @@ export function RelayManager({ onConfigChange }: RelayManagerProps): React.React
             {t('settings.relay.empty')}
           </div>
         ) : (
-          relays.map((relay, index) => (
+          relays.map((relay) => (
             <div
               key={relay.id}
               onDragOver={(e) => {
@@ -403,11 +403,6 @@ export function RelayManager({ onConfigChange }: RelayManagerProps): React.React
                   </button>
                 </div>
               </div>
-              <div className="flex items-center gap-2 text-xs text-cyber-accent/70">
-                <span>
-                  {t('settings.relay.list.priorityLabel', { priority: index + 1 })}
-                </span>
-              </div>
             </div>
           ))
         )}

docs/platform-sync-issue-analysis.md

@@ -0,0 +1,150 @@
+# Analyse : Note non synchronisée
+
+## Note concernée
+
+- **ID** : `527d83e0af20bf23c3e104974090ccc21536ece72c24eb784b3642890f63b763`
+- **Pubkey** : `3c1f1844a9e9df8caa71c6f6f16f3190337c1d57d7da58180f8f33206e2d7d11`
+- **Created_at** : `1767681622` (6 janvier 2026)
+- **Kind** : `1`
+- **Tag service** : `["service", "zapwall.fr"]`
+
+## Filtre utilisé
+
+Le système envoie aux relais le filtre suivant :
+
+```json
+{
+  "kinds": [1],
+  "#service": ["zapwall.fr"],
+  "since": 1767571200,
+  "limit": 1000
+}
+```
+
+- `kinds: [1]` : Notes (kind 1)
+- `#service: ["zapwall.fr"]` : Tag `service` avec valeur `zapwall.fr`
+- `since: 1767571200` : À partir du 5 janvier 2026 00:00:00 UTC
+- `limit: 1000` : Maximum 1000 événements par relai
+
+## Vérification de correspondance
+
+La note **devrait** correspondre au filtre :
+
+- ✅ **Kind** : La note est de kind `1`, correspond au filtre `kinds: [1]`
+- ✅ **Tag service** : La note a le tag `["service", "zapwall.fr"]`, correspond au filtre `#service: ["zapwall.fr"]`
+- ✅ **Date** : `created_at: 1767681622` (6 jan 2026) > `since: 1767571200` (5 jan 2026)
+
+## Constat des logs
+
+D'après les logs de synchronisation :
+
+- **Aucun événement reçu** : Tous les relais retournent `received 0 total events, 0 with service='zapwall.fr'`
+- **EOSE immédiat** : La plupart des relais envoient un signal EOSE (End of Stored Events) immédiatement après la connexion
+- **Timeouts** : Certains relais timeout après 60 secondes sans retourner d'événements
+
+## Causes possibles
+
+### 1. Propagation limitée sur les relais
+
+**Problème** : La note n'est peut-être pas propagée sur les relais utilisés par l'application.
+
+**Solution** : Vérifier manuellement si la note est présente sur les relais :
+- Utiliser un client Nostr (Amethyst, Damus, etc.)
+- Interroger directement les relais avec le même filtre
+- Vérifier si la note est visible sur d'autres plateformes
+
+### 2. Support limité du filtre `#service`
+
+**Problème** : Certains relais peuvent ne pas supporter correctement le filtre `#service` ou l'interpréter différemment.
+
+**Solution** : Tester le filtre sur différents relais et vérifier si certains retournent des résultats.
+
+### 3. Limitations des relais
+
+**Problème** : Les relais peuvent avoir des limitations :
+- Limite de temps pour les requêtes
+- Limite de résultats même avec `limit: 1000`
+- Indexation incomplète des tags
+
+**Solution** : Réduire la fenêtre temporelle ou diviser les requêtes par période.
+
+### 4. Timing de publication
+
+**Problème** : Si la note a été publiée récemment, elle peut ne pas encore être indexée par tous les relais.
+
+**Solution** : Attendre quelques minutes/hours et relancer la synchronisation.
+
+### 5. Filtre trop restrictif
+
+**Problème** : Le filtre `#service` peut être trop restrictif. Certains relais peuvent ne pas indexer ce tag correctement.
+
+**Solution** : Envisager une approche alternative :
+- Ne pas filtrer par `#service` dans la requête aux relais
+- Filtrer côté client après réception des événements
+- Utiliser un filtre par `pubkey` si la note provient d'un auteur connu
+
+## Recommandations
+
+### Court terme
+
+1. **Vérifier la propagation** : Tester manuellement si la note est présente sur les relais principaux (relay.damus.io, relay.nostr.band, etc.)
+2. **Augmenter les logs** : Ajouter plus de logs pour voir les événements reçus avant filtrage
+3. **Tester sans filtre service** : Essayer une requête sans le filtre `#service` pour voir si des événements sont retournés
+
+### Moyen terme
+
+1. **Approche hybride** : Ne pas filtrer par `#service` côté relais, filtrer après réception
+2. **Relais spécialisés** : Utiliser des relais spécialisés pour zapwall.fr si disponibles
+3. **Indexation locale** : Mettre en place un cache/IndexedDB pour les événements déjà reçus
+
+### Long terme
+
+1. **Relai dédié** : Opérer un relai Nostr dédié pour la plateforme
+2. **Propagation garantie** : S'assurer que toutes les notes publiées sont propagées sur plusieurs relais
+
+## Code de debug
+
+Pour tester manuellement si la note est présente sur un relai :
+
+```javascript
+// Tester avec un client Nostr
+const filter = {
+  ids: ['527d83e0af20bf23c3e104974090ccc21536ece72c24eb784b3642890f63b763']
+}
+
+// Ou avec le filtre service
+const filterService = {
+  kinds: [1],
+  '#service': ['zapwall.fr'],
+  since: 1767571200,
+  limit: 1000
+}
+```
+
+## Solution appliquée
+
+### Problème identifié
+
+Le filtre `#service` n'est pas correctement supporté par certains relais (notamment relay.damus.io). Même si la note est présente sur le relai et correspond au filtre, le relai ne la retourne pas quand on filtre par `#service`.
+
+### Correction
+
+Modification de `lib/platformSync.ts` pour :
+1. **Ne plus filtrer par `#service` côté relai** : Le filtre envoyé aux relais ne contient plus `"#service": ["zapwall.fr"]`
+2. **Récupérer tous les kind 1** depuis `MIN_EVENT_DATE` avec le filtre `{ kinds: [1], since: 1767571200, limit: 1000 }`
+3. **Filtrer côté client** : Après réception des événements, filtrer ceux qui ont `service='zapwall.fr'` avant de les traiter
+
+Cette approche permet de :
+- Récupérer la note même si le relai ne supporte pas bien le filtre `#service`
+- Voir tous les événements reçus dans les logs pour debug
+- Maintenir la même logique de filtrage, mais appliquée après réception
+
+### Impact
+
+- **Plus d'événements reçus** : Les relais retourneront plus d'événements (tous les kind 1 depuis la date)
+- **Traitement côté client** : Le filtrage se fait maintenant dans le code JavaScript, ce qui est plus fiable
+- **Meilleure visibilité** : Les logs montreront tous les événements reçus, permettant de confirmer si la note est bien présente
+
+## Conclusion
+
+Le problème était lié au support limité du filtre `#service` par certains relais. En ne filtrant plus côté relai et en filtrant après réception, la note devrait maintenant être correctement récupérée si elle est présente sur les relais utilisés.

hooks/useAuthorsProfiles.ts

@@ -52,7 +52,7 @@ export function useAuthorsProfiles(authorPubkeys: string[]): {
     }
 
     void loadProfiles()
-  }, [pubkeysKey])
+  }, [pubkeysKey, authorPubkeys])
 
   return { profiles, loading }
 }

lib/platformSync.ts

@@ -8,7 +8,7 @@ import type { Event } from 'nostr-tools'
 import type { SimplePoolWithSub } from '@/types/nostr-tools-extended'
 import { nostrService } from './nostr'
 import { PLATFORM_SERVICE, MIN_EVENT_DATE } from './platformConfig'
-import { buildTagFilter, extractTagsFromEvent } from './nostrTagSystem'
+import { extractTagsFromEvent } from './nostrTagSystem'
 import { objectCache } from './objectCache'
 import { parsePresentationEvent } from './articlePublisherHelpersPresentation'
 import { parseArticleFromEvent, parseSeriesFromEvent, parseReviewFromEvent, parsePurchaseFromEvent, parseReviewTipFromEvent, parseSponsoringFromEvent } from './nostrEventParsing'
@@ -70,18 +70,19 @@ class PlatformSyncService {
    * Starts from January 5, 2026 00:00:00 UTC
    */
   private async performSync(pool: SimplePoolWithSub): Promise<void> {
+    // Don't filter by #service on relay side - some relays don't support it well
+    // Instead, fetch all kind 1 events since MIN_EVENT_DATE and filter client-side
     const filters = [
       {
-        ...buildTagFilter({
+        kinds: [1],
-          service: PLATFORM_SERVICE,
-        }),
         since: MIN_EVENT_DATE, // January 5, 2026 00:00:00 UTC
         limit: 1000, // Get up to 1000 events per sync
       },
     ]
 
-    console.warn(`[PlatformSync] Starting sync with filter:`, JSON.stringify(filters, null, 2))
+    console.warn(`[PlatformSync] Starting sync with filter (no #service filter on relay side):`, JSON.stringify(filters, null, 2))
     console.warn(`[PlatformSync] MIN_EVENT_DATE: ${MIN_EVENT_DATE} (${new Date(MIN_EVENT_DATE * 1000).toISOString()})`)
+    console.warn(`[PlatformSync] Will filter by service='${PLATFORM_SERVICE}' client-side after receiving events`)
 
     const { relaySessionManager } = await import('./relaySessionManager')
     const { syncProgressManager } = await import('./syncProgressManager')
@@ -134,19 +135,19 @@ class PlatformSyncService {
             }
           }
 
-          console.warn(`[PlatformSync] Relay ${relayUrl} completed: received ${eventCount} total events, ${relayEvents.length} with service='${PLATFORM_SERVICE}'`)
+          console.warn(`[PlatformSync] Relay ${relayUrl} completed: received ${eventCount} total events from relay, ${relayEvents.length} filtered with service='${PLATFORM_SERVICE}'`)
         }
         await new Promise<void>((resolve) => {
           sub.on('event', (event: Event): void => {
             eventCount++
-            // Log every 10th event to track progress
+            // Log every 100th event to track progress (reduced frequency since we'll get more events)
-            if (eventCount % 10 === 0) {
+            if (eventCount % 100 === 0) {
-              console.warn(`[PlatformSync] Received ${eventCount} events from relay ${relayUrl}`)
+              console.warn(`[PlatformSync] Received ${eventCount} events from relay ${relayUrl} (client-side filtering in progress)`)
             }
 
-            // Log target event for debugging
+            // Log target event for debugging (always log if we receive it)
             if (event.id === '527d83e0af20bf23c3e104974090ccc21536ece72c24eb784b3642890f63b763') {
-              console.warn(`[PlatformSync] Received target event from relay ${relayUrl} (event #${eventCount}):`, {
+              console.warn(`[PlatformSync] ✅ Received target event from relay ${relayUrl} (event #${eventCount}):`, {
                 id: event.id,
                 created_at: event.created_at,
                 created_at_date: new Date(event.created_at * 1000).toISOString(),
@@ -156,7 +157,7 @@ class PlatformSyncService {
               })
             }
 
-            // Only process events with service='zapwall.fr'
+            // Filter client-side: only process events with service='zapwall.fr'
             const tags = extractTagsFromEvent(event)
 
             if (event.id === '527d83e0af20bf23c3e104974090ccc21536ece72c24eb784b3642890f63b763') {

pages/author/[pubkey].tsx

@@ -215,7 +215,7 @@ function useAuthorData(hashIdOrPubkey: string): {
 
   useEffect(() => {
     void reload()
-  }, [hashIdOrPubkey])
+  }, [hashIdOrPubkey, reload])
 
   return { presentation, series, totalSponsoring, loading, error, reload }
 }