feat: add support policy /info subjects

Author: ebiggz

src/interactions/commands/handlers/info/info-helpers.ts

@@ -1,10 +1,65 @@
-import { BaseMessageOptions, EmbedBuilder } from 'discord.js';
+import {
+    ActionRowBuilder,
+    BaseMessageOptions,
+    ButtonBuilder,
+    ButtonStyle,
+    EmbedBuilder,
+} from 'discord.js';
+import { getSupportedFirebotVersions } from '../../../../services/github.service';
 
 export function getBaseEmbed() {
     return new EmbedBuilder().setColor('#FFBE00');
 }
 
 export type InfoTopic = {
     name: string;
-    message: BaseMessageOptions;
+    message: BaseMessageOptions | (() => Promise<BaseMessageOptions>);
 };
+
+export async function getSupportPolicyEmbed(): Promise<EmbedBuilder> {
+    const supportedVersions = await getSupportedFirebotVersions();
+
+    // Build the list of currently supported versions
+    const versionLines: string[] = [];
+    if (supportedVersions.currentStable) {
+        versionLines.push(`- **${supportedVersions.currentStable}** (Latest)`);
+    }
+    if (
+        supportedVersions.previousStable &&
+        supportedVersions.previousStableExpiresAt
+    ) {
+        versionLines.push(
+            `- **${supportedVersions.previousStable}** (Previous - support expires <t:${supportedVersions.previousStableExpiresAt}:R>)`
+        );
+    }
+    if (supportedVersions.prerelease) {
+        versionLines.push(
+            `- **${supportedVersions.prerelease}** (Pre-release)`
+        );
+    }
+
+    const currentlySupportedSection =
+        versionLines.length > 0
+            ? `**Currently Supported Versions:**\n${versionLines.join('\n')}\n\n`
+            : '';
+    return getBaseEmbed().setTitle('Support Policy').setDescription(`
+${currentlySupportedSection}**Policy Summary:**
+- Latest stable release is always supported
+- Previous stable releases are supported for up to **30 days** after a newer stable update
+- Betas are unsupported once a newer beta or corresponding stable release is available
+- Nightly builds receive limited support due to their unstable nature
+
+To receive support, please update to a supported version of Firebot.
+`);
+}
+
+export function getSupportPolicyLinkButton() {
+    return new ActionRowBuilder<ButtonBuilder>().addComponents(
+        new ButtonBuilder()
+            .setLabel('View Full Support Policy')
+            .setStyle(ButtonStyle.Link)
+            .setURL(
+                'https://github.com/crowbartools/Firebot/blob/master/.github/SUPPORT.md'
+            )
+    );
+}

src/interactions/commands/handlers/info/info-slash.ts

