|
|
@@ -0,0 +1,2304 @@
|
|
|
+name: Issue Triage & Automation
|
|
|
+on:
|
|
|
+ workflow_dispatch:
|
|
|
+ inputs:
|
|
|
+ issue_state:
|
|
|
+ description: Issue state to backfill
|
|
|
+ required: true
|
|
|
+ default: all
|
|
|
+ type: choice
|
|
|
+ options:
|
|
|
+ - all
|
|
|
+ - open
|
|
|
+ - closed
|
|
|
+ limit:
|
|
|
+ description: Max issues to process (0 = all)
|
|
|
+ required: true
|
|
|
+ default: "0"
|
|
|
+ type: string
|
|
|
+ ai_game_fallback:
|
|
|
+ description: Use AI only when deterministic game mapping finds no game
|
|
|
+ required: true
|
|
|
+ default: "false"
|
|
|
+ type: choice
|
|
|
+ options:
|
|
|
+ - "false"
|
|
|
+ - "true"
|
|
|
+ issues:
|
|
|
+ types:
|
|
|
+ - opened
|
|
|
+ - edited
|
|
|
+ - reopened
|
|
|
+ - labeled
|
|
|
+ - unlabeled
|
|
|
+ - assigned
|
|
|
+ - unassigned
|
|
|
+ - milestoned
|
|
|
+ - demilestoned
|
|
|
+ - transferred
|
|
|
+ - pinned
|
|
|
+ - unpinned
|
|
|
+ issue_comment:
|
|
|
+ types:
|
|
|
+ - created
|
|
|
+ - edited
|
|
|
+ - deleted
|
|
|
+ pull_request:
|
|
|
+ types:
|
|
|
+ - opened
|
|
|
+ - edited
|
|
|
+ - synchronize
|
|
|
+ - reopened
|
|
|
+ push:
|
|
|
+ branches:
|
|
|
+ - master
|
|
|
+ - develop
|
|
|
+ paths:
|
|
|
+ - "lgsm/data/serverlist.csv"
|
|
|
+
|
|
|
+permissions:
|
|
|
+ issues: write
|
|
|
+ pull-requests: write
|
|
|
+ contents: read
|
|
|
+ models: read
|
|
|
+
|
|
|
+env:
|
|
|
+ FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: "true"
|
|
|
+
|
|
|
+jobs:
|
|
|
+ issue-regex-labeler:
|
|
|
+ if: github.repository_owner == 'GameServerManagers' && github.event_name == 'issues' && (github.event.action == 'opened' || github.event.action == 'edited')
|
|
|
+ runs-on: ubuntu-latest
|
|
|
+ steps:
|
|
|
+ - name: Issue Labeler
|
|
|
+ uses: github/issue-labeler@v3.4
|
|
|
+ with:
|
|
|
+ repo-token: "${{ secrets.GITHUB_TOKEN }}"
|
|
|
+ configuration-path: .github/labeler.yml
|
|
|
+ enable-versioned-regex: 0
|
|
|
+ include-title: 1
|
|
|
+ sync-labels: 0
|
|
|
+
|
|
|
+ issue-ai-maintenance:
|
|
|
+ if: github.repository_owner == 'GameServerManagers' && (github.event_name == 'issues' || github.event_name == 'issue_comment')
|
|
|
+ runs-on: ubuntu-latest
|
|
|
+ steps:
|
|
|
+ - name: Reconcile issue labels and AI triage
|
|
|
+ uses: actions/github-script@v9
|
|
|
+ env:
|
|
|
+ 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;
|
|
|
+ const action = context.payload.action;
|
|
|
+ const issueNumber = context.payload.issue?.number;
|
|
|
+ const AI_MARKER = '<!-- ai-triage -->';
|
|
|
+
|
|
|
+ if (!issueNumber) {
|
|
|
+ console.log('No issue number found in payload.');
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Avoid bot-to-bot relabel loops on label events.
|
|
|
+ if (
|
|
|
+ eventName === 'issues' &&
|
|
|
+ ['labeled', 'unlabeled'].includes(action) &&
|
|
|
+ context.actor === 'github-actions[bot]'
|
|
|
+ ) {
|
|
|
+ console.log('Skipping self-triggered label event.');
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ const issueResp = await github.rest.issues.get({
|
|
|
+ owner,
|
|
|
+ repo,
|
|
|
+ issue_number: issueNumber,
|
|
|
+ });
|
|
|
+ const issue = issueResp.data;
|
|
|
+ const title = issue.title || '';
|
|
|
+ const body = issue.body || '';
|
|
|
+ const existingLabels = new Set((issue.labels || []).map((l) => l.name).filter(Boolean));
|
|
|
+
|
|
|
+ function parseTriageResponse(raw) {
|
|
|
+ const input = (raw || '').trim();
|
|
|
+ if (!input) return {};
|
|
|
+
|
|
|
+ const candidates = [input];
|
|
|
+ const fenced = input.match(/```(?:json)?\s*([\s\S]*?)```/i);
|
|
|
+ if (fenced?.[1]) candidates.push(fenced[1].trim());
|
|
|
+
|
|
|
+ const firstBrace = input.indexOf('{');
|
|
|
+ const lastBrace = input.lastIndexOf('}');
|
|
|
+ if (firstBrace !== -1 && lastBrace > firstBrace) {
|
|
|
+ candidates.push(input.slice(firstBrace, lastBrace + 1));
|
|
|
+ }
|
|
|
+
|
|
|
+ for (const candidate of candidates) {
|
|
|
+ try {
|
|
|
+ return JSON.parse(candidate);
|
|
|
+ } catch (_err) {
|
|
|
+ // Continue trying fallbacks.
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return {};
|
|
|
+ }
|
|
|
+
|
|
|
+ function extractSection(sectionName) {
|
|
|
+ const escaped = sectionName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
|
|
|
+ const re = new RegExp(`### ${escaped}\\n\\n([\\s\\S]*?)(\\n### |$)`, 'i');
|
|
|
+ return (body.match(re)?.[1] || '').trim();
|
|
|
+ }
|
|
|
+
|
|
|
+ function normalizeName(value) {
|
|
|
+ return (value || '')
|
|
|
+ .toLowerCase()
|
|
|
+ .replace(/[’'`]/g, '')
|
|
|
+ .replace(/[^a-z0-9]+/g, ' ')
|
|
|
+ .trim();
|
|
|
+ }
|
|
|
+
|
|
|
+ function parseGameCandidates(gameField) {
|
|
|
+ if (!gameField || /^_?no response_?$/i.test(gameField)) {
|
|
|
+ return [];
|
|
|
+ }
|
|
|
+ return gameField
|
|
|
+ .replace(/\(.*?\)/g, ' ')
|
|
|
+ .split(/\n|,|\s+&\s+|\s+and\s+|\//i)
|
|
|
+ .map((v) => v.trim())
|
|
|
+ .filter(Boolean);
|
|
|
+ }
|
|
|
+
|
|
|
+ function findGamesFromText(text, gameAliasToLabel, gameAliasToScript) {
|
|
|
+ const labels = new Set();
|
|
|
+ const scripts = new Set();
|
|
|
+ const normalizedText = normalizeName(text);
|
|
|
+ if (!normalizedText) return { labels, scripts };
|
|
|
+
|
|
|
+ const escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
|
|
|
+ const aliases = [];
|
|
|
+ for (const [alias, label] of gameAliasToLabel.entries()) {
|
|
|
+ if (alias.length < 3) continue;
|
|
|
+ aliases.push({ alias, label, script: gameAliasToScript.get(alias) || null });
|
|
|
+ }
|
|
|
+
|
|
|
+ // Prefer longer aliases first so "killing floor 2" does not also match "killing floor".
|
|
|
+ aliases.sort((a, b) => b.alias.length - a.alias.length);
|
|
|
+
|
|
|
+ const usedRanges = [];
|
|
|
+ const isOverlapping = (start, end) =>
|
|
|
+ usedRanges.some((range) => start < range.end && end > range.start);
|
|
|
+
|
|
|
+ for (const entry of aliases) {
|
|
|
+ const pattern = new RegExp(`\\b${escapeRegex(entry.alias).replace(/\\ /g, '\\s+')}\\b`, 'g');
|
|
|
+ let match;
|
|
|
+ while ((match = pattern.exec(normalizedText)) !== null) {
|
|
|
+ const start = match.index;
|
|
|
+ const end = start + match[0].length;
|
|
|
+ if (isOverlapping(start, end)) continue;
|
|
|
+
|
|
|
+ labels.add(entry.label);
|
|
|
+ if (entry.script) scripts.add(entry.script);
|
|
|
+ usedRanges.push({ start, end });
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return { labels, scripts };
|
|
|
+ }
|
|
|
+
|
|
|
+ function hasAliasHitForLabel(text, targetLabel, gameAliasToLabel) {
|
|
|
+ const normalizedText = normalizeName(text);
|
|
|
+ if (!normalizedText || !targetLabel) return false;
|
|
|
+
|
|
|
+ const paddedText = ` ${normalizedText} `;
|
|
|
+ for (const [alias, label] of gameAliasToLabel.entries()) {
|
|
|
+ if (label !== targetLabel) continue;
|
|
|
+ if (alias.length < 3) continue;
|
|
|
+ if (paddedText.includes(` ${alias} `)) return true;
|
|
|
+
|
|
|
+ // Allow obvious joined-word variants for multi-token aliases
|
|
|
+ // (e.g., "counter strike 1 6" matching "counterstrike 1.6").
|
|
|
+ const aliasTokens = alias.split(/\s+/).filter(Boolean);
|
|
|
+ if (aliasTokens.length > 1) {
|
|
|
+ const escapedTokens = aliasTokens.map((token) =>
|
|
|
+ token.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
|
|
|
+ );
|
|
|
+ const flexibleAliasPattern = new RegExp(`\\b${escapedTokens.join('\\s*')}\\b`);
|
|
|
+ if (flexibleAliasPattern.test(normalizedText)) return true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ 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/);
|
|
|
+ for (let i = 1; i < lines.length; i += 1) {
|
|
|
+ const line = lines[i]?.trim();
|
|
|
+ if (!line) continue;
|
|
|
+ const parts = line.split(',');
|
|
|
+ if (parts.length < 3) continue;
|
|
|
+ rows.push({
|
|
|
+ shortname: parts[0].trim(),
|
|
|
+ gameservername: parts[1].trim(),
|
|
|
+ gamename: parts[2].trim(),
|
|
|
+ });
|
|
|
+ }
|
|
|
+ return rows;
|
|
|
+ }
|
|
|
+ function inferTypeFromTitle(issueTitle) {
|
|
|
+ if (/^\[bug\]/i.test(issueTitle)) return 'type: bug';
|
|
|
+ if (/\bserver\s+request\b/i.test(issueTitle)) return 'type: game server request';
|
|
|
+ const hasBracketPrefix = /^\[[^\]]+\]/.test(issueTitle || '');
|
|
|
+ const isServerCreation =
|
|
|
+ /\bserver\s+creation\b/i.test(issueTitle) ||
|
|
|
+ (hasBracketPrefix && /\bcreation\b/i.test(issueTitle));
|
|
|
+ const isServerSupportRequest =
|
|
|
+ /\bserver\s+support\b/i.test(issueTitle) ||
|
|
|
+ (/\bsupport\s+for\b/i.test(issueTitle) && /\bserver\b/i.test(issueTitle));
|
|
|
+ if (isServerCreation || isServerSupportRequest) return 'type: game server request';
|
|
|
+ if (/^\[feature\]/i.test(issueTitle)) return 'type: feature';
|
|
|
+ if (/^\[server request\]/i.test(issueTitle)) return 'type: game server request';
|
|
|
+ if (/^\[docs?\]/i.test(issueTitle)) return 'type: docs';
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+
|
|
|
+ function inferDesiredType(issueTitle, labelNames) {
|
|
|
+ const titleType = inferTypeFromTitle(issueTitle);
|
|
|
+ if (titleType) return titleType;
|
|
|
+
|
|
|
+ // Prefer server requests over generic feature when both labels exist.
|
|
|
+ if (labelNames.has('type: game server request')) return 'type: game server request';
|
|
|
+
|
|
|
+ for (const label of [
|
|
|
+ 'type: bug',
|
|
|
+ 'type: feature',
|
|
|
+ 'type: game server request',
|
|
|
+ 'type: docs',
|
|
|
+ ]) {
|
|
|
+ if (labelNames.has(label)) return label;
|
|
|
+ }
|
|
|
+
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+
|
|
|
+ function inferIssueTypeNameFromDesiredType(typeLabel) {
|
|
|
+ if (typeLabel === 'type: bug') return 'Bug';
|
|
|
+ if (typeLabel === 'type: feature') return 'Feature';
|
|
|
+ if (typeLabel === 'type: game server request') return 'Server Request';
|
|
|
+ if (typeLabel === 'type: docs') return 'Task';
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+
|
|
|
+ function parseCommandSelections(sectionValue) {
|
|
|
+ const selected = new Set();
|
|
|
+ const re = /command:\s*([a-z-]+)/gi;
|
|
|
+ let m;
|
|
|
+ while ((m = re.exec(sectionValue || '')) !== null) {
|
|
|
+ let value = m[1].toLowerCase();
|
|
|
+ if (value.startsWith('mods-')) value = 'mods';
|
|
|
+ if (value === 'auto-update') value = 'update';
|
|
|
+ selected.add(`command: ${value}`);
|
|
|
+ }
|
|
|
+ return selected;
|
|
|
+ }
|
|
|
+
|
|
|
+ function parseDistroSelections(sectionValue) {
|
|
|
+ const text = sectionValue || '';
|
|
|
+ const selected = new Set();
|
|
|
+ if (/\bUbuntu\b/i.test(text)) selected.add('distro: Ubuntu');
|
|
|
+ if (/\bDebian\b/i.test(text)) selected.add('distro: Debian');
|
|
|
+ if (/\bAlmaLinux\b/i.test(text)) selected.add('distro: AlmaLinux');
|
|
|
+ if (/\bRocky\b/i.test(text)) selected.add('distro: Rocky Linux');
|
|
|
+ if (/\bCentOS\b/i.test(text)) selected.add('distro: CentOS');
|
|
|
+ if (/\bFedora\b/i.test(text)) selected.add('distro: Fedora');
|
|
|
+ if (/\bopenSUSE\b/i.test(text)) selected.add('distro: openSUSE');
|
|
|
+ if (/\bArch Linux\b/i.test(text)) selected.add('distro: Arch Linux');
|
|
|
+ if (/\bSlackware\b/i.test(text)) selected.add('distro: Slackware');
|
|
|
+ return selected;
|
|
|
+ }
|
|
|
+
|
|
|
+ const repoLabels = await github.paginate(github.rest.issues.listLabelsForRepo, {
|
|
|
+ owner,
|
|
|
+ repo,
|
|
|
+ per_page: 100,
|
|
|
+ });
|
|
|
+
|
|
|
+ const gameLabelByNormalized = new Map();
|
|
|
+ for (const label of repoLabels) {
|
|
|
+ if (!label.name.startsWith('game: ')) continue;
|
|
|
+ gameLabelByNormalized.set(normalizeName(label.name.slice(6)), label.name);
|
|
|
+ }
|
|
|
+ const existingEngineLabels = new Set(
|
|
|
+ repoLabels.map((label) => label.name).filter((name) => name.startsWith('engine: '))
|
|
|
+ );
|
|
|
+
|
|
|
+ const gameAliasToLabel = new Map();
|
|
|
+ const gameAliasToScript = new Map();
|
|
|
+ const engineByScript = new Map();
|
|
|
+ for (const [normalizedGameName, label] of gameLabelByNormalized.entries()) {
|
|
|
+ gameAliasToLabel.set(normalizedGameName, label);
|
|
|
+ }
|
|
|
+
|
|
|
+ try {
|
|
|
+ const serverlistContent = await github.rest.repos.getContent({
|
|
|
+ owner,
|
|
|
+ repo,
|
|
|
+ path: 'lgsm/data/serverlist.csv',
|
|
|
+ });
|
|
|
+ const encoded = serverlistContent.data?.content || '';
|
|
|
+ const csvText = Buffer.from(encoded, 'base64').toString('utf8');
|
|
|
+ const serverRows = parseServerlistCsv(csvText);
|
|
|
+
|
|
|
+ for (const row of serverRows) {
|
|
|
+ const canonicalLabel = gameLabelByNormalized.get(normalizeName(row.gamename));
|
|
|
+ if (!canonicalLabel) continue;
|
|
|
+
|
|
|
+ for (const alias of [row.shortname, row.gameservername, row.gamename]) {
|
|
|
+ const key = normalizeName(alias);
|
|
|
+ if (!key) continue;
|
|
|
+ gameAliasToLabel.set(key, canonicalLabel);
|
|
|
+ gameAliasToScript.set(key, row.gameservername);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } catch (err) {
|
|
|
+ console.log(`Could not load serverlist aliases: ${err.message}`);
|
|
|
+ }
|
|
|
+
|
|
|
+ async function ensureEngineLabel(engineLabel) {
|
|
|
+ if (existingEngineLabels.has(engineLabel)) return;
|
|
|
+ try {
|
|
|
+ await github.rest.issues.createLabel({
|
|
|
+ owner,
|
|
|
+ repo,
|
|
|
+ name: engineLabel,
|
|
|
+ color: '000000',
|
|
|
+ description: `Issues related to ${engineLabel.slice(8)} engine`,
|
|
|
+ });
|
|
|
+ existingEngineLabels.add(engineLabel);
|
|
|
+ } catch (err) {
|
|
|
+ if (err.status === 422) {
|
|
|
+ existingEngineLabels.add(engineLabel);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ console.log(`Could not create engine label "${engineLabel}": ${err.message}`);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ async function getEngineForScript(scriptName) {
|
|
|
+ if (!scriptName) return null;
|
|
|
+ if (engineByScript.has(scriptName)) {
|
|
|
+ return engineByScript.get(scriptName);
|
|
|
+ }
|
|
|
+ try {
|
|
|
+ const cfgContent = await github.rest.repos.getContent({
|
|
|
+ owner,
|
|
|
+ repo,
|
|
|
+ path: `lgsm/config-default/config-lgsm/${scriptName}/_default.cfg`,
|
|
|
+ });
|
|
|
+ const encoded = cfgContent.data?.content || '';
|
|
|
+ const cfgText = Buffer.from(encoded, 'base64').toString('utf8');
|
|
|
+ const engine = cfgText.match(/^engine="([^"]+)"/m)?.[1] || null;
|
|
|
+ engineByScript.set(scriptName, engine);
|
|
|
+ return engine;
|
|
|
+ } catch (err) {
|
|
|
+ console.log(`Could not detect engine for ${scriptName}: ${err.message}`);
|
|
|
+ engineByScript.set(scriptName, null);
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ const labelsToAdd = new Set();
|
|
|
+ const labelsToRemove = new Set();
|
|
|
+
|
|
|
+ // Deterministic reconciliation on every interaction.
|
|
|
+ const desiredType = inferDesiredType(title, existingLabels);
|
|
|
+ if (desiredType) {
|
|
|
+ labelsToAdd.add(desiredType);
|
|
|
+ for (const label of existingLabels) {
|
|
|
+ if (label.startsWith('type: ') && label !== desiredType) {
|
|
|
+ labelsToRemove.add(label);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ const desiredIssueTypeName = inferIssueTypeNameFromDesiredType(desiredType);
|
|
|
+ if (desiredIssueTypeName) {
|
|
|
+ try {
|
|
|
+ const issueTypeData = await github.graphql(
|
|
|
+ `query($owner:String!,$repo:String!,$number:Int!){
|
|
|
+ repository(owner:$owner,name:$repo){
|
|
|
+ issueTypes(first:20){ nodes { id name } }
|
|
|
+ issue(number:$number){ id issueType { id name } }
|
|
|
+ }
|
|
|
+ }`,
|
|
|
+ { owner, repo, number: issueNumber }
|
|
|
+ );
|
|
|
+
|
|
|
+ const issueNode = issueTypeData.repository?.issue;
|
|
|
+ const issueTypes = issueTypeData.repository?.issueTypes?.nodes || [];
|
|
|
+ const desiredIssueType = issueTypes.find((t) => t.name === desiredIssueTypeName);
|
|
|
+
|
|
|
+ if (issueNode?.id && desiredIssueType?.id && issueNode.issueType?.id !== desiredIssueType.id) {
|
|
|
+ await github.graphql(
|
|
|
+ `mutation($id:ID!,$issueTypeId:ID!){
|
|
|
+ updateIssue(input:{id:$id,issueTypeId:$issueTypeId}){
|
|
|
+ issue { id number issueType { id name } }
|
|
|
+ }
|
|
|
+ }`,
|
|
|
+ { id: issueNode.id, issueTypeId: desiredIssueType.id }
|
|
|
+ );
|
|
|
+ }
|
|
|
+ } catch (err) {
|
|
|
+ console.log(`Could not sync Issue Type: ${err.message}`);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ const commandSection = extractSection('Command');
|
|
|
+ const desiredCommands = parseCommandSelections(commandSection);
|
|
|
+ if (desiredCommands.size > 0) {
|
|
|
+ for (const label of desiredCommands) labelsToAdd.add(label);
|
|
|
+ for (const label of existingLabels) {
|
|
|
+ if (label.startsWith('command: ') && !desiredCommands.has(label)) {
|
|
|
+ labelsToRemove.add(label);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ const distroSection = extractSection('Linux distro');
|
|
|
+ const desiredDistros = parseDistroSelections(distroSection);
|
|
|
+ if (desiredDistros.size > 0) {
|
|
|
+ for (const label of desiredDistros) labelsToAdd.add(label);
|
|
|
+ for (const label of existingLabels) {
|
|
|
+ if (label.startsWith('distro: ') && !desiredDistros.has(label)) {
|
|
|
+ labelsToRemove.add(label);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ const tmuxContextPattern = /\b(tmuxception|check_tmuxception)\b/i;
|
|
|
+ if (existingLabels.has('info: tmux') && !tmuxContextPattern.test(`${title}\n${body}`)) {
|
|
|
+ labelsToRemove.add('info: tmux');
|
|
|
+ }
|
|
|
+
|
|
|
+ const desiredGames = new Set();
|
|
|
+ const desiredServerScripts = new Set();
|
|
|
+ // 'Game server' is the section name in server_request.yml; 'Game' is used in bug_report.yml.
|
|
|
+ const gameField = extractSection('Game server') || extractSection('Game');
|
|
|
+ const gameCandidates = parseGameCandidates(gameField);
|
|
|
+ const hasStructuredGameSelection = gameCandidates.length > 0;
|
|
|
+ for (const candidate of gameCandidates) {
|
|
|
+ const normalizedCandidate = normalizeName(candidate);
|
|
|
+ const mapped = gameAliasToLabel.get(normalizedCandidate) || gameLabelByNormalized.get(normalizedCandidate);
|
|
|
+ if (mapped) desiredGames.add(mapped);
|
|
|
+ const mappedScript = gameAliasToScript.get(normalizedCandidate);
|
|
|
+ if (mappedScript) desiredServerScripts.add(mappedScript);
|
|
|
+ }
|
|
|
+
|
|
|
+ // Legacy issues often have no form section; fall back to deterministic text matching.
|
|
|
+ // If a structured Game field exists but does not map, do not guess from free text.
|
|
|
+ if (desiredGames.size === 0 && !hasStructuredGameSelection) {
|
|
|
+ const fromText = findGamesFromText(`${title}\n${body}`, gameAliasToLabel, gameAliasToScript);
|
|
|
+ for (const label of fromText.labels) desiredGames.add(label);
|
|
|
+ for (const scriptName of fromText.scripts) desiredServerScripts.add(scriptName);
|
|
|
+ }
|
|
|
+
|
|
|
+ // AI advisory is only needed on issue opened/edited.
|
|
|
+ let triage = {};
|
|
|
+ let ranAi = false;
|
|
|
+ const shouldRunAi = eventName === 'issues' && ['opened', 'edited'].includes(action);
|
|
|
+ const shouldRunLinuxSupportCheck =
|
|
|
+ eventName === 'issues' &&
|
|
|
+ ['opened', 'edited', 'reopened', 'labeled', 'unlabeled'].includes(action);
|
|
|
+ if (shouldRunAi) {
|
|
|
+ ranAi = true;
|
|
|
+
|
|
|
+ const isShortBody = body.trim().length < 80;
|
|
|
+ if (isShortBody) {
|
|
|
+ labelsToAdd.add('needs: more info');
|
|
|
+ } else {
|
|
|
+ try {
|
|
|
+ const res = await fetch(
|
|
|
+ `https://models.github.ai/orgs/${owner}/inference/chat/completions`,
|
|
|
+ {
|
|
|
+ method: 'POST',
|
|
|
+ headers: {
|
|
|
+ Accept: 'application/vnd.github+json',
|
|
|
+ Authorization: `Bearer ${process.env.GITHUB_TOKEN}`,
|
|
|
+ 'X-GitHub-Api-Version': '2026-03-10',
|
|
|
+ 'Content-Type': 'application/json',
|
|
|
+ },
|
|
|
+ body: JSON.stringify({
|
|
|
+ model: 'openai/gpt-4.1-mini',
|
|
|
+ temperature: 0.1,
|
|
|
+ max_tokens: 400,
|
|
|
+ messages: [
|
|
|
+ {
|
|
|
+ role: 'system',
|
|
|
+ content:
|
|
|
+ 'You are a triage assistant for LinuxGSM, an open-source Linux game server manager. ' +
|
|
|
+ 'Return only JSON. Analyze issue quality, suggest missing info, detect game names, and suggest contextual labels ' +
|
|
|
+ 'only when highly certain. Never set type: docs just because docs links are mentioned.',
|
|
|
+ },
|
|
|
+ {
|
|
|
+ role: 'user',
|
|
|
+ content:
|
|
|
+ `Title: ${title}\n\nBody:\n${body.slice(0, 3000)}\n\n` +
|
|
|
+ 'Return JSON schema:\n' +
|
|
|
+ '{\n' +
|
|
|
+ ' "quality": "good" | "ok" | "poor",\n' +
|
|
|
+ ' "missing_info": ["list of specific missing fields"],\n' +
|
|
|
+ ' "detected_game": "canonical game name if one is mentioned, or null",\n' +
|
|
|
+ ' "game_confidence": "high" | "medium" | "low" | null,\n' +
|
|
|
+ ' "context_labels": ["labels"],\n' +
|
|
|
+ ' "context_confidence": "high" | "medium" | "low" | null,\n' +
|
|
|
+ ' "game_note": "string",\n' +
|
|
|
+ ' "comment": "string"\n' +
|
|
|
+ '}',
|
|
|
+ },
|
|
|
+ ],
|
|
|
+ }),
|
|
|
+ }
|
|
|
+ );
|
|
|
+
|
|
|
+ if (res.ok) {
|
|
|
+ const data = await res.json();
|
|
|
+ const raw = data.choices?.[0]?.message?.content || '{}';
|
|
|
+ triage = parseTriageResponse(raw);
|
|
|
+ } else {
|
|
|
+ console.log(`GitHub Models returned ${res.status} - skipping AI triage.`);
|
|
|
+ }
|
|
|
+ } catch (err) {
|
|
|
+ console.log('AI triage skipped:', err.message);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ const allowedContextLabels = new Set([
|
|
|
+ 'type: docs',
|
|
|
+ 'info: docs',
|
|
|
+ 'info: dependency',
|
|
|
+ 'info: docker',
|
|
|
+ 'info: email',
|
|
|
+ 'info: query',
|
|
|
+ 'info: steamcmd',
|
|
|
+ 'info: systemd',
|
|
|
+ 'info: website',
|
|
|
+ 'info: alerts',
|
|
|
+ ]);
|
|
|
+
|
|
|
+ const isPoor = triage?.quality === 'poor';
|
|
|
+ const missing = Array.isArray(triage?.missing_info) ? triage.missing_info : [];
|
|
|
+ const hasIssues = isPoor || missing.length > 0;
|
|
|
+
|
|
|
+ // Fallback to AI-detected game only when no structured Game field exists.
|
|
|
+ const detectedGame = triage?.detected_game;
|
|
|
+ const gameConfidence = triage?.game_confidence;
|
|
|
+ if (desiredGames.size === 0 && !hasStructuredGameSelection && detectedGame && gameConfidence === 'high') {
|
|
|
+ const normalizedDetectedGame = normalizeName(detectedGame);
|
|
|
+ const mapped = gameLabelByNormalized.get(normalizedDetectedGame);
|
|
|
+ if (mapped) {
|
|
|
+ desiredGames.add(mapped);
|
|
|
+ }
|
|
|
+ const mappedScript = gameAliasToScript.get(normalizedDetectedGame);
|
|
|
+ if (mappedScript) desiredServerScripts.add(mappedScript);
|
|
|
+ }
|
|
|
+
|
|
|
+ // Resolve server scripts from canonical game labels when only labels were mapped.
|
|
|
+ for (const gameLabel of desiredGames) {
|
|
|
+ const gameName = gameLabel.slice(6);
|
|
|
+ const mappedScript = gameAliasToScript.get(normalizeName(gameName));
|
|
|
+ if (mappedScript) desiredServerScripts.add(mappedScript);
|
|
|
+ }
|
|
|
+
|
|
|
+ const desiredEngineLabels = new Set();
|
|
|
+ for (const scriptName of desiredServerScripts) {
|
|
|
+ const engine = await getEngineForScript(scriptName);
|
|
|
+ if (!engine) continue;
|
|
|
+ const engineLabel = `engine: ${engine}`;
|
|
|
+ await ensureEngineLabel(engineLabel);
|
|
|
+ desiredEngineLabels.add(engineLabel);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (desiredEngineLabels.size > 0) {
|
|
|
+ for (const label of desiredEngineLabels) labelsToAdd.add(label);
|
|
|
+ for (const label of existingLabels) {
|
|
|
+ if (label.startsWith('engine: ') && !desiredEngineLabels.has(label)) {
|
|
|
+ labelsToRemove.add(label);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (desiredGames.size > 0) {
|
|
|
+ for (const label of desiredGames) labelsToAdd.add(label);
|
|
|
+ if (hasStructuredGameSelection) {
|
|
|
+ for (const label of existingLabels) {
|
|
|
+ if (label.startsWith('game: ') && !desiredGames.has(label)) {
|
|
|
+ labelsToRemove.add(label);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ // For legacy issues without structured game selection, only prune stale
|
|
|
+ // broader labels when a more specific inferred game label exists.
|
|
|
+ const desiredGameNamesNormalized = new Set(
|
|
|
+ [...desiredGames].map((label) => normalizeName(label.slice(6)))
|
|
|
+ );
|
|
|
+ for (const label of existingLabels) {
|
|
|
+ if (!label.startsWith('game: ') || desiredGames.has(label)) continue;
|
|
|
+ const existingGameName = normalizeName(label.slice(6));
|
|
|
+ const isBroaderOverlap = [...desiredGameNamesNormalized].some(
|
|
|
+ (desiredName) => desiredName !== existingGameName && desiredName.startsWith(`${existingGameName} `)
|
|
|
+ );
|
|
|
+ if (isBroaderOverlap) {
|
|
|
+ labelsToRemove.add(label);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (triage?.context_confidence === 'high') {
|
|
|
+ const contextLabels = Array.isArray(triage.context_labels) ? triage.context_labels : [];
|
|
|
+ for (const label of contextLabels) {
|
|
|
+ if (!allowedContextLabels.has(label)) continue;
|
|
|
+ if (
|
|
|
+ label === 'type: docs' &&
|
|
|
+ (existingLabels.has('type: game server request') || desiredType === 'type: game server request')
|
|
|
+ ) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ labelsToAdd.add(label);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (ranAi && hasIssues) {
|
|
|
+ labelsToAdd.add('needs: more info');
|
|
|
+ }
|
|
|
+
|
|
|
+ if (ranAi && !hasIssues && existingLabels.has('needs: more info')) {
|
|
|
+ labelsToRemove.add('needs: more info');
|
|
|
+ }
|
|
|
+
|
|
|
+ // Avoid pointless API calls.
|
|
|
+ const finalAdds = [...labelsToAdd].filter((label) => !existingLabels.has(label));
|
|
|
+ const finalRemoves = [...labelsToRemove].filter((label) => existingLabels.has(label));
|
|
|
+
|
|
|
+ for (const label of finalRemoves) {
|
|
|
+ try {
|
|
|
+ await github.rest.issues.removeLabel({
|
|
|
+ owner,
|
|
|
+ repo,
|
|
|
+ issue_number: issueNumber,
|
|
|
+ name: label,
|
|
|
+ });
|
|
|
+ console.log(`Removed label: ${label}`);
|
|
|
+ } catch (err) {
|
|
|
+ console.log(`Could not remove label "${label}": ${err.message}`);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ for (const label of finalAdds) {
|
|
|
+ try {
|
|
|
+ await github.rest.issues.addLabels({
|
|
|
+ owner,
|
|
|
+ repo,
|
|
|
+ issue_number: issueNumber,
|
|
|
+ labels: [label],
|
|
|
+ });
|
|
|
+ console.log(`Added label: ${label}`);
|
|
|
+ } catch (err) {
|
|
|
+ console.log(`Could not add label "${label}": ${err.message}`);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // Post AI comment only for opened/edited issues when useful.
|
|
|
+ if (ranAi) {
|
|
|
+ const gameNote = triage?.game_note || '';
|
|
|
+ const reporterComment = triage?.comment || '';
|
|
|
+
|
|
|
+ if (hasIssues || gameNote) {
|
|
|
+ const missingBlock = missing.length > 0
|
|
|
+ ? `\n\n**Missing information:**\n${missing.map((m) => `- ${m}`).join('\n')}`
|
|
|
+ : '';
|
|
|
+ const gameBlock = gameNote ? `\n\n**Game name note:** ${gameNote}` : '';
|
|
|
+
|
|
|
+ const triageCommentBody =
|
|
|
+ `${AI_MARKER}\n` +
|
|
|
+ `Thanks for opening this issue!\n\n` +
|
|
|
+ `${reporterComment}` +
|
|
|
+ `${missingBlock}` +
|
|
|
+ `${gameBlock}\n\n` +
|
|
|
+ `_This note was generated automatically by AI triage and may not be perfect. ` +
|
|
|
+ `A maintainer will review shortly._`;
|
|
|
+
|
|
|
+ try {
|
|
|
+ const comments = await github.paginate(github.rest.issues.listComments, {
|
|
|
+ owner,
|
|
|
+ repo,
|
|
|
+ issue_number: issueNumber,
|
|
|
+ per_page: 100,
|
|
|
+ });
|
|
|
+
|
|
|
+ const existingAiComment = [...comments].reverse().find(
|
|
|
+ (comment) => comment.user?.type === 'Bot' && comment.body?.includes(AI_MARKER)
|
|
|
+ );
|
|
|
+
|
|
|
+ if (existingAiComment) {
|
|
|
+ await github.rest.issues.updateComment({
|
|
|
+ owner,
|
|
|
+ repo,
|
|
|
+ comment_id: existingAiComment.id,
|
|
|
+ body: triageCommentBody,
|
|
|
+ });
|
|
|
+ } else {
|
|
|
+ await github.rest.issues.createComment({
|
|
|
+ owner,
|
|
|
+ repo,
|
|
|
+ issue_number: issueNumber,
|
|
|
+ body: triageCommentBody,
|
|
|
+ });
|
|
|
+ }
|
|
|
+ } catch (err) {
|
|
|
+ console.log('Could not post comment:', err.message);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // === Linux support verification for server request issues ===
|
|
|
+ // Runs only on opened/edited events to avoid reprocessing every label change.
|
|
|
+ const isServerRequest =
|
|
|
+ desiredType === 'type: game server request' ||
|
|
|
+ existingLabels.has('type: game server request') ||
|
|
|
+ /\[server request\]/i.test(title);
|
|
|
+
|
|
|
+ if (isServerRequest && shouldRunLinuxSupportCheck) {
|
|
|
+ const officialDocsSection = extractSection('Official dedicated server documentation');
|
|
|
+ const linuxBinaryProofSection = extractSection('Linux binary proof');
|
|
|
+ const guidesSection = extractSection('Guides');
|
|
|
+ const steamSection = extractSection('Steam').trim();
|
|
|
+ const isSteamNo = /^no$/i.test(steamSection);
|
|
|
+ const isSteamYes = /^yes$/i.test(steamSection);
|
|
|
+ const steamAppIdRaw = extractSection('Steam appid').trim();
|
|
|
+ const steamAppId = /^\d+$/.test(steamAppIdRaw) ? steamAppIdRaw : null;
|
|
|
+
|
|
|
+ const supportEvidenceText = [officialDocsSection, linuxBinaryProofSection, guidesSection]
|
|
|
+ .join('\n')
|
|
|
+ .trim();
|
|
|
+
|
|
|
+ // Deterministic textual checks to avoid trusting checkbox-only reports.
|
|
|
+ const windowsOnlyPatterns = [
|
|
|
+ /\bwindows\s+only\b/i,
|
|
|
+ /\bonly\s+windows\b/i,
|
|
|
+ /\bno\s+linux\s+support\b/i,
|
|
|
+ /\blinux\s+not\s+supported\b/i,
|
|
|
+ /\bdoes\s+not\s+support\s+linux\b/i,
|
|
|
+ ];
|
|
|
+ const wineRequiredPatterns = [
|
|
|
+ /\brequires?\s+wine\b/i,
|
|
|
+ /\buse\s+wine\b/i,
|
|
|
+ /\brun\s+with\s+wine\b/i,
|
|
|
+ /\bvia\s+wine\b/i,
|
|
|
+ /\bproton\b/i,
|
|
|
+ ];
|
|
|
+ const linuxEvidencePatterns = [
|
|
|
+ /\blinux\b/i,
|
|
|
+ /\bubuntu\b/i,
|
|
|
+ /\bdebian\b/i,
|
|
|
+ /\blinuxgsm\b/i,
|
|
|
+ /\bsteamcmd\s*\+app_update\b/i,
|
|
|
+ ];
|
|
|
+ const windowsBinaryHint = /\b\.exe\b/i.test(supportEvidenceText);
|
|
|
+ const deterministicWindowsOnly = windowsOnlyPatterns.some((re) => re.test(supportEvidenceText));
|
|
|
+ const deterministicWineRequired = wineRequiredPatterns.some((re) => re.test(supportEvidenceText));
|
|
|
+ const hasLinuxEvidence = linuxEvidencePatterns.some((re) => re.test(supportEvidenceText));
|
|
|
+
|
|
|
+ // Steam store API is client-app metadata only. It is kept for comment context,
|
|
|
+ // but it is NOT used to determine dedicated server Linux support.
|
|
|
+ let steamLinuxSupport = null; // true=yes, false=no, null=unknown/informational-only
|
|
|
+ let steamAppIsServerTool = false; // success:false from store API = likely server-tool AppID
|
|
|
+ let steamCmdAssessment = null;
|
|
|
+ if (steamAppId) {
|
|
|
+ try {
|
|
|
+ const steamRes = await fetch(
|
|
|
+ `https://store.steampowered.com/api/appdetails?appids=${steamAppId}&filters=platforms`,
|
|
|
+ { signal: AbortSignal.timeout(8000) }
|
|
|
+ );
|
|
|
+ if (steamRes.ok) {
|
|
|
+ const steamData = await steamRes.json();
|
|
|
+ const appData = steamData[steamAppId];
|
|
|
+ if (appData?.success && appData?.data?.platforms) {
|
|
|
+ steamLinuxSupport = appData.data.platforms.linux === true;
|
|
|
+ console.log(`Steam AppID ${steamAppId} linux=${steamLinuxSupport}`);
|
|
|
+ } else if (appData?.success === false) {
|
|
|
+ // Dedicated server tool AppIDs have no store page — inconclusive, not negative.
|
|
|
+ steamAppIsServerTool = true;
|
|
|
+ console.log(`Steam AppID ${steamAppId} has no store page (likely a server-tool AppID)`);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } catch (err) {
|
|
|
+ console.log(`Steam API check failed: ${err.message}`);
|
|
|
+ }
|
|
|
+
|
|
|
+ steamCmdAssessment = runSteamCmdLinuxCheck(steamAppId);
|
|
|
+ console.log(`SteamCMD assessment: ${JSON.stringify(steamCmdAssessment)}`);
|
|
|
+ }
|
|
|
+
|
|
|
+ // AI analysis of official docs/guides for Linux evidence.
|
|
|
+ let aiLinuxAssessment = null;
|
|
|
+ if (supportEvidenceText.length > 10) {
|
|
|
+ try {
|
|
|
+ const linuxAiRes = await fetch(
|
|
|
+ `https://models.github.ai/orgs/${owner}/inference/chat/completions`,
|
|
|
+ {
|
|
|
+ method: 'POST',
|
|
|
+ headers: {
|
|
|
+ Accept: 'application/vnd.github+json',
|
|
|
+ Authorization: `Bearer ${process.env.GITHUB_TOKEN}`,
|
|
|
+ 'X-GitHub-Api-Version': '2026-03-10',
|
|
|
+ 'Content-Type': 'application/json',
|
|
|
+ },
|
|
|
+ body: JSON.stringify({
|
|
|
+ model: 'openai/gpt-4.1-mini',
|
|
|
+ temperature: 0.1,
|
|
|
+ max_tokens: 200,
|
|
|
+ messages: [
|
|
|
+ {
|
|
|
+ role: 'system',
|
|
|
+ content:
|
|
|
+ 'You analyze game server documentation to determine Linux support. ' +
|
|
|
+ 'Return only JSON. Be conservative: only say "no" if evidence clearly shows Windows-only.',
|
|
|
+ },
|
|
|
+ {
|
|
|
+ role: 'user',
|
|
|
+ content:
|
|
|
+ `Analyze for native Linux dedicated server support:\n\nOfficial docs: ${officialDocsSection.slice(0, 400)}\nLinux binary proof: ${linuxBinaryProofSection.slice(0, 500)}\nGuides: ${guidesSection.slice(0, 800)}\n\n` +
|
|
|
+ 'Return JSON: {"linux_support": "yes"|"no"|"unknown", "confidence": "high"|"medium"|"low", "reason": "one sentence"}',
|
|
|
+ },
|
|
|
+ ],
|
|
|
+ }),
|
|
|
+ }
|
|
|
+ );
|
|
|
+ if (linuxAiRes.ok) {
|
|
|
+ const linuxAiData = await linuxAiRes.json();
|
|
|
+ const raw = linuxAiData.choices?.[0]?.message?.content || '{}';
|
|
|
+ aiLinuxAssessment = parseTriageResponse(raw);
|
|
|
+ console.log(`AI linux assessment: ${JSON.stringify(aiLinuxAssessment)}`);
|
|
|
+ }
|
|
|
+ } catch (err) {
|
|
|
+ console.log(`Linux AI check failed: ${err.message}`);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // Linux checkbox — used as soft positive evidence only when no negative signals exist.
|
|
|
+ // We don't fully trust it (users tick it without checking) but it matters when
|
|
|
+ // server-specific evidence is still inconclusive and no negative patterns were found.
|
|
|
+ const linuxCheckboxChecked = /\[x\]/i.test(extractSection('Linux support'));
|
|
|
+
|
|
|
+ // Determine verdict: confirmed = deterministic evidence; suggested = AI advisory.
|
|
|
+ const noLinuxFromDeterministicText =
|
|
|
+ deterministicWindowsOnly ||
|
|
|
+ (deterministicWineRequired && !hasLinuxEvidence) ||
|
|
|
+ (windowsBinaryHint && !hasLinuxEvidence);
|
|
|
+ const noLinuxFromSteamCmd = steamCmdAssessment?.status === 'windows-only';
|
|
|
+ const noLinuxFromAi =
|
|
|
+ aiLinuxAssessment?.linux_support === 'no' &&
|
|
|
+ (aiLinuxAssessment?.confidence === 'high' || aiLinuxAssessment?.confidence === 'medium');
|
|
|
+
|
|
|
+ const confirmedNoLinux = noLinuxFromDeterministicText || noLinuxFromSteamCmd;
|
|
|
+ const suggestsNoLinux = noLinuxFromAi && !confirmedNoLinux;
|
|
|
+ const confirmedLinuxFromSteamCmd = steamCmdAssessment?.status === 'linux';
|
|
|
+ const linuxYesFromAi =
|
|
|
+ aiLinuxAssessment?.linux_support === 'yes' &&
|
|
|
+ (aiLinuxAssessment?.confidence === 'high' || aiLinuxAssessment?.confidence === 'medium');
|
|
|
+ const confirmedLinuxSupport =
|
|
|
+ confirmedLinuxFromSteamCmd || linuxYesFromAi;
|
|
|
+ // Soft positive: checkbox checked with no negative signals and no definitive server evidence.
|
|
|
+ const likelySupportedByCheckbox =
|
|
|
+ linuxCheckboxChecked &&
|
|
|
+ !confirmedNoLinux &&
|
|
|
+ !suggestsNoLinux &&
|
|
|
+ !confirmedLinuxFromSteamCmd &&
|
|
|
+ !linuxYesFromAi;
|
|
|
+
|
|
|
+ const NO_LINUX_LABEL = 'status: no linux support';
|
|
|
+ const CONFIRMED_LINUX_LABEL = 'status: linux support confirmed';
|
|
|
+ const LINUX_MARKER = '<!-- linux-support-check -->';
|
|
|
+ const steamDbLink = steamAppId ? `https://steamdb.info/app/${steamAppId}/` : null;
|
|
|
+ const shouldApplyNoLinuxLabel = confirmedNoLinux || suggestsNoLinux;
|
|
|
+ const shouldApplyConfirmedLinuxLabel = confirmedLinuxSupport && !confirmedNoLinux && !suggestsNoLinux;
|
|
|
+
|
|
|
+ if (shouldApplyNoLinuxLabel) {
|
|
|
+ // Auto-create the label if it does not exist yet.
|
|
|
+ try {
|
|
|
+ await github.rest.issues.getLabel({ owner, repo, name: NO_LINUX_LABEL });
|
|
|
+ } catch (err) {
|
|
|
+ if (err.status === 404) {
|
|
|
+ try {
|
|
|
+ await github.rest.issues.createLabel({
|
|
|
+ owner,
|
|
|
+ repo,
|
|
|
+ name: NO_LINUX_LABEL,
|
|
|
+ color: 'd73a4a',
|
|
|
+ description: 'Game server does not have confirmed native Linux support',
|
|
|
+ });
|
|
|
+ } catch (createErr) {
|
|
|
+ console.log(`Could not create label "${NO_LINUX_LABEL}": ${createErr.message}`);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (!existingLabels.has(NO_LINUX_LABEL)) {
|
|
|
+ try {
|
|
|
+ await github.rest.issues.addLabels({ owner, repo, issue_number: issueNumber, labels: [NO_LINUX_LABEL] });
|
|
|
+ console.log(`Added label: ${NO_LINUX_LABEL}`);
|
|
|
+ } catch (err) {
|
|
|
+ console.log(`Could not add label "${NO_LINUX_LABEL}": ${err.message}`);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (existingLabels.has(CONFIRMED_LINUX_LABEL)) {
|
|
|
+ try {
|
|
|
+ await github.rest.issues.removeLabel({ owner, repo, issue_number: issueNumber, name: CONFIRMED_LINUX_LABEL });
|
|
|
+ console.log(`Removed label: ${CONFIRMED_LINUX_LABEL}`);
|
|
|
+ } catch (err) {
|
|
|
+ console.log(`Could not remove label "${CONFIRMED_LINUX_LABEL}": ${err.message}`);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else if (existingLabels.has(NO_LINUX_LABEL)) {
|
|
|
+ try {
|
|
|
+ await github.rest.issues.removeLabel({ owner, repo, issue_number: issueNumber, name: NO_LINUX_LABEL });
|
|
|
+ console.log(`Removed label: ${NO_LINUX_LABEL}`);
|
|
|
+ } catch (err) {
|
|
|
+ console.log(`Could not remove label "${NO_LINUX_LABEL}": ${err.message}`);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (shouldApplyConfirmedLinuxLabel) {
|
|
|
+ try {
|
|
|
+ await github.rest.issues.getLabel({ owner, repo, name: CONFIRMED_LINUX_LABEL });
|
|
|
+ } catch (err) {
|
|
|
+ if (err.status === 404) {
|
|
|
+ try {
|
|
|
+ await github.rest.issues.createLabel({
|
|
|
+ owner,
|
|
|
+ repo,
|
|
|
+ name: CONFIRMED_LINUX_LABEL,
|
|
|
+ color: '0e8a16',
|
|
|
+ description: 'Game server has confirmed native Linux support',
|
|
|
+ });
|
|
|
+ } catch (createErr) {
|
|
|
+ console.log(`Could not create label "${CONFIRMED_LINUX_LABEL}": ${createErr.message}`);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (!existingLabels.has(CONFIRMED_LINUX_LABEL)) {
|
|
|
+ try {
|
|
|
+ await github.rest.issues.addLabels({ owner, repo, issue_number: issueNumber, labels: [CONFIRMED_LINUX_LABEL] });
|
|
|
+ console.log(`Added label: ${CONFIRMED_LINUX_LABEL}`);
|
|
|
+ } catch (err) {
|
|
|
+ console.log(`Could not add label "${CONFIRMED_LINUX_LABEL}": ${err.message}`);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else if (existingLabels.has(CONFIRMED_LINUX_LABEL)) {
|
|
|
+ try {
|
|
|
+ await github.rest.issues.removeLabel({ owner, repo, issue_number: issueNumber, name: CONFIRMED_LINUX_LABEL });
|
|
|
+ console.log(`Removed label: ${CONFIRMED_LINUX_LABEL}`);
|
|
|
+ } catch (err) {
|
|
|
+ console.log(`Could not remove label "${CONFIRMED_LINUX_LABEL}": ${err.message}`);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ const reasons = [];
|
|
|
+ if (deterministicWindowsOnly) reasons.push('the provided docs/guides explicitly indicate Windows-only or no Linux support');
|
|
|
+ if (deterministicWineRequired && !hasLinuxEvidence) reasons.push('the provided docs/guides indicate a Wine/Proton requirement rather than native Linux binaries');
|
|
|
+ if (windowsBinaryHint && !hasLinuxEvidence) reasons.push('the provided evidence appears to reference Windows binaries (.exe) without clear Linux server evidence');
|
|
|
+ if (isSteamNo) reasons.push('request is marked as non-Steam, so Steam platform checks were intentionally skipped');
|
|
|
+ if (steamAppIsServerTool) reasons.push(`AppID ${steamAppId} has no Steam store page (typical for dedicated server tool AppIDs)`);
|
|
|
+ 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');
|
|
|
+
|
|
|
+ let verdictLine = 'Linux support could not be confirmed automatically from the submitted details.';
|
|
|
+ if (confirmedNoLinux) {
|
|
|
+ verdictLine = 'This server request does **not** appear to have native Linux support, which is required for LinuxGSM.';
|
|
|
+ } else if (suggestsNoLinux) {
|
|
|
+ verdictLine = 'This server request **may not** have native Linux support based on submitted evidence.';
|
|
|
+ } 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) {
|
|
|
+ verdictLine = 'Linux support is **likely** — the requester confirmed it and no contradicting evidence was found. A maintainer should verify before accepting.';
|
|
|
+ }
|
|
|
+
|
|
|
+ const steamApiStatus = isSteamNo
|
|
|
+ ? 'Not applicable'
|
|
|
+ : steamLinuxSupport === true
|
|
|
+ ? 'Client app marked Linux-supported (informational only)'
|
|
|
+ : steamLinuxSupport === false
|
|
|
+ ? 'Client app marked Linux-unsupported (informational only)'
|
|
|
+ : steamAppIsServerTool
|
|
|
+ ? 'No store page for this AppID (informational only)'
|
|
|
+ : 'No definitive platform response';
|
|
|
+
|
|
|
+ const steamCmdStatus = isSteamNo
|
|
|
+ ? 'Not applicable'
|
|
|
+ : !steamAppId
|
|
|
+ ? 'Skipped until valid AppID is provided'
|
|
|
+ : 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 Store API:** Not applicable\n\n'
|
|
|
+ : steamAppId
|
|
|
+ ? `**Steam:** ${isSteamYes ? 'Yes' : 'Unspecified'}\n` +
|
|
|
+ `**Steam AppID:** ${steamAppId}\n` +
|
|
|
+ `**Steam Store 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 Store API:** Skipped until valid AppID is provided.\n**SteamCMD:** Skipped until valid AppID is provided.\n\n' : '\n');
|
|
|
+
|
|
|
+ const linuxCommentHeader = shouldApplyConfirmedLinuxLabel
|
|
|
+ ? '**Linux Support Check** :rocket:'
|
|
|
+ : '**Linux Support Check**';
|
|
|
+ const confirmedLinuxLabelBlock = shouldApplyConfirmedLinuxLabel
|
|
|
+ ? `**Label applied:** ${CONFIRMED_LINUX_LABEL}\n\n`
|
|
|
+ : '';
|
|
|
+
|
|
|
+ const linuxCommentBody =
|
|
|
+ `${LINUX_MARKER}\n` +
|
|
|
+ `${linuxCommentHeader}\n\n` +
|
|
|
+ `${verdictLine}\n\n` +
|
|
|
+ `${confirmedLinuxLabelBlock}` +
|
|
|
+ `${steamBlock}` +
|
|
|
+ (reasons.length > 0
|
|
|
+ ? `**Evidence:**\n${reasons.map((r) => `- ${r}`).join('\n')}\n\n`
|
|
|
+ : '') +
|
|
|
+ `LinuxGSM only supports **native Linux dedicated servers**. Wine and Windows-only servers are not supported.\n\n` +
|
|
|
+ `If support is unclear, please provide:\n` +
|
|
|
+ `- 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 SteamCMD, submitted issue details, and AI assistance for document interpretation. Steam store data is shown only as client-app context and is not used to determine server support._`;
|
|
|
+
|
|
|
+ try {
|
|
|
+ const allComments = await github.paginate(github.rest.issues.listComments, {
|
|
|
+ owner,
|
|
|
+ repo,
|
|
|
+ issue_number: issueNumber,
|
|
|
+ per_page: 100,
|
|
|
+ });
|
|
|
+ const existingLinuxComment = [...allComments].reverse().find(
|
|
|
+ (c) => c.user?.type === 'Bot' && c.body?.includes(LINUX_MARKER)
|
|
|
+ );
|
|
|
+
|
|
|
+ if (existingLinuxComment) {
|
|
|
+ await github.rest.issues.updateComment({
|
|
|
+ owner,
|
|
|
+ repo,
|
|
|
+ comment_id: existingLinuxComment.id,
|
|
|
+ body: linuxCommentBody,
|
|
|
+ });
|
|
|
+ } else {
|
|
|
+ await github.rest.issues.createComment({
|
|
|
+ owner,
|
|
|
+ repo,
|
|
|
+ issue_number: issueNumber,
|
|
|
+ body: linuxCommentBody,
|
|
|
+ });
|
|
|
+ }
|
|
|
+ } catch (err) {
|
|
|
+ console.log(`Could not post Linux support comment: ${err.message}`);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ issue-potential-duplicates:
|
|
|
+ if: github.repository_owner == 'GameServerManagers' && github.event_name == 'issues' && (github.event.action == 'opened' || github.event.action == 'edited' || github.event.action == 'reopened')
|
|
|
+ runs-on: ubuntu-latest
|
|
|
+ steps:
|
|
|
+ - name: Detect potential duplicates
|
|
|
+ uses: actions/github-script@v9
|
|
|
+ with:
|
|
|
+ script: |
|
|
|
+ const owner = context.repo.owner;
|
|
|
+ const repo = context.repo.repo;
|
|
|
+ const issueNumber = context.payload.issue?.number;
|
|
|
+ const DUPLICATE_LABEL = 'potential-duplicate';
|
|
|
+ const DUPLICATE_MARKER = '<!-- potential-duplicate-check -->';
|
|
|
+ const MAX_CANDIDATES = 5;
|
|
|
+ const THRESHOLD = 0.45;
|
|
|
+
|
|
|
+ if (!issueNumber) {
|
|
|
+ console.log('No issue number found in payload.');
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ const issueResp = await github.rest.issues.get({
|
|
|
+ owner,
|
|
|
+ repo,
|
|
|
+ issue_number: issueNumber,
|
|
|
+ });
|
|
|
+
|
|
|
+ const issue = issueResp.data;
|
|
|
+ if (issue.pull_request) {
|
|
|
+ console.log('Skipping pull request payload.');
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ function normalizeText(value) {
|
|
|
+ return (value || '')
|
|
|
+ .toLowerCase()
|
|
|
+ .replace(/[`'"’]/g, '')
|
|
|
+ .replace(/[^a-z0-9\s]/g, ' ')
|
|
|
+ .replace(/\s+/g, ' ')
|
|
|
+ .trim();
|
|
|
+ }
|
|
|
+
|
|
|
+ function tokenize(value) {
|
|
|
+ const stopwords = new Set([
|
|
|
+ 'a', 'an', 'and', 'are', 'as', 'at', 'be', 'by', 'for', 'from', 'how', 'i', 'in', 'is', 'it', 'its',
|
|
|
+ 'of', 'on', 'or', 'that', 'the', 'this', 'to', 'when', 'with', 'wont', 'cannot', 'cant', 'fails', 'fail',
|
|
|
+ 'issue', 'bug', 'request', 'server', 'command', 'linuxgsm'
|
|
|
+ ]);
|
|
|
+ return new Set(
|
|
|
+ normalizeText(value)
|
|
|
+ .split(' ')
|
|
|
+ .filter((token) => token.length > 2 && !stopwords.has(token))
|
|
|
+ );
|
|
|
+ }
|
|
|
+
|
|
|
+ function jaccard(aSet, bSet) {
|
|
|
+ if (aSet.size === 0 || bSet.size === 0) return 0;
|
|
|
+ let intersection = 0;
|
|
|
+ for (const v of aSet) {
|
|
|
+ if (bSet.has(v)) intersection += 1;
|
|
|
+ }
|
|
|
+ const union = new Set([...aSet, ...bSet]).size;
|
|
|
+ return union === 0 ? 0 : intersection / union;
|
|
|
+ }
|
|
|
+
|
|
|
+ function bodySignature(text) {
|
|
|
+ return normalizeText(text).split(' ').slice(0, 200).join(' ');
|
|
|
+ }
|
|
|
+
|
|
|
+ const currentTitleTokens = tokenize(issue.title || '');
|
|
|
+ const currentBodyTokens = tokenize(bodySignature(issue.body || ''));
|
|
|
+
|
|
|
+ const recentIssues = await github.paginate(github.rest.issues.listForRepo, {
|
|
|
+ owner,
|
|
|
+ repo,
|
|
|
+ state: 'all',
|
|
|
+ sort: 'updated',
|
|
|
+ direction: 'desc',
|
|
|
+ per_page: 100,
|
|
|
+ });
|
|
|
+
|
|
|
+ const ranked = [];
|
|
|
+ for (const candidate of recentIssues) {
|
|
|
+ if (!candidate || candidate.number === issueNumber || candidate.pull_request) continue;
|
|
|
+
|
|
|
+ const candidateTitleTokens = tokenize(candidate.title || '');
|
|
|
+ const candidateBodyTokens = tokenize(bodySignature(candidate.body || ''));
|
|
|
+ const titleScore = jaccard(currentTitleTokens, candidateTitleTokens);
|
|
|
+ const bodyScore = jaccard(currentBodyTokens, candidateBodyTokens);
|
|
|
+ const score = titleScore * 0.8 + bodyScore * 0.2;
|
|
|
+
|
|
|
+ if (score < THRESHOLD) continue;
|
|
|
+
|
|
|
+ ranked.push({
|
|
|
+ number: candidate.number,
|
|
|
+ title: candidate.title,
|
|
|
+ state: candidate.state,
|
|
|
+ html_url: candidate.html_url,
|
|
|
+ score,
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ ranked.sort((a, b) => b.score - a.score);
|
|
|
+ const topMatches = ranked.slice(0, MAX_CANDIDATES);
|
|
|
+
|
|
|
+ async function ensurePotentialDuplicateLabel() {
|
|
|
+ try {
|
|
|
+ await github.rest.issues.getLabel({ owner, repo, name: DUPLICATE_LABEL });
|
|
|
+ } catch (err) {
|
|
|
+ if (err.status !== 404) throw err;
|
|
|
+ await github.rest.issues.createLabel({
|
|
|
+ owner,
|
|
|
+ repo,
|
|
|
+ name: DUPLICATE_LABEL,
|
|
|
+ color: 'd4c5f9',
|
|
|
+ description: 'Potentially duplicates another existing issue',
|
|
|
+ });
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ const existingLabelNames = new Set((issue.labels || []).map((l) => l.name));
|
|
|
+
|
|
|
+ const comments = await github.paginate(github.rest.issues.listComments, {
|
|
|
+ owner,
|
|
|
+ repo,
|
|
|
+ issue_number: issueNumber,
|
|
|
+ per_page: 100,
|
|
|
+ });
|
|
|
+ const existingComment = [...comments]
|
|
|
+ .reverse()
|
|
|
+ .find((comment) => comment.user?.type === 'Bot' && comment.body?.includes(DUPLICATE_MARKER));
|
|
|
+
|
|
|
+ if (topMatches.length === 0) {
|
|
|
+ if (existingLabelNames.has(DUPLICATE_LABEL)) {
|
|
|
+ try {
|
|
|
+ await github.rest.issues.removeLabel({
|
|
|
+ owner,
|
|
|
+ repo,
|
|
|
+ issue_number: issueNumber,
|
|
|
+ name: DUPLICATE_LABEL,
|
|
|
+ });
|
|
|
+ } catch (err) {
|
|
|
+ console.log(`Could not remove ${DUPLICATE_LABEL}: ${err.message}`);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (existingComment) {
|
|
|
+ try {
|
|
|
+ await github.rest.issues.updateComment({
|
|
|
+ owner,
|
|
|
+ repo,
|
|
|
+ comment_id: existingComment.id,
|
|
|
+ body:
|
|
|
+ `${DUPLICATE_MARKER}\n` +
|
|
|
+ `Potential duplicate scan did not find strong matches at this time.\n\n` +
|
|
|
+ `_This note is maintained automatically._`,
|
|
|
+ });
|
|
|
+ } catch (err) {
|
|
|
+ console.log(`Could not update duplicate comment: ${err.message}`);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ await ensurePotentialDuplicateLabel();
|
|
|
+
|
|
|
+ if (!existingLabelNames.has(DUPLICATE_LABEL)) {
|
|
|
+ try {
|
|
|
+ await github.rest.issues.addLabels({
|
|
|
+ owner,
|
|
|
+ repo,
|
|
|
+ issue_number: issueNumber,
|
|
|
+ labels: [DUPLICATE_LABEL],
|
|
|
+ });
|
|
|
+ } catch (err) {
|
|
|
+ console.log(`Could not add ${DUPLICATE_LABEL}: ${err.message}`);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ const lines = topMatches
|
|
|
+ .map((m) => `- #${m.number} (${Math.round(m.score * 100)}%) ${m.title}`)
|
|
|
+ .join('\n');
|
|
|
+
|
|
|
+ const commentBody =
|
|
|
+ `${DUPLICATE_MARKER}\n` +
|
|
|
+ `Potential duplicates:\n${lines}\n\n` +
|
|
|
+ `_This note is generated automatically using repository issue similarity and may include false positives._`;
|
|
|
+
|
|
|
+ if (existingComment) {
|
|
|
+ await github.rest.issues.updateComment({
|
|
|
+ owner,
|
|
|
+ repo,
|
|
|
+ comment_id: existingComment.id,
|
|
|
+ body: commentBody,
|
|
|
+ });
|
|
|
+ } else {
|
|
|
+ await github.rest.issues.createComment({
|
|
|
+ owner,
|
|
|
+ repo,
|
|
|
+ issue_number: issueNumber,
|
|
|
+ body: commentBody,
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ backfill-relabel:
|
|
|
+ if: github.repository_owner == 'GameServerManagers' && github.event_name == 'workflow_dispatch'
|
|
|
+ runs-on: ubuntu-latest
|
|
|
+ env:
|
|
|
+ ISSUE_STATE: ${{ inputs.issue_state }}
|
|
|
+ ISSUE_LIMIT: ${{ inputs.limit }}
|
|
|
+ AI_GAME_FALLBACK: ${{ inputs.ai_game_fallback }}
|
|
|
+ steps:
|
|
|
+ - name: Trigger relabel backfill
|
|
|
+ uses: actions/github-script@v9
|
|
|
+ env:
|
|
|
+ GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
|
|
+ with:
|
|
|
+ script: |
|
|
|
+ const owner = context.repo.owner;
|
|
|
+ const repo = context.repo.repo;
|
|
|
+ const state = process.env.ISSUE_STATE || 'all';
|
|
|
+ const rawLimit = Number.parseInt(process.env.ISSUE_LIMIT || '0', 10);
|
|
|
+ const limit = Number.isFinite(rawLimit) && rawLimit > 0 ? rawLimit : 0;
|
|
|
+ const useAiGameFallback = String(process.env.AI_GAME_FALLBACK || 'false').toLowerCase() === 'true';
|
|
|
+ const processedIssues = [];
|
|
|
+ const failedIssues = [];
|
|
|
+ let aiGameAttempts = 0;
|
|
|
+ let aiGameMatches = 0;
|
|
|
+ let aiGameRateLimited = 0;
|
|
|
+ let aiFallbackDisabledReason = '';
|
|
|
+ let stoppedForApiRateLimit = false;
|
|
|
+ let apiRateLimitStopReason = '';
|
|
|
+
|
|
|
+ // === Helpers (mirrored from issue-ai-maintenance) ===
|
|
|
+
|
|
|
+ function normalizeName(value) {
|
|
|
+ return (value || '')
|
|
|
+ .toLowerCase()
|
|
|
+ .replace(/[''`]/g, '')
|
|
|
+ .replace(/[^a-z0-9]+/g, ' ')
|
|
|
+ .trim();
|
|
|
+ }
|
|
|
+
|
|
|
+ function parseGameCandidates(gameField) {
|
|
|
+ if (!gameField || /^_?no response_?$/i.test(gameField)) return [];
|
|
|
+ return gameField
|
|
|
+ .replace(/\(.*?\)/g, ' ')
|
|
|
+ .split(/\n|,|\s+&\s+|\s+and\s+|\//i)
|
|
|
+ .map((v) => v.trim())
|
|
|
+ .filter(Boolean);
|
|
|
+ }
|
|
|
+
|
|
|
+ function findGamesFromText(text, gameAliasToLabel, gameAliasToScript) {
|
|
|
+ const labels = new Set();
|
|
|
+ const scripts = new Set();
|
|
|
+ const normalizedText = normalizeName(text);
|
|
|
+ if (!normalizedText) return { labels, scripts };
|
|
|
+
|
|
|
+ const escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
|
|
|
+ const aliases = [];
|
|
|
+ for (const [alias, label] of gameAliasToLabel.entries()) {
|
|
|
+ if (alias.length < 3) continue;
|
|
|
+ aliases.push({ alias, label, script: gameAliasToScript.get(alias) || null });
|
|
|
+ }
|
|
|
+
|
|
|
+ // Prefer longer aliases first so "killing floor 2" does not also match "killing floor".
|
|
|
+ aliases.sort((a, b) => b.alias.length - a.alias.length);
|
|
|
+
|
|
|
+ const usedRanges = [];
|
|
|
+ const isOverlapping = (start, end) =>
|
|
|
+ usedRanges.some((range) => start < range.end && end > range.start);
|
|
|
+
|
|
|
+ for (const entry of aliases) {
|
|
|
+ const pattern = new RegExp(`\\b${escapeRegex(entry.alias).replace(/\\ /g, '\\s+')}\\b`, 'g');
|
|
|
+ let match;
|
|
|
+ while ((match = pattern.exec(normalizedText)) !== null) {
|
|
|
+ const start = match.index;
|
|
|
+ const end = start + match[0].length;
|
|
|
+ if (isOverlapping(start, end)) continue;
|
|
|
+
|
|
|
+ labels.add(entry.label);
|
|
|
+ if (entry.script) scripts.add(entry.script);
|
|
|
+ usedRanges.push({ start, end });
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return { labels, scripts };
|
|
|
+ }
|
|
|
+
|
|
|
+ function parseAiGameResponse(raw) {
|
|
|
+ const input = (raw || '').trim();
|
|
|
+ if (!input) return {};
|
|
|
+
|
|
|
+ const candidates = [input];
|
|
|
+ const fenced = input.match(/```(?:json)?\s*([\s\S]*?)```/i);
|
|
|
+ if (fenced?.[1]) candidates.push(fenced[1].trim());
|
|
|
+
|
|
|
+ const firstBrace = input.indexOf('{');
|
|
|
+ const lastBrace = input.lastIndexOf('}');
|
|
|
+ if (firstBrace !== -1 && lastBrace > firstBrace) {
|
|
|
+ candidates.push(input.slice(firstBrace, lastBrace + 1));
|
|
|
+ }
|
|
|
+
|
|
|
+ for (const candidate of candidates) {
|
|
|
+ try {
|
|
|
+ return JSON.parse(candidate);
|
|
|
+ } catch (_err) {
|
|
|
+ // Continue trying fallbacks.
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return {};
|
|
|
+ }
|
|
|
+
|
|
|
+ function isGenericNonGameDetection(value) {
|
|
|
+ const normalized = normalizeName(value);
|
|
|
+ if (!normalized) return false;
|
|
|
+
|
|
|
+ return [
|
|
|
+ 'srcds',
|
|
|
+ 'source dedicated server',
|
|
|
+ 'dedicated server',
|
|
|
+ 'source engine',
|
|
|
+ 'goldsrc',
|
|
|
+ 'steamcmd',
|
|
|
+ 'linuxgsm',
|
|
|
+ 'lgsm',
|
|
|
+ ].some((term) => normalized.includes(term));
|
|
|
+ }
|
|
|
+
|
|
|
+ function parseAiRateLimitInfo(response) {
|
|
|
+ const retryAfter = response.headers.get('retry-after') || response.headers.get('Retry-After') || '';
|
|
|
+ const limit = response.headers.get('x-ratelimit-limit') || '';
|
|
|
+ const remaining = response.headers.get('x-ratelimit-remaining') || '';
|
|
|
+ const resetEpoch = response.headers.get('x-ratelimit-reset') || '';
|
|
|
+ const requestId = response.headers.get('x-github-request-id') || '';
|
|
|
+
|
|
|
+ let resetIso = '';
|
|
|
+ const parsedReset = Number.parseInt(resetEpoch, 10);
|
|
|
+ if (Number.isFinite(parsedReset) && parsedReset > 0) {
|
|
|
+ resetIso = new Date(parsedReset * 1000).toISOString();
|
|
|
+ }
|
|
|
+
|
|
|
+ return {
|
|
|
+ retryAfter,
|
|
|
+ limit,
|
|
|
+ remaining,
|
|
|
+ resetEpoch,
|
|
|
+ resetIso,
|
|
|
+ requestId,
|
|
|
+ };
|
|
|
+ }
|
|
|
+
|
|
|
+ function formatAiRateLimitInfo(info) {
|
|
|
+ const parts = [];
|
|
|
+ if (info.retryAfter) parts.push(`retry-after=${info.retryAfter}s`);
|
|
|
+ if (info.limit) parts.push(`limit=${info.limit}`);
|
|
|
+ if (info.remaining) parts.push(`remaining=${info.remaining}`);
|
|
|
+ if (info.resetEpoch) parts.push(`reset=${info.resetEpoch}${info.resetIso ? ` (${info.resetIso})` : ''}`);
|
|
|
+ if (info.requestId) parts.push(`request-id=${info.requestId}`);
|
|
|
+ return parts.length > 0 ? parts.join(', ') : 'no rate-limit headers returned';
|
|
|
+ }
|
|
|
+
|
|
|
+ function isApiRateLimitError(err) {
|
|
|
+ const message = String(err?.message || '').toLowerCase();
|
|
|
+ return (
|
|
|
+ err?.status === 429 ||
|
|
|
+ message.includes('api rate limit exceeded') ||
|
|
|
+ message.includes('secondary rate limit') ||
|
|
|
+ (message.includes('rate limit') && err?.status === 403)
|
|
|
+ );
|
|
|
+ }
|
|
|
+
|
|
|
+ function formatApiRateLimitError(err) {
|
|
|
+ const headers = err?.response?.headers || err?.headers || {};
|
|
|
+ const limit = headers['x-ratelimit-limit'] || '';
|
|
|
+ const remaining = headers['x-ratelimit-remaining'] || '';
|
|
|
+ const resetEpoch = headers['x-ratelimit-reset'] || '';
|
|
|
+ const requestId = headers['x-github-request-id'] || '';
|
|
|
+
|
|
|
+ let resetIso = '';
|
|
|
+ const parsedReset = Number.parseInt(resetEpoch || '', 10);
|
|
|
+ if (Number.isFinite(parsedReset) && parsedReset > 0) {
|
|
|
+ resetIso = new Date(parsedReset * 1000).toISOString();
|
|
|
+ }
|
|
|
+
|
|
|
+ const parts = [];
|
|
|
+ if (limit) parts.push(`limit=${limit}`);
|
|
|
+ if (remaining) parts.push(`remaining=${remaining}`);
|
|
|
+ if (resetEpoch) parts.push(`reset=${resetEpoch}${resetIso ? ` (${resetIso})` : ''}`);
|
|
|
+ if (requestId) parts.push(`request-id=${requestId}`);
|
|
|
+ return parts.length > 0 ? parts.join(', ') : 'no rate-limit headers returned';
|
|
|
+ }
|
|
|
+
|
|
|
+ function hasAliasHitForLabel(text, targetLabel, gameAliasToLabel) {
|
|
|
+ const normalizedText = normalizeName(text);
|
|
|
+ if (!normalizedText || !targetLabel) return false;
|
|
|
+
|
|
|
+ const paddedText = ` ${normalizedText} `;
|
|
|
+ for (const [alias, label] of gameAliasToLabel.entries()) {
|
|
|
+ if (label !== targetLabel) continue;
|
|
|
+ if (alias.length < 3) continue;
|
|
|
+ if (paddedText.includes(` ${alias} `)) return true;
|
|
|
+
|
|
|
+ // Allow obvious joined-word variants for multi-token aliases
|
|
|
+ // (e.g., "counter strike 1 6" matching "counterstrike 1.6").
|
|
|
+ const aliasTokens = alias.split(/\s+/).filter(Boolean);
|
|
|
+ if (aliasTokens.length > 1) {
|
|
|
+ const escapedTokens = aliasTokens.map((token) =>
|
|
|
+ token.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
|
|
|
+ );
|
|
|
+ const flexibleAliasPattern = new RegExp(`\\b${escapedTokens.join('\\s*')}\\b`);
|
|
|
+ if (flexibleAliasPattern.test(normalizedText)) return true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ function parseServerlistCsv(csvText) {
|
|
|
+ const rows = [];
|
|
|
+ const lines = (csvText || '').split(/\r?\n/);
|
|
|
+ for (let i = 1; i < lines.length; i += 1) {
|
|
|
+ const line = lines[i]?.trim();
|
|
|
+ if (!line) continue;
|
|
|
+ const parts = line.split(',');
|
|
|
+ if (parts.length < 3) continue;
|
|
|
+ rows.push({
|
|
|
+ shortname: parts[0].trim(),
|
|
|
+ gameservername: parts[1].trim(),
|
|
|
+ gamename: parts[2].trim(),
|
|
|
+ });
|
|
|
+ }
|
|
|
+ return rows;
|
|
|
+ }
|
|
|
+
|
|
|
+ function inferTypeFromTitle(issueTitle) {
|
|
|
+ if (/^\[bug\]/i.test(issueTitle)) return 'type: bug';
|
|
|
+ if (/\bserver\s+request\b/i.test(issueTitle)) return 'type: game server request';
|
|
|
+ const hasBracketPrefix = /^\[[^\]]+\]/.test(issueTitle || '');
|
|
|
+ const isServerCreation =
|
|
|
+ /\bserver\s+creation\b/i.test(issueTitle) ||
|
|
|
+ (hasBracketPrefix && /\bcreation\b/i.test(issueTitle));
|
|
|
+ const isServerSupportRequest =
|
|
|
+ /\bserver\s+support\b/i.test(issueTitle) ||
|
|
|
+ (/\bsupport\s+for\b/i.test(issueTitle) && /\bserver\b/i.test(issueTitle));
|
|
|
+ if (isServerCreation || isServerSupportRequest) return 'type: game server request';
|
|
|
+ if (/^\[feature\]/i.test(issueTitle)) return 'type: feature';
|
|
|
+ if (/^\[server request\]/i.test(issueTitle)) return 'type: game server request';
|
|
|
+ if (/^\[docs?\]/i.test(issueTitle)) return 'type: docs';
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+
|
|
|
+ function inferDesiredType(issueTitle, labelNames) {
|
|
|
+ const titleType = inferTypeFromTitle(issueTitle);
|
|
|
+ if (titleType) return titleType;
|
|
|
+
|
|
|
+ // Prefer server requests over generic feature when both labels exist.
|
|
|
+ if (labelNames.has('type: game server request')) return 'type: game server request';
|
|
|
+
|
|
|
+ for (const label of [
|
|
|
+ 'type: bug',
|
|
|
+ 'type: feature',
|
|
|
+ 'type: game server request',
|
|
|
+ 'type: docs',
|
|
|
+ ]) {
|
|
|
+ if (labelNames.has(label)) return label;
|
|
|
+ }
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+
|
|
|
+ function inferIssueTypeNameFromDesiredType(typeLabel) {
|
|
|
+ if (typeLabel === 'type: bug') return 'Bug';
|
|
|
+ if (typeLabel === 'type: feature') return 'Feature';
|
|
|
+ if (typeLabel === 'type: game server request') return 'Server Request';
|
|
|
+ if (typeLabel === 'type: docs') return 'Task';
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+
|
|
|
+ function parseCommandSelections(sectionValue) {
|
|
|
+ const selected = new Set();
|
|
|
+ const re = /command:\s*([a-z-]+)/gi;
|
|
|
+ let m;
|
|
|
+ while ((m = re.exec(sectionValue || '')) !== null) {
|
|
|
+ let value = m[1].toLowerCase();
|
|
|
+ if (value.startsWith('mods-')) value = 'mods';
|
|
|
+ if (value === 'auto-update') value = 'update';
|
|
|
+ selected.add(`command: ${value}`);
|
|
|
+ }
|
|
|
+ return selected;
|
|
|
+ }
|
|
|
+
|
|
|
+ function parseDistroSelections(sectionValue) {
|
|
|
+ const text = sectionValue || '';
|
|
|
+ const selected = new Set();
|
|
|
+ if (/\bUbuntu\b/i.test(text)) selected.add('distro: Ubuntu');
|
|
|
+ if (/\bDebian\b/i.test(text)) selected.add('distro: Debian');
|
|
|
+ if (/\bAlmaLinux\b/i.test(text)) selected.add('distro: AlmaLinux');
|
|
|
+ if (/\bRocky\b/i.test(text)) selected.add('distro: Rocky Linux');
|
|
|
+ if (/\bCentOS\b/i.test(text)) selected.add('distro: CentOS');
|
|
|
+ if (/\bFedora\b/i.test(text)) selected.add('distro: Fedora');
|
|
|
+ if (/\bopenSUSE\b/i.test(text)) selected.add('distro: openSUSE');
|
|
|
+ if (/\bArch Linux\b/i.test(text)) selected.add('distro: Arch Linux');
|
|
|
+ if (/\bSlackware\b/i.test(text)) selected.add('distro: Slackware');
|
|
|
+ return selected;
|
|
|
+ }
|
|
|
+
|
|
|
+ function extractSection(body, sectionName) {
|
|
|
+ const escaped = sectionName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
|
|
|
+ const re = new RegExp(`### ${escaped}\\n\\n([\\s\\S]*?)(\\n### |$)`, 'i');
|
|
|
+ return (body.match(re)?.[1] || '').trim();
|
|
|
+ }
|
|
|
+
|
|
|
+ // === Load shared data once ===
|
|
|
+
|
|
|
+ const repoLabels = await github.paginate(github.rest.issues.listLabelsForRepo, {
|
|
|
+ owner,
|
|
|
+ repo,
|
|
|
+ per_page: 100,
|
|
|
+ });
|
|
|
+
|
|
|
+ const gameLabelByNormalized = new Map();
|
|
|
+ for (const label of repoLabels) {
|
|
|
+ if (!label.name.startsWith('game: ')) continue;
|
|
|
+ gameLabelByNormalized.set(normalizeName(label.name.slice(6)), label.name);
|
|
|
+ }
|
|
|
+
|
|
|
+ const existingEngineLabels = new Set(
|
|
|
+ repoLabels.map((l) => l.name).filter((name) => name.startsWith('engine: '))
|
|
|
+ );
|
|
|
+
|
|
|
+ const gameAliasToLabel = new Map();
|
|
|
+ const gameAliasToScript = new Map();
|
|
|
+ const engineByScript = new Map();
|
|
|
+
|
|
|
+ for (const [normalizedGameName, label] of gameLabelByNormalized.entries()) {
|
|
|
+ gameAliasToLabel.set(normalizedGameName, label);
|
|
|
+ }
|
|
|
+
|
|
|
+ try {
|
|
|
+ const serverlistContent = await github.rest.repos.getContent({
|
|
|
+ owner,
|
|
|
+ repo,
|
|
|
+ path: 'lgsm/data/serverlist.csv',
|
|
|
+ });
|
|
|
+ const csvText = Buffer.from(serverlistContent.data?.content || '', 'base64').toString('utf8');
|
|
|
+ const serverRows = parseServerlistCsv(csvText);
|
|
|
+ for (const row of serverRows) {
|
|
|
+ const canonicalLabel = gameLabelByNormalized.get(normalizeName(row.gamename));
|
|
|
+ if (!canonicalLabel) continue;
|
|
|
+ for (const alias of [row.shortname, row.gameservername, row.gamename]) {
|
|
|
+ const key = normalizeName(alias);
|
|
|
+ if (!key) continue;
|
|
|
+ gameAliasToLabel.set(key, canonicalLabel);
|
|
|
+ gameAliasToScript.set(key, row.gameservername);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } catch (err) {
|
|
|
+ console.log(`Could not load serverlist aliases: ${err.message}`);
|
|
|
+ }
|
|
|
+
|
|
|
+ async function ensureEngineLabel(engineLabel) {
|
|
|
+ if (existingEngineLabels.has(engineLabel)) return;
|
|
|
+ try {
|
|
|
+ await github.rest.issues.createLabel({
|
|
|
+ owner,
|
|
|
+ repo,
|
|
|
+ name: engineLabel,
|
|
|
+ color: '000000',
|
|
|
+ description: `Issues related to ${engineLabel.slice(8)} engine`,
|
|
|
+ });
|
|
|
+ existingEngineLabels.add(engineLabel);
|
|
|
+ } catch (err) {
|
|
|
+ if (err.status === 422) {
|
|
|
+ existingEngineLabels.add(engineLabel);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ console.log(`Could not create engine label "${engineLabel}": ${err.message}`);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ async function getEngineForScript(scriptName) {
|
|
|
+ if (!scriptName) return null;
|
|
|
+ if (engineByScript.has(scriptName)) return engineByScript.get(scriptName);
|
|
|
+ try {
|
|
|
+ const cfgContent = await github.rest.repos.getContent({
|
|
|
+ owner,
|
|
|
+ repo,
|
|
|
+ path: `lgsm/config-default/config-lgsm/${scriptName}/_default.cfg`,
|
|
|
+ });
|
|
|
+ const cfgText = Buffer.from(cfgContent.data?.content || '', 'base64').toString('utf8');
|
|
|
+ const engine = cfgText.match(/^engine="([^"]+)"/m)?.[1] || null;
|
|
|
+ engineByScript.set(scriptName, engine);
|
|
|
+ return engine;
|
|
|
+ } catch (_err) {
|
|
|
+ engineByScript.set(scriptName, null);
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // === Process issues ===
|
|
|
+
|
|
|
+ const issues = await github.paginate(github.rest.issues.listForRepo, {
|
|
|
+ owner,
|
|
|
+ repo,
|
|
|
+ state,
|
|
|
+ sort: 'created',
|
|
|
+ direction: 'asc',
|
|
|
+ per_page: 100,
|
|
|
+ });
|
|
|
+
|
|
|
+ const targets = issues.filter((issue) => !issue.pull_request);
|
|
|
+ const selectedTargets = limit > 0 ? targets.slice(0, limit) : targets;
|
|
|
+
|
|
|
+ console.log(
|
|
|
+ `Starting relabel backfill for ${selectedTargets.length} issue(s) ` +
|
|
|
+ `(state=${state}, limit=${limit === 0 ? 'all' : limit}).`
|
|
|
+ );
|
|
|
+
|
|
|
+ let processed = 0;
|
|
|
+ for (const rawIssue of selectedTargets) {
|
|
|
+ if (stoppedForApiRateLimit) break;
|
|
|
+ console.log(`Processing issue #${rawIssue.number}: ${rawIssue.title}`);
|
|
|
+ try {
|
|
|
+ const issueResp = await github.rest.issues.get({
|
|
|
+ owner,
|
|
|
+ repo,
|
|
|
+ issue_number: rawIssue.number,
|
|
|
+ });
|
|
|
+ const issue = issueResp.data;
|
|
|
+ const title = issue.title || '';
|
|
|
+ const body = issue.body || '';
|
|
|
+ const existingLabels = new Set((issue.labels || []).map((l) => l.name).filter(Boolean));
|
|
|
+ const labelsToAdd = new Set();
|
|
|
+ const labelsToRemove = new Set();
|
|
|
+ const isLocked = issue.locked === true;
|
|
|
+ let issueTypeSet = null;
|
|
|
+
|
|
|
+ // Type reconciliation
|
|
|
+ const desiredType = inferDesiredType(title, existingLabels);
|
|
|
+ if (desiredType) {
|
|
|
+ labelsToAdd.add(desiredType);
|
|
|
+ for (const label of existingLabels) {
|
|
|
+ if (label.startsWith('type: ') && label !== desiredType) labelsToRemove.add(label);
|
|
|
+ }
|
|
|
+
|
|
|
+ const desiredIssueTypeName = inferIssueTypeNameFromDesiredType(desiredType);
|
|
|
+ if (desiredIssueTypeName) {
|
|
|
+ try {
|
|
|
+ const issueTypeData = await github.graphql(
|
|
|
+ `query($owner:String!,$repo:String!,$number:Int!){
|
|
|
+ repository(owner:$owner,name:$repo){
|
|
|
+ issueTypes(first:20){ nodes { id name } }
|
|
|
+ issue(number:$number){ id issueType { id name } }
|
|
|
+ }
|
|
|
+ }`,
|
|
|
+ { owner, repo, number: rawIssue.number }
|
|
|
+ );
|
|
|
+ const issueNode = issueTypeData.repository?.issue;
|
|
|
+ const issueTypes = issueTypeData.repository?.issueTypes?.nodes || [];
|
|
|
+ const desiredIssueType = issueTypes.find((t) => t.name === desiredIssueTypeName);
|
|
|
+ if (
|
|
|
+ issueNode?.id &&
|
|
|
+ desiredIssueType?.id &&
|
|
|
+ issueNode.issueType?.id !== desiredIssueType.id
|
|
|
+ ) {
|
|
|
+ await github.graphql(
|
|
|
+ `mutation($id:ID!,$issueTypeId:ID!){
|
|
|
+ updateIssue(input:{id:$id,issueTypeId:$issueTypeId}){
|
|
|
+ issue { id number issueType { id name } }
|
|
|
+ }
|
|
|
+ }`,
|
|
|
+ { id: issueNode.id, issueTypeId: desiredIssueType.id }
|
|
|
+ );
|
|
|
+ issueTypeSet = desiredIssueTypeName;
|
|
|
+ console.log(`#${rawIssue.number}: set Issue Type to ${desiredIssueTypeName}`);
|
|
|
+ }
|
|
|
+ } catch (err) {
|
|
|
+ if (isApiRateLimitError(err)) throw err;
|
|
|
+ console.log(`#${rawIssue.number}: could not sync Issue Type: ${err.message}`);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // Commands
|
|
|
+ const commandSection = extractSection(body, 'Command');
|
|
|
+ const desiredCommands = parseCommandSelections(commandSection);
|
|
|
+ if (desiredCommands.size > 0) {
|
|
|
+ for (const label of desiredCommands) labelsToAdd.add(label);
|
|
|
+ for (const label of existingLabels) {
|
|
|
+ if (label.startsWith('command: ') && !desiredCommands.has(label)) labelsToRemove.add(label);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // Distros
|
|
|
+ const distroSection = extractSection(body, 'Linux distro');
|
|
|
+ const desiredDistros = parseDistroSelections(distroSection);
|
|
|
+ if (desiredDistros.size > 0) {
|
|
|
+ for (const label of desiredDistros) labelsToAdd.add(label);
|
|
|
+ for (const label of existingLabels) {
|
|
|
+ if (label.startsWith('distro: ') && !desiredDistros.has(label)) labelsToRemove.add(label);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // Tmux false positive cleanup
|
|
|
+ if (
|
|
|
+ existingLabels.has('info: tmux') &&
|
|
|
+ !/\b(tmuxception|check_tmuxception)\b/i.test(`${title}\n${body}`)
|
|
|
+ ) {
|
|
|
+ labelsToRemove.add('info: tmux');
|
|
|
+ }
|
|
|
+
|
|
|
+ // Games and engines
|
|
|
+ const desiredGames = new Set();
|
|
|
+ const gameLabelSource = new Map(); // label → 'form-field' | 'text-match' | 'ai-fallback'
|
|
|
+ const desiredServerScripts = new Set();
|
|
|
+ // 'Game server' is the section name in server_request.yml; 'Game' is used in bug_report.yml.
|
|
|
+ const gameField = extractSection(body, 'Game server') || extractSection(body, 'Game');
|
|
|
+ const gameCandidates = parseGameCandidates(gameField);
|
|
|
+ const hasStructuredGameSelection = gameCandidates.length > 0;
|
|
|
+ for (const candidate of gameCandidates) {
|
|
|
+ const normalizedCandidate = normalizeName(candidate);
|
|
|
+ const mapped =
|
|
|
+ gameAliasToLabel.get(normalizedCandidate) || gameLabelByNormalized.get(normalizedCandidate);
|
|
|
+ if (mapped) {
|
|
|
+ desiredGames.add(mapped);
|
|
|
+ gameLabelSource.set(mapped, 'form-field');
|
|
|
+ }
|
|
|
+ const mappedScript = gameAliasToScript.get(normalizedCandidate);
|
|
|
+ if (mappedScript) desiredServerScripts.add(mappedScript);
|
|
|
+ }
|
|
|
+
|
|
|
+ // Legacy issues often have no form section; fall back to deterministic text matching.
|
|
|
+ if (desiredGames.size === 0) {
|
|
|
+ const fromText = findGamesFromText(`${title}\n${body}`, gameAliasToLabel, gameAliasToScript);
|
|
|
+ for (const label of fromText.labels) {
|
|
|
+ desiredGames.add(label);
|
|
|
+ gameLabelSource.set(label, 'text-match');
|
|
|
+ }
|
|
|
+ for (const scriptName of fromText.scripts) desiredServerScripts.add(scriptName);
|
|
|
+ }
|
|
|
+
|
|
|
+ // Optional AI fallback for legacy issues where deterministic matching finds nothing.
|
|
|
+ if (useAiGameFallback && desiredGames.size === 0) {
|
|
|
+ if (aiFallbackDisabledReason) {
|
|
|
+ console.log(`#${rawIssue.number}: AI fallback skipped (${aiFallbackDisabledReason})`);
|
|
|
+ } else {
|
|
|
+ aiGameAttempts += 1;
|
|
|
+ const aiPayload = {
|
|
|
+ model: 'openai/gpt-4.1-mini',
|
|
|
+ temperature: 0.1,
|
|
|
+ max_tokens: 120,
|
|
|
+ messages: [
|
|
|
+ {
|
|
|
+ role: 'system',
|
|
|
+ content:
|
|
|
+ 'Return JSON only. Identify the specific game referenced in this LinuxGSM issue with high precision. ' +
|
|
|
+ 'If only generic platform/engine terms are present (e.g. srcds, source dedicated server, steamcmd), return detected_game as null.',
|
|
|
+ },
|
|
|
+ {
|
|
|
+ role: 'user',
|
|
|
+ content:
|
|
|
+ `Title: ${title}\n\nBody:\n${body.slice(0, 2500)}\n\n` +
|
|
|
+ 'Return JSON: {"detected_game":"string or null","game_confidence":"high|medium|low|null"}',
|
|
|
+ },
|
|
|
+ ],
|
|
|
+ };
|
|
|
+ const aiUrl = `https://models.github.ai/orgs/${owner}/inference/chat/completions`;
|
|
|
+ const aiHeaders = {
|
|
|
+ Accept: 'application/vnd.github+json',
|
|
|
+ Authorization: `Bearer ${process.env.GITHUB_TOKEN}`,
|
|
|
+ 'X-GitHub-Api-Version': '2026-03-10',
|
|
|
+ 'Content-Type': 'application/json',
|
|
|
+ };
|
|
|
+ try {
|
|
|
+ let res = await fetch(aiUrl, { method: 'POST', headers: aiHeaders, body: JSON.stringify(aiPayload) });
|
|
|
+
|
|
|
+ // On 429 honour Retry-After (capped at 60 s) then retry once.
|
|
|
+ if (res.status === 429) {
|
|
|
+ aiGameRateLimited += 1;
|
|
|
+ const rateInfo = parseAiRateLimitInfo(res);
|
|
|
+ const rawRetryAfter = Number.parseInt(rateInfo.retryAfter || '10', 10);
|
|
|
+ const retryAfter = Math.min(Number.isFinite(rawRetryAfter) ? rawRetryAfter : 10, 60);
|
|
|
+ if (Number.isFinite(rawRetryAfter) && rawRetryAfter > 300) {
|
|
|
+ aiFallbackDisabledReason = `global cooldown active (retry-after=${rawRetryAfter}s)`;
|
|
|
+ console.log(
|
|
|
+ `#${rawIssue.number}: AI fallback disabled for remaining run (${aiFallbackDisabledReason}; ${formatAiRateLimitInfo(rateInfo)})`
|
|
|
+ );
|
|
|
+ } else {
|
|
|
+ console.log(
|
|
|
+ `#${rawIssue.number}: AI fallback rate-limited - waiting ${retryAfter}s then retrying (${formatAiRateLimitInfo(rateInfo)})`
|
|
|
+ );
|
|
|
+ await new Promise((r) => setTimeout(r, retryAfter * 1000));
|
|
|
+ res = await fetch(aiUrl, { method: 'POST', headers: aiHeaders, body: JSON.stringify(aiPayload) });
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (res.ok) {
|
|
|
+ const data = await res.json();
|
|
|
+ const raw = data.choices?.[0]?.message?.content || '{}';
|
|
|
+ const parsed = parseAiGameResponse(raw);
|
|
|
+ const detectedGame = normalizeName(parsed?.detected_game || '');
|
|
|
+ const confidence = (parsed?.game_confidence || '').toLowerCase();
|
|
|
+ if (detectedGame && confidence === 'high') {
|
|
|
+ const mappedLabel =
|
|
|
+ gameAliasToLabel.get(detectedGame) || gameLabelByNormalized.get(detectedGame);
|
|
|
+ if (mappedLabel) {
|
|
|
+ const hasAliasEvidence = hasAliasHitForLabel(
|
|
|
+ `${title}\n${body}`,
|
|
|
+ mappedLabel,
|
|
|
+ gameAliasToLabel
|
|
|
+ );
|
|
|
+ if (hasAliasEvidence) {
|
|
|
+ desiredGames.add(mappedLabel);
|
|
|
+ gameLabelSource.set(mappedLabel, 'ai-fallback');
|
|
|
+ const mappedScript = gameAliasToScript.get(detectedGame);
|
|
|
+ if (mappedScript) desiredServerScripts.add(mappedScript);
|
|
|
+ aiGameMatches += 1;
|
|
|
+ console.log(
|
|
|
+ `#${rawIssue.number}: AI fallback accepted game "${mappedLabel}" from "${parsed?.detected_game}"`
|
|
|
+ );
|
|
|
+ } else {
|
|
|
+ console.log(
|
|
|
+ `#${rawIssue.number}: AI fallback rejected game "${mappedLabel}" (no literal alias evidence in issue text)`
|
|
|
+ );
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ if (isGenericNonGameDetection(parsed?.detected_game || '')) {
|
|
|
+ console.log(
|
|
|
+ `#${rawIssue.number}: AI fallback skipped generic non-game detection "${parsed?.detected_game}"`
|
|
|
+ );
|
|
|
+ } else {
|
|
|
+ console.log(
|
|
|
+ `#${rawIssue.number}: AI fallback returned unmapped game "${parsed?.detected_game}"`
|
|
|
+ );
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ if (res.status === 429) {
|
|
|
+ const rateInfo = parseAiRateLimitInfo(res);
|
|
|
+ console.log(
|
|
|
+ `#${rawIssue.number}: AI fallback skipped (HTTP 429, ${formatAiRateLimitInfo(rateInfo)})`
|
|
|
+ );
|
|
|
+ } else {
|
|
|
+ console.log(`#${rawIssue.number}: AI fallback skipped (HTTP ${res.status})`);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } catch (err) {
|
|
|
+ console.log(`#${rawIssue.number}: AI fallback error: ${err.message}`);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ for (const gameLabel of desiredGames) {
|
|
|
+ const mappedScript = gameAliasToScript.get(normalizeName(gameLabel.slice(6)));
|
|
|
+ if (mappedScript) desiredServerScripts.add(mappedScript);
|
|
|
+ }
|
|
|
+
|
|
|
+ const desiredEngineLabels = new Set();
|
|
|
+ for (const scriptName of desiredServerScripts) {
|
|
|
+ const engine = await getEngineForScript(scriptName);
|
|
|
+ if (!engine) continue;
|
|
|
+ const engineLabel = `engine: ${engine}`;
|
|
|
+ await ensureEngineLabel(engineLabel);
|
|
|
+ desiredEngineLabels.add(engineLabel);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (desiredEngineLabels.size > 0) {
|
|
|
+ for (const label of desiredEngineLabels) labelsToAdd.add(label);
|
|
|
+ for (const label of existingLabels) {
|
|
|
+ if (label.startsWith('engine: ') && !desiredEngineLabels.has(label)) labelsToRemove.add(label);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (desiredGames.size > 0) {
|
|
|
+ for (const label of desiredGames) labelsToAdd.add(label);
|
|
|
+ if (hasStructuredGameSelection) {
|
|
|
+ for (const label of existingLabels) {
|
|
|
+ if (label.startsWith('game: ') && !desiredGames.has(label)) labelsToRemove.add(label);
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ // For legacy issues without structured game selection, only prune stale
|
|
|
+ // broader labels when a more specific inferred game label exists.
|
|
|
+ const desiredGameNamesNormalized = new Set(
|
|
|
+ [...desiredGames].map((label) => normalizeName(label.slice(6)))
|
|
|
+ );
|
|
|
+ for (const label of existingLabels) {
|
|
|
+ if (!label.startsWith('game: ') || desiredGames.has(label)) continue;
|
|
|
+ const existingGameName = normalizeName(label.slice(6));
|
|
|
+ const isBroaderOverlap = [...desiredGameNamesNormalized].some(
|
|
|
+ (desiredName) => desiredName !== existingGameName && desiredName.startsWith(`${existingGameName} `)
|
|
|
+ );
|
|
|
+ if (isBroaderOverlap) labelsToRemove.add(label);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // Apply changes
|
|
|
+ const finalAdds = [...labelsToAdd].filter((label) => !existingLabels.has(label));
|
|
|
+ const finalRemoves = [...labelsToRemove].filter((label) => existingLabels.has(label));
|
|
|
+
|
|
|
+ let labelAdded = 0;
|
|
|
+ let labelRemoved = 0;
|
|
|
+
|
|
|
+ for (const label of finalRemoves) {
|
|
|
+ try {
|
|
|
+ await github.rest.issues.removeLabel({
|
|
|
+ owner,
|
|
|
+ repo,
|
|
|
+ issue_number: rawIssue.number,
|
|
|
+ name: label,
|
|
|
+ });
|
|
|
+ labelRemoved += 1;
|
|
|
+ console.log(`#${rawIssue.number}: removed "${label}"`);
|
|
|
+ } catch (err) {
|
|
|
+ if (isApiRateLimitError(err)) throw err;
|
|
|
+ console.log(`#${rawIssue.number}: could not remove "${label}": ${err.message}`);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ for (const label of finalAdds) {
|
|
|
+ try {
|
|
|
+ await github.rest.issues.addLabels({
|
|
|
+ owner,
|
|
|
+ repo,
|
|
|
+ issue_number: rawIssue.number,
|
|
|
+ labels: [label],
|
|
|
+ });
|
|
|
+ labelAdded += 1;
|
|
|
+ const gameSource = gameLabelSource.get(label);
|
|
|
+ console.log(`#${rawIssue.number}: added "${label}"${gameSource ? ` (${gameSource})` : ''}`);
|
|
|
+ } catch (err) {
|
|
|
+ if (isApiRateLimitError(err)) throw err;
|
|
|
+ console.log(`#${rawIssue.number}: could not add "${label}": ${err.message}`);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ processed += 1;
|
|
|
+ processedIssues.push({
|
|
|
+ number: rawIssue.number,
|
|
|
+ title: rawIssue.title,
|
|
|
+ adds: labelAdded,
|
|
|
+ removes: labelRemoved,
|
|
|
+ issueTypeSet,
|
|
|
+ locked: isLocked,
|
|
|
+ });
|
|
|
+ console.log(
|
|
|
+ `#${rawIssue.number}: done (+${labelAdded} added, -${labelRemoved} removed${
|
|
|
+ issueTypeSet ? `, type→${issueTypeSet}` : ''
|
|
|
+ }${isLocked ? ', locked' : ''})`
|
|
|
+ );
|
|
|
+ } catch (err) {
|
|
|
+ if (isApiRateLimitError(err)) {
|
|
|
+ stoppedForApiRateLimit = true;
|
|
|
+ apiRateLimitStopReason = formatApiRateLimitError(err);
|
|
|
+ console.log(
|
|
|
+ `Stopping backfill due to API rate limit at #${rawIssue.number} (${apiRateLimitStopReason})`
|
|
|
+ );
|
|
|
+ failedIssues.push({
|
|
|
+ number: rawIssue.number,
|
|
|
+ title: rawIssue.title,
|
|
|
+ stage: 'rate-limit',
|
|
|
+ error: err.message,
|
|
|
+ });
|
|
|
+ break;
|
|
|
+ } else {
|
|
|
+ console.log(`Error processing #${rawIssue.number}: ${err.message}`);
|
|
|
+ failedIssues.push({
|
|
|
+ number: rawIssue.number,
|
|
|
+ title: rawIssue.title,
|
|
|
+ stage: 'process',
|
|
|
+ error: err.message,
|
|
|
+ });
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ console.log(
|
|
|
+ `Relabel backfill complete: ${processed} processed, ${failedIssues.length} failed${
|
|
|
+ stoppedForApiRateLimit ? `, stopped early (${apiRateLimitStopReason})` : ''
|
|
|
+ }.`
|
|
|
+ );
|
|
|
+
|
|
|
+ await core.summary
|
|
|
+ .addHeading('Relabel Backfill Summary')
|
|
|
+ .addTable([
|
|
|
+ [
|
|
|
+ { data: 'Requested state', header: true },
|
|
|
+ { data: 'Limit', header: true },
|
|
|
+ { data: 'AI fallback', header: true },
|
|
|
+ { data: 'AI attempts', header: true },
|
|
|
+ { data: 'AI matches', header: true },
|
|
|
+ { data: 'AI 429s', header: true },
|
|
|
+ { data: 'AI disabled reason', header: true },
|
|
|
+ { data: 'Stopped early', header: true },
|
|
|
+ { data: 'Target issues', header: true },
|
|
|
+ { data: 'Processed', header: true },
|
|
|
+ { data: 'Failures', header: true },
|
|
|
+ ],
|
|
|
+ [
|
|
|
+ state,
|
|
|
+ limit === 0 ? 'all' : String(limit),
|
|
|
+ useAiGameFallback ? 'enabled' : 'disabled',
|
|
|
+ String(aiGameAttempts),
|
|
|
+ String(aiGameMatches),
|
|
|
+ String(aiGameRateLimited),
|
|
|
+ aiFallbackDisabledReason || '—',
|
|
|
+ stoppedForApiRateLimit ? apiRateLimitStopReason : 'no',
|
|
|
+ String(selectedTargets.length),
|
|
|
+ String(processed),
|
|
|
+ String(failedIssues.length),
|
|
|
+ ],
|
|
|
+ ])
|
|
|
+ .write();
|
|
|
+
|
|
|
+ if (processedIssues.length > 0) {
|
|
|
+ const processedRows = processedIssues.slice(0, 50).map((issue) => [
|
|
|
+ `#${issue.number}${issue.locked ? ' 🔒' : ''}`,
|
|
|
+ `[${issue.title}](https://github.com/${owner}/${repo}/issues/${issue.number})`,
|
|
|
+ `+${issue.adds} / -${issue.removes}`,
|
|
|
+ issue.issueTypeSet || '—',
|
|
|
+ ]);
|
|
|
+
|
|
|
+ await core.summary
|
|
|
+ .addHeading('Processed Issues')
|
|
|
+ .addTable([
|
|
|
+ [
|
|
|
+ { data: 'Issue', header: true },
|
|
|
+ { data: 'Title', header: true },
|
|
|
+ { data: 'Label changes', header: true },
|
|
|
+ { data: 'Issue Type set', header: true },
|
|
|
+ ],
|
|
|
+ ...processedRows,
|
|
|
+ ])
|
|
|
+ .write();
|
|
|
+ }
|
|
|
+
|
|
|
+ if (failedIssues.length > 0) {
|
|
|
+ const failureRows = failedIssues.slice(0, 50).map((issue) => [
|
|
|
+ `#${issue.number}`,
|
|
|
+ issue.stage,
|
|
|
+ issue.error,
|
|
|
+ ]);
|
|
|
+
|
|
|
+ await core.summary
|
|
|
+ .addHeading('Failures')
|
|
|
+ .addTable([
|
|
|
+ [
|
|
|
+ { data: 'Issue', header: true },
|
|
|
+ { data: 'Stage', header: true },
|
|
|
+ { data: 'Error', header: true },
|
|
|
+ ],
|
|
|
+ ...failureRows,
|
|
|
+ ])
|
|
|
+ .write();
|
|
|
+ }
|
|
|
+
|
|
|
+ pr-labeler:
|
|
|
+ if: github.repository_owner == 'GameServerManagers' && github.event_name == 'pull_request'
|
|
|
+ runs-on: ubuntu-latest
|
|
|
+ steps:
|
|
|
+ - name: PR Labeler
|
|
|
+ uses: github/issue-labeler@v3.4
|
|
|
+ with:
|
|
|
+ repo-token: "${{ secrets.GITHUB_TOKEN }}"
|
|
|
+ configuration-path: .github/labeler.yml
|
|
|
+ enable-versioned-regex: 0
|
|
|
+ include-title: 1
|
|
|
+ include-body: 0
|
|
|
+ sync-labels: 1
|
|
|
+
|
|
|
+ is-sponsor-label:
|
|
|
+ if: github.repository_owner == 'GameServerManagers' && github.event_name == 'issues' && github.event.action == 'opened'
|
|
|
+ runs-on: ubuntu-latest
|
|
|
+ steps:
|
|
|
+ - name: Is Sponsor Label
|
|
|
+ uses: JasonEtco/is-sponsor-label-action@v2
|
|
|
+ env:
|
|
|
+ GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
|
|
+
|
|
|
+ sync-game-labels:
|
|
|
+ if: github.repository_owner == 'GameServerManagers' && github.event_name == 'push' && contains(github.event.head_commit.modified, 'lgsm/data/serverlist.csv')
|
|
|
+ runs-on: ubuntu-latest
|
|
|
+ steps:
|
|
|
+ - name: Checkout
|
|
|
+ uses: actions/checkout@v5
|
|
|
+
|
|
|
+ - name: Sync game labels from serverlist
|
|
|
+ env:
|
|
|
+ GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
|
|
+ run: |
|
|
|
+ chmod +x .github/scripts/sync-game-labels.sh
|
|
|
+ .github/scripts/sync-game-labels.sh
|
Daniel Gibbs