feat(labeler): implement SteamCMD Linux support check

* Added a new function `runSteamCmdLinuxCheck` to assess Linux platform support using SteamCMD.
* Enhanced existing logic to incorporate SteamCMD results alongside Steam API checks.
* Updated comments to clarify the distinction between server tool AppIDs and client platform support.
* Improved error handling and logging for SteamCMD assessments.

Co-authored-by: Copilot <copilot@github.com>

Author: dgibbs64

.github/workflows/labeler.yml

@@ -83,6 +83,7 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           script: |
+            const { execFileSync } = require('node:child_process');
             const owner = context.repo.owner;
             const repo = context.repo.repo;
             const eventName = context.eventName;
@@ -227,6 +228,88 @@ jobs:
               return false;
             }
 
+            function runSteamCmdLinuxCheck(appId) {
+              if (!appId) {
+                return { status: 'skipped', reason: 'No Steam AppID provided.' };
+              }
+
+              const image = 'gameservermanagers/steamcmd:latest';
+              const args = [
+                'run',
+                '--rm',
+                '-e',
+                'PUID=1001',
+                '-e',
+                'PGID=1001',
+                image,
+                '+@ShutdownOnFailedCommand',
+                '1',
+                '+@NoPromptForPassword',
+                '1',
+                '+login',
+                'anonymous',
+                '+app_info_update',
+                '1',
+                '+app_info_print',
+                String(appId),
+                '+quit',
+              ];
+
+              try {
+                const output = execFileSync('docker', args, {
+                  encoding: 'utf8',
+                  stdio: ['ignore', 'pipe', 'pipe'],
+                  timeout: 120000,
+                  maxBuffer: 10 * 1024 * 1024,
+                });
+
+                const normalized = output.toLowerCase();
+                const linuxSignals = [
+                  /"oslist"\s+"linux"/i,
+                  /"oslist"\s+"linux,windows"/i,
+                  /"oslist"\s+"windows,linux"/i,
+                  /"platforms"[\s\S]*?"linux"\s+"1"/i,
+                  /linux32/i,
+                  /linux64/i,
+                ];
+                const windowsOnlySignals = [
+                  /"oslist"\s+"windows"/i,
+                  /"platforms"[\s\S]*?"windows"\s+"1"/i,
+                ];
+
+                const hasLinuxSignal = linuxSignals.some((re) => re.test(normalized));
+                const hasWindowsOnlySignal =
+                  !hasLinuxSignal && windowsOnlySignals.some((re) => re.test(normalized));
+
+                if (hasLinuxSignal) {
+                  return {
+                    status: 'linux',
+                    reason: `SteamCMD app_info contains Linux platform/depot metadata for AppID ${appId}.`,
+                  };
+                }
+
+                if (hasWindowsOnlySignal) {
+                  return {
+                    status: 'windows-only',
+                    reason: `SteamCMD app_info contains Windows-only platform metadata for AppID ${appId}.`,
+                  };
+                }
+
+                return {
+                  status: 'unknown',
+                  reason: `SteamCMD app_info returned no clear Linux server metadata for AppID ${appId}.`,
+                };
+              } catch (err) {
+                const stderr = err.stderr ? String(err.stderr).trim() : '';
+                const stdout = err.stdout ? String(err.stdout).trim() : '';
+                const message = stderr || stdout || err.message;
+                return {
+                  status: 'error',
+                  reason: `SteamCMD lookup failed: ${message}`,
+                };
+              }
+            }
+
             function parseServerlistCsv(csvText) {
               const rows = [];
               const lines = (csvText || '').split(/\r?\n/);
@@ -809,9 +892,13 @@ jobs:
 
               // Steam API check: platforms.linux for the given AppID.
               // Note: dedicated server tool AppIDs (e.g. 403240, 869800) return success:false
-              // because they have no store page. This is NOT evidence of no Linux support.
+              // because they have no store page — this is NOT evidence of no Linux support.
+              // We do NOT fall back to checking the game client AppID because client and server
+              // platform support are independent: a game can have no Linux client but still
+              // ship a native Linux dedicated server binary (and vice versa).
               let steamLinuxSupport = null; // true=yes, false=no, null=unknown/inconclusive
-              let steamAppIsServerTool = false; // success:false from store API
+              let steamAppIsServerTool = false; // success:false from store API = likely server-tool AppID
+              let steamCmdAssessment = null;
               if (steamAppId) {
                 try {
                   const steamRes = await fetch(
@@ -833,6 +920,11 @@ jobs:
                 } catch (err) {
                   console.log(`Steam API check failed: ${err.message}`);
                 }
+
+                if (steamLinuxSupport === null) {
+                  steamCmdAssessment = runSteamCmdLinuxCheck(steamAppId);
+                  console.log(`SteamCMD assessment: ${JSON.stringify(steamCmdAssessment)}`);
+                }
               }
 
               // AI analysis of official docs/guides for Linux evidence.
@@ -892,13 +984,15 @@ jobs:
                 (deterministicWineRequired && !hasLinuxEvidence) ||
                 (windowsBinaryHint && !hasLinuxEvidence);
               const noLinuxFromSteam = steamLinuxSupport === false;
+              const noLinuxFromSteamCmd = steamCmdAssessment?.status === 'windows-only';
               const noLinuxFromAi =
                 aiLinuxAssessment?.linux_support === 'no' &&
                 (aiLinuxAssessment?.confidence === 'high' || aiLinuxAssessment?.confidence === 'medium');
 
-              const confirmedNoLinux = noLinuxFromDeterministicText || noLinuxFromSteam;
+              const confirmedNoLinux = noLinuxFromDeterministicText || noLinuxFromSteam || noLinuxFromSteamCmd;
               const suggestsNoLinux = noLinuxFromAi && !confirmedNoLinux;
               const confirmedLinuxFromSteam = steamLinuxSupport === true;
+              const confirmedLinuxFromSteamCmd = steamCmdAssessment?.status === 'linux';
               const linuxYesFromAi =
                 aiLinuxAssessment?.linux_support === 'yes' &&
                 (aiLinuxAssessment?.confidence === 'high' || aiLinuxAssessment?.confidence === 'medium');
@@ -909,6 +1003,7 @@ jobs:
                 !confirmedNoLinux &&
                 !suggestsNoLinux &&
                 !confirmedLinuxFromSteam &&
+                !confirmedLinuxFromSteamCmd &&
                 !linuxYesFromAi;
 
               const NO_LINUX_LABEL = 'status: no linux support';
@@ -947,7 +1042,11 @@ jobs:
               if (isSteamNo) reasons.push('request is marked as non-Steam, so Steam platform checks were intentionally skipped');
               if (noLinuxFromSteam) reasons.push(`Steam API reports no Linux platform support for AppID ${steamAppId}`);
               if (confirmedLinuxFromSteam) reasons.push(`Steam API reports Linux platform support for AppID ${steamAppId}`);
-              if (steamAppIsServerTool) reasons.push(`AppID ${steamAppId} has no Steam store page (common for dedicated server tools) — Steam platform check inconclusive`);
+              if (steamAppIsServerTool) reasons.push(`AppID ${steamAppId} has no Steam store page (typical for dedicated server tool AppIDs) — Steam client platform check is not applicable to server support`);
+              if (noLinuxFromSteamCmd && steamCmdAssessment?.reason) reasons.push(steamCmdAssessment.reason);
+              if (confirmedLinuxFromSteamCmd && steamCmdAssessment?.reason) reasons.push(steamCmdAssessment.reason);
+              if (steamCmdAssessment?.status === 'unknown' && steamCmdAssessment?.reason) reasons.push(steamCmdAssessment.reason);
+              if (steamCmdAssessment?.status === 'error' && steamCmdAssessment?.reason) reasons.push(steamCmdAssessment.reason);
               if (noLinuxFromAi && aiLinuxAssessment?.reason) reasons.push(`AI analysis of provided documentation: ${aiLinuxAssessment.reason}`);
               if (linuxYesFromAi && aiLinuxAssessment?.reason) reasons.push(`AI analysis indicates Linux support: ${aiLinuxAssessment.reason}`);
               if (likelySupportedByCheckbox) reasons.push('requester confirmed Linux support via the form checkbox; no contradicting evidence found');
@@ -959,6 +1058,8 @@ jobs:
                 verdictLine = 'This server request **may not** have native Linux support based on submitted evidence.';
               } else if (confirmedLinuxFromSteam) {
                 verdictLine = 'Steam metadata confirms this server has Linux platform support.';
+              } else if (confirmedLinuxFromSteamCmd) {
+                verdictLine = 'SteamCMD metadata indicates this server has Linux platform/depot support.';
               } else if (linuxYesFromAi) {
                 verdictLine = 'Submitted documentation appears to indicate Linux server support.';
               } else if (likelySupportedByCheckbox) {
@@ -975,16 +1076,33 @@ jobs:
                       ? 'Inconclusive — AppID has no store page (typical for dedicated server tools)'
                       : 'No definitive platform response';
 
+              const steamCmdStatus = isSteamNo
+                ? 'Not applicable'
+                : !steamAppId
+                  ? 'Skipped until valid AppID is provided'
+                  : steamLinuxSupport !== null
+                    ? 'Not needed (Steam API returned a definitive result)'
+                    : steamCmdAssessment?.status === 'linux'
+                      ? 'Linux platform/depot metadata found'
+                      : steamCmdAssessment?.status === 'windows-only'
+                        ? 'Windows-only platform metadata found'
+                        : steamCmdAssessment?.status === 'unknown'
+                          ? 'No clear Linux server metadata found'
+                          : steamCmdAssessment?.status === 'error'
+                            ? 'Lookup failed'
+                            : 'Not run';
+
               const steamBlock = isSteamNo
                 ? '**Steam:** No (non-Steam request)\n**Steam API:** Not applicable\n\n'
                 : steamAppId
                   ? `**Steam:** ${isSteamYes ? 'Yes' : 'Unspecified'}\n` +
                     `**Steam AppID:** ${steamAppId}\n` +
                     `**Steam API:** ${steamApiStatus}\n` +
+                    `**SteamCMD:** ${steamCmdStatus}\n` +
                     `**SteamDB:** ${steamDbLink}\n\n`
                   : `**Steam:** ${isSteamYes ? 'Yes' : 'Unspecified'}\n` +
                     '**Steam AppID:** Not provided in the issue form.\n' +
-                    (isSteamYes ? '**Steam API:** Skipped until valid AppID is provided.\n\n' : '\n');
+                    (isSteamYes ? '**Steam API:** Skipped until valid AppID is provided.\n**SteamCMD:** Skipped until valid AppID is provided.\n\n' : '\n');
 
               const linuxCommentBody =
                 `${LINUX_MARKER}\n` +
@@ -999,7 +1117,7 @@ jobs:
                 `- Official Linux dedicated server documentation\n` +
                 `- Linux server binaries or release notes\n` +
                 `- Linux startup instructions or commands\n\n` +
-                `_This check was performed automatically using Steam API and submitted issue details (with AI assistance for document interpretation)._`;
+                `_This check was performed automatically using Steam API, SteamCMD, and submitted issue details (with AI assistance for document interpretation)._`;
 
               try {
                 const allComments = await github.paginate(github.rest.issues.listComments, {