@@ -33,13 +33,17 @@ export const infoSlashCommand: ICommandHandler = {
 
         const topicName = interaction.options.getString('topic');
 
-        const message = infoTopics.find((p) => p.name === topicName)?.message;
+        const topic = infoTopics.find((p) => p.name === topicName);
 
-        if (!message) {
+        if (!topic?.message) {
             await interaction.editReply('Invalid topic');
             return;
         }
 
+        const message = typeof topic.message === 'function'
+            ? await topic.message()
+            : topic.message;
+
         const targetUser = interaction.options.getUser('target');
 
         const variableMap = {

src/interactions/commands/handlers/info/topics/index.ts

@@ -17,6 +17,8 @@ import { InfoTopic } from '../info-helpers';
 import { arm64InstallError } from './arm64';
 import { overlayIssues } from './overlay-issues';
 import { debugInfo } from './debug-info';
+import { unsupportedVersion } from './unsupported-version';
+import { supportPolicy } from './support-policy';
 
 export const infoTopics: Array<InfoTopic> = [
     authIssues,
@@ -36,5 +38,7 @@ export const infoTopics: Array<InfoTopic> = [
     tuts,
     arm64InstallError,
     overlayIssues,
-    debugInfo
+    debugInfo,
+    supportPolicy,
+    unsupportedVersion,
 ];

src/interactions/commands/handlers/info/topics/support-policy.ts

@@ -0,0 +1,15 @@
+import {
+    getSupportPolicyEmbed,
+    getSupportPolicyLinkButton,
+    InfoTopic,
+} from '../info-helpers';
+
+export const supportPolicy: InfoTopic = {
+    name: 'Support Policy',
+    message: async () => {
+        return {
+            embeds: [await getSupportPolicyEmbed()],
+            components: [getSupportPolicyLinkButton()],
+        };
+    },
+};

src/interactions/commands/handlers/info/topics/unsupported-version.ts

@@ -0,0 +1,17 @@
+import {
+    getSupportPolicyEmbed,
+    getSupportPolicyLinkButton,
+    InfoTopic,
+} from '../info-helpers';
+
+export const unsupportedVersion: InfoTopic = {
+    name: 'Unsupported Version',
+    message: async () => {
+        return {
+            content:
+                'It looks like you may be running an unsupported version of Firebot. To receive support, please update to a supported version of Firebot.',
+            embeds: [await getSupportPolicyEmbed()],
+            components: [getSupportPolicyLinkButton()],
+        };
+    },
+};

src/services/github.service.ts

@@ -154,3 +154,95 @@ export async function getLatestFirebotReleaseVersion(): Promise<string | null> {
 
     return null;
 }
+
+export async function getRecentFirebotReleases(): Promise<IRelease[] | null> {
+    const getReleasesUrl =
+        'https://api.github.com/repos/crowbartools/firebot/releases?per_page=50';
+
+    let response: AxiosResponse<IRelease[]>;
+    try {
+        response = await axios.get<IRelease[]>(
+            getReleasesUrl,
+            getDefaultAxiosConfig()
+        );
+    } catch (error) {
+        console.log('Error getting firebot releases', error);
+    }
+
+    if (response && response.status == 200) {
+        return response.data;
+    }
+
+    return null;
+}
+
+export interface SupportedVersions {
+    currentStable: string | null;
+    previousStable: string | null;
+    previousStableExpiresAt: number | null;
+    prerelease: string | null;
+}
+
+export async function getSupportedFirebotVersions(): Promise<SupportedVersions> {
+    const releases = await getRecentFirebotReleases();
+
+    const result: SupportedVersions = {
+        currentStable: null,
+        previousStable: null,
+        previousStableExpiresAt: null,
+        prerelease: null,
+    };
+
+    if (!releases || releases.length === 0) {
+        return result;
+    }
+
+    // Find stable releases
+    const stableReleases = releases.filter(
+        (r) => !r.prerelease
+    );
+
+    // Find prerelease versions (betas, etc)
+    const prereleases = releases.filter(
+        (r) => r.prerelease
+    );
+
+    // Current stable is the most recent stable release
+    if (stableReleases.length > 0) {
+        result.currentStable = stableReleases[0].tag_name;
+
+        // Check if previous stable should still be supported (within 30 days of current stable release)
+        if (stableReleases.length > 1) {
+            const currentStableDate = new Date(stableReleases[0].published_at);
+            const now = new Date();
+            const daysSinceCurrentStable = Math.floor(
+                (now.getTime() - currentStableDate.getTime()) / (1000 * 60 * 60 * 24)
+            );
+
+            if (daysSinceCurrentStable <= 30) {
+                result.previousStable = stableReleases[1].tag_name;
+                // Calculate expiration date (30 days from current stable release)
+                const expirationDate = new Date(currentStableDate.getTime() + 30 * 24 * 60 * 60 * 1000);
+                result.previousStableExpiresAt = Math.floor(expirationDate.getTime() / 1000);
+            }
+        }
+    }
+
+    // Check if there's a prerelease that hasn't been superseded by a stable
+    // A prerelease is still supported if it's newer than the current stable
+    if (prereleases.length > 0 && stableReleases.length > 0) {
+        const latestPrerelease = prereleases[0];
+        const latestPrereleaseDate = new Date(latestPrerelease.published_at);
+        const currentStableDate = new Date(stableReleases[0].published_at);
+
+        // Prerelease is supported if it was released after the current stable
+        if (latestPrereleaseDate > currentStableDate) {
+            result.prerelease = latestPrerelease.tag_name;
+        }
+    } else if (prereleases.length > 0 && stableReleases.length === 0) {
+        // No stable releases, so the prerelease is supported
+        result.prerelease = prereleases[0].tag_name;
+    }
+
+    return result;
+}

src/types/github.ts

@@ -59,4 +59,6 @@ export interface ISearchResult {
 
 export interface IRelease {
     tag_name: string;
+    published_at: string;
+    prerelease: boolean;
 }