Fix Steam attribution and flag untracked announcers

The game RSS feed exposes posters by display name, but SteamFeed matched
against the account's SteamID64/vanity identifier, so no post ever matched
and zero Steam posts were saved.

- SteamFeed: resolve each account's current persona name from its profile
  XML and match feed authors against that (trimmed, case-insensitive)
- Steam.afterIndex: once per game, ntfy for any recent announcement author
  that matches no tracked account's persona (finder-style discovery hint),
  deduped via the permanent cache
- indexer.js: generic afterIndex hook so the cross-account check stays out
  of the type-agnostic indexing loop

Author: oskarrisberg

indexer.js

@@ -81,7 +81,17 @@ const indexService = function indexService ( serviceConfig, serviceOptions, game
     }
 
     return Promise.all( indexerPromises )
-        .then( () => {
+        .then( async () => {
+            const IndexerClass = Indexers[ serviceConfig.indexerType ];
+
+            if ( IndexerClass && typeof IndexerClass.afterIndex === 'function' ) {
+                try {
+                    await IndexerClass.afterIndex( serviceConfig, serviceOptions, gameIdentifier, load );
+                } catch ( afterIndexError ) {
+                    console.error( afterIndexError );
+                }
+            }
+
             console.timeEnd( `${ gameIdentifier }-${ serviceConfig.indexerType }` );
         } );
 };
@@ -161,8 +171,8 @@ const indexGame = function indexGame ( game ) {
 
                 // eslint-disable-next-line no-process-env
                 if ( process.env.LIMIT_SERVICE && service !== process.env.LIMIT_SERVICE ) {
-                   continue;
-               }
+                    continue;
+                }
 
                 servicesIndexers.push( pFinally( indexService( serviceConfig[ service ], configuredServices[ service ] || {}, identifier ) ) );
             }

modules/indexers/Steam.js

@@ -1,4 +1,9 @@
+const RSS = require( './RSS.js' );
 const SteamFeed = require( './SteamFeed' );
+const cache = require( '../cache.js' );
+const ntfy = require( '../ntfy.js' );
+
+const ATTRIBUTION_WINDOW_SECONDS = 30 * 24 * 60 * 60;
 
 class Steam {
     constructor ( userIdentifier, providerConfig, load ) {
@@ -15,6 +20,87 @@ class Steam {
             return [];
         }
     }
+
+    // Runs once per game after every tracked account has been indexed. The game
+    // feed is shared across all of a game's Steam accounts, so attribution is a
+    // cross-account question: an announcement author we can't match to ANY
+    // tracked persona means there's a studio/dev account we should be tracking
+    // (much like finder discovering new accounts).
+    static async afterIndex ( serviceConfig, serviceOptions, gameIdentifier, load ) {
+        const appId = serviceOptions.allowedSections && serviceOptions.allowedSections[ 0 ];
+
+        if ( !appId ) {
+            return;
+        }
+
+        const endpoint = `https://steamcommunity.com/games/${ appId }/rss/`;
+
+        let items = false;
+
+        try {
+            items = await new RSS( appId, { endpoint }, load ).loadRecentPosts();
+        } catch ( feedError ) {
+            console.error( feedError );
+        }
+
+        if ( !items || items.length === 0 ) {
+            return;
+        }
+
+        const cutoff = Math.floor( Date.now() / 1000 ) - ATTRIBUTION_WINDOW_SECONDS;
+        const recentAuthors = new Set();
+
+        for ( let i = 0; i < items.length; i = i + 1 ) {
+            if ( items[ i ].author && ( !items[ i ].timestamp || items[ i ].timestamp >= cutoff ) ) {
+                recentAuthors.add( items[ i ].author.trim() );
+            }
+        }
+
+        if ( recentAuthors.size === 0 ) {
+            return;
+        }
+
+        const trackedPersonas = new Set();
+
+        await Promise.all( serviceConfig.developers.map( async ( developer ) => {
+            const persona = await SteamFeed.resolvePersonaName( developer.identifier, load );
+
+            if ( persona ) {
+                trackedPersonas.add( persona.toLowerCase() );
+            }
+        } ) );
+
+        for ( const author of recentAuthors ) {
+            if ( trackedPersonas.has( author.toLowerCase() ) ) {
+                continue;
+            }
+
+            // Notify only once per (game, author) so the 60s run loop doesn't spam.
+            const marker = `steam-unattributed-${ appId }-${ author }`;
+            let alreadyNotified = false;
+
+            try {
+                alreadyNotified = await cache.get( marker );
+            } catch ( cacheError ) {
+                console.error( cacheError );
+            }
+
+            if ( alreadyNotified ) {
+                continue;
+            }
+
+            ntfy( {
+                message: `"${ author }" posts announcements for ${ gameIdentifier } (app ${ appId }) but matches no tracked account. Consider adding them as a developer/studio account.`,
+                title: 'Untracked Steam announcer',
+            } );
+
+            try {
+                await cache.store( marker, 'notified', true );
+            } catch ( storeError ) {
+                console.error( storeError );
+            }
+        }
+    }
 }
 
 module.exports = Steam;

modules/indexers/SteamFeed.js

@@ -13,6 +13,31 @@ class SteamFeed extends RSS {
         this.section = providerConfig.allowedSections[ 0 ];
     }
 
+    // The game RSS feed exposes posters by display name (e.g. "Mal"), but our
+    // account identifier is a SteamID64 or vanity name. Resolve the account's
+    // current persona name from its profile XML so we can match feed authors.
+    static async resolvePersonaName ( userIdentifier, load ) {
+        const profileUrl = /^\d+$/.test( userIdentifier )
+            ? `https://steamcommunity.com/profiles/${ userIdentifier }/?xml=1`
+            : `https://steamcommunity.com/id/${ userIdentifier }/?xml=1`;
+
+        let profileXml = false;
+
+        try {
+            profileXml = await load.get( profileUrl );
+        } catch ( profileLoadError ) {
+            console.error( `[SteamFeed] failed to load profile ${ profileUrl }: ${ profileLoadError.message }` );
+        }
+
+        if ( !profileXml ) {
+            return false;
+        }
+
+        const match = profileXml.match( /<steamID>(?:<!\[CDATA\[)?([\s\S]*?)(?:\]\]>)?<\/steamID>/ );
+
+        return match ? match[ 1 ].trim() : false;
+    }
+
     async loadRecentPosts () {
         let posts = false;
 
@@ -22,10 +47,23 @@ class SteamFeed extends RSS {
             console.error( postLoadError );
         }
 
+        if ( !posts ) {
+            return [];
+        }
+
+        const personaName = await SteamFeed.resolvePersonaName( this.userId, this.load );
+
+        if ( !personaName ) {
+            console.warn( `[SteamFeed] could not resolve persona for ${ this.userId }, skipping ${ this.section }` );
+
+            return [];
+        }
+
+        const normalizedPersona = personaName.toLowerCase();
         const validPosts = [];
 
         for ( let i = 0; i < posts.length; i = i + 1 ) {
-            if ( posts[ i ].author !== this.userId ) {
+            if ( !posts[ i ].author || posts[ i ].author.trim().toLowerCase() !== normalizedPersona ) {
                 continue;
             }