1.5.3 (#2445)

* APlay Updates (#2432)

* Fixed custom data location sometimes incorrect
- Fixed some songs logged twice in a row
- Updated languages

* Fixed not marking as played with project section actions

* Added fallback API Bible

* Edit timer item

* Using new scripture URL

* Fixed transpose issues
- Updated Dutch language

* Fix output lyric overrides (#2401)

* Fix output lyric overrides by deriving the show template directly from $showsCache

* make sure templates set via 'custom template on first slide' don't inherit the overwrites

* Cleanup

* auto-size caching and optimizing (#2403)

* Fetch and populate pingback url

* Split AmazingLifeProvider into multiple files.  Added CHECK_MEDIA_LICENSE IPC.

* Moved encryption decision to the ContentProvider

* Made content file a child of Media

* Enabled search for content libraries

* Brought in click 3 times for aPlay code

---------

Co-authored-by: Kristoffer <[email protected]>
Co-authored-by: Yuri Vidal <[email protected]>

* Added search autoscroll and fixed CSS (#2435)

* Added search autoscroll and fixed CSS

* Improve Scripture Bible and Collection View

* More UI Changes

* Fixed imports

* Auto error reporting

* Create style/stage from output selector popup
- New default overlays/templates will be automatically added
- Moved "Reset defaults" to context menu
- Start playlist action won't restart if already playing
- Fixed projects in closed folders not showing in RemoteShow
- Fixed projects list not showing in RemoteShow initially
- Small fixes

* Default project name uses local date format

* Scripture template uses style if only one output

* Fixed restoring settings data

* Delete old backups from within the app

* Protocol serving for protected files (#2441)

* Rebase to new branch

* Use non deprecated protocol

* Active template icon in slide editor
- Consider donating message
- Fixed usage not working by default
- Project import does not overwrite show if locked

* Scripture selection fixes
- Updated outputs code

* Fixed YT error
- Small tweaks

* Fixed stage display video mirror not updating
- Tweaked optimized mode
- Version update

---------

Co-authored-by: Jeremy Zongker <[email protected]>
Co-authored-by: Yuri Vidal <[email protected]>
Co-authored-by: Gladson Sam <[email protected]>

Author: 4 people

package-lock.json

@@ -1,6 +1,6 @@
 {
     "name": "freeshow",
-    "version": "1.5.3-beta.3",
+    "version": "1.5.3",
     "private": true,
     "main": "build/electron/index.js",
     "description": "Show song lyrics and more for free!",
@@ -105,6 +105,7 @@
     "dependencies": {
         "@discordjs/opus": "^0.10.0",
         "@googleapis/drive": "^8.16.0",
+        "@sentry/electron": "^7.3.0",
         "@tanstack/pacer": "^0.14.0",
         "@vimeo/player": "^2.29.3",
         "adm-zip": "^0.5.16",

package.json

@@ -434,7 +434,7 @@
         "variable": "Variable",
         "trigger": "Trigger",
         "audio_stream": "Audio stream",
-        "now_playing": "NowPlaying file",
+        "now_playing": "Now playing file",
         "aspect_ratio": "Change aspect ratio",
         "max_lines": "Set max lines",
         "transition": "Transition",

public/lang/en.json

@@ -1,3 +1,4 @@
+import * as Sentry from "@sentry/electron/main"
 import type { BrowserWindow, DesktopCapturerSource } from "electron"
 import { app, desktopCapturer, screen, shell, systemPreferences } from "electron"
 import { machineIdSync } from "node-machine-id"
@@ -9,7 +10,7 @@ import { Main } from "../../types/IPC/Main"
 import type { ErrorLog, LyricSearchResult, OS } from "../../types/Main"
 import { openNowPlaying, setPlayingState, unsetPlayingAudio } from "../audio/nowPlaying"
 import { ContentProviderRegistry } from "../contentProviders"
-import { getBackups, restoreFiles } from "../data/backup"
+import { deleteBackup, getBackups, restoreFiles } from "../data/backup"
 import { checkIfMediaDownloaded, downloadLessonsMedia, downloadMedia } from "../data/downloadMedia"
 import { importShow } from "../data/import"
 import { save } from "../data/save"
@@ -85,6 +86,7 @@ export const mainResponses: MainResponses = {
     /// //////////////////////
     [Main.SAVE]: (a) => save(a),
     [Main.BACKUPS]: () => getBackups(),
+    [Main.DELETE_BACKUP]: (data) => deleteBackup(data),
     [Main.IMPORT]: (data) => startImport(data),
     [Main.BIBLE]: (data) => loadScripture(data),
     [Main.SHOW]: (data) => loadShow(data),
@@ -211,6 +213,14 @@ export const mainResponses: MainResponses = {
             return []
         }
         return await provider.getContent(data.key)
+    },
+    [Main.CHECK_MEDIA_LICENSE]: async (data) => {
+        const provider = ContentProviderRegistry.getProvider(data.providerId)
+        if (!provider?.checkMediaLicense) {
+            console.error(`Provider ${data.providerId} does not support checkMediaLicense`)
+            return null
+        }
+        return await provider.checkMediaLicense(data.mediaId)
     }
 }
 
@@ -410,6 +420,20 @@ export function createLog(err: Error) {
     } as ErrorLog
 }
 
+export function autoErrorReport() {
+    if (!isProd) return
+
+    Sentry.init({
+        dsn: "https://5d1069c3cb6faaa6e7ad0d9dc0145361@o4510419080445952.ingest.us.sentry.io/4510419082346496",
+        beforeSend(event) {
+            // filter out known non-critical errors
+            const errorMessage = event.exception?.values?.[0]?.value || ""
+            const shouldFilter = ERROR_FILTER.some((filter) => errorMessage.includes(filter))
+            return shouldFilter ? null : event
+        },
+    })
+}
+
 // STORE MEDIA AS BASE64
 // function storeMedia(files: { id: string; path: string }[]) {
 //     let encodedFiles: { id: string; content: string }[] = []

src/electron/IPC/responsesMain.ts

@@ -81,6 +81,7 @@ async function convertDynamicValues(data: NowPlayingData) {
                 const coverFilePath = join(audioFolder, fileNameImage)
                 if (value === "{artwork_path}") return coverFilePath
 
+                if (!doesPathExist(coverFilePath)) return ""
                 const pngBuffer = readFile(coverFilePath)
                 const base64String = Buffer.from(pngBuffer).toString('base64')
                 return pngBuffer ? `data:image/png;base64,${base64String}` : ""

src/electron/audio/nowPlaying.ts

@@ -0,0 +1,145 @@
+import express from "express"
+import { ToMain } from "../../../types/IPC/ToMain"
+import { getContentProviderAccess, setContentProviderAccess } from "../../data/contentProviders"
+import { sendToMain } from "../../IPC/main"
+import { getKey } from "../../utils/keys"
+import { OAuth2Helper } from "../base/OAuth2Helper"
+import type { AmazingLifeAuthData, AmazingLifeScopes } from "./types"
+import { AMAZING_LIFE_OAUTH_BASE } from "./types"
+
+/**
+ * Handles authentication and connection management with the AmazingLife (APlay) service.
+ * Manages OAuth PKCE flow, token refresh, and connection state.
+ *
+ * WARNING: This class should ONLY be accessed through AmazingLifeProvider.
+ * Do not import or use this class directly in other parts of the application.
+ * Use ContentProviderRegistry or AmazingLifeProvider instead.
+ */
+export class AmazingLifeConnect {
+    private static readonly AMAZING_LIFE_PORT = 5502
+    private static AMAZING_LIFE_ACCESS: AmazingLifeAuthData | null = null
+    private static readonly clientId: string = getKey("amazinglife_id") || ""
+    private static oauthHelper: OAuth2Helper<AmazingLifeAuthData>
+    private static app = express()
+    private static routeSetup = false
+
+    private static initializeOAuthHelper(): void {
+        if (!this.oauthHelper) {
+            const redirectUri = `http://localhost:${this.AMAZING_LIFE_PORT}/auth/complete`
+            this.oauthHelper = new OAuth2Helper<AmazingLifeAuthData>({
+                clientId: this.clientId,
+                clientSecret: "", // Not needed for PKCE flow
+                authUrl: `${AMAZING_LIFE_OAUTH_BASE}/authorize`,
+                tokenUrl: `${AMAZING_LIFE_OAUTH_BASE}/token`,
+                redirectUri,
+                scopes: ["openid", "profile", "email"],
+                usePKCE: true,
+                additionalParams: { state: "xyz" }
+            })
+        }
+
+        // Set up the auth callback route
+        if (!this.routeSetup) {
+            this.app.get('/auth/complete', (req, res) => {
+                this.handleAuthCallback(req, res)
+            })
+            this.routeSetup = true
+        }
+    }
+
+    public static async connect(scope: AmazingLifeScopes): Promise<AmazingLifeAuthData | null> {
+        const storedAccess = getContentProviderAccess("amazinglife", scope) as AmazingLifeAuthData | null
+
+        if (storedAccess) {
+            this.AMAZING_LIFE_ACCESS = storedAccess
+
+            if (this.isTokenExpired(storedAccess)) {
+                console.info("APlay: Token expired, refreshing...")
+                const refreshed = await this.refreshToken(scope)
+                if (refreshed) {
+                    this.AMAZING_LIFE_ACCESS = refreshed
+                    sendToMain(ToMain.PROVIDER_CONNECT, { providerId: "amazinglife", success: true })
+                    return refreshed
+                }
+            } else {
+                console.info("APlay: Using valid stored credentials")
+                sendToMain(ToMain.PROVIDER_CONNECT, { providerId: "amazinglife", success: true })
+                return storedAccess
+            }
+        }
+
+        console.info("APlay: Starting OAuth flow...")
+        const authData = await this.authenticate(scope)
+        sendToMain(ToMain.PROVIDER_CONNECT, {
+            providerId: "amazinglife",
+            success: !!authData,
+            isFirstConnection: !!authData
+        })
+        return authData
+    }
+
+    public static disconnect(scope: AmazingLifeScopes = "openid profile email"): void {
+        console.log(`APlay: Disconnecting (scope: ${scope})`)
+        setContentProviderAccess("amazinglife", scope, null)
+        this.AMAZING_LIFE_ACCESS = null
+    }
+
+    public static getAccessToken(): string | null {
+        return this.AMAZING_LIFE_ACCESS?.access_token || null
+    }
+
+    private static isTokenExpired(access: AmazingLifeAuthData): boolean {
+        return (access.created_at + access.expires_in) * 1000 < Date.now()
+    }
+
+    private static async refreshToken(scope: AmazingLifeScopes): Promise<AmazingLifeAuthData | null> {
+        if (!this.AMAZING_LIFE_ACCESS?.refresh_token) {
+            console.warn("No refresh token available for APlay")
+            return null
+        }
+
+        try {
+            this.initializeOAuthHelper()
+            const refreshed = await this.oauthHelper.refreshAccessToken(this.AMAZING_LIFE_ACCESS.refresh_token, scope)
+            if (refreshed) {
+                this.AMAZING_LIFE_ACCESS = refreshed
+                setContentProviderAccess("amazinglife", scope, refreshed)
+            }
+            return refreshed
+        } catch (error) {
+            console.error("Failed to refresh APlay token:", error)
+            return null
+        }
+    }
+
+    private static async authenticate(scope: AmazingLifeScopes): Promise<AmazingLifeAuthData | null> {
+        this.initializeOAuthHelper()
+
+        const server = this.app.listen(this.AMAZING_LIFE_PORT, () => {
+            console.info(`Listening for APlay OAuth response at port ${this.AMAZING_LIFE_PORT}`)
+        })
+
+        server.once("error", (err: Error) => {
+            if ((err as any).code === "EADDRINUSE") server.close()
+        })
+
+        try {
+            const authData = await this.oauthHelper.authorize(scope)
+            if (authData) {
+                this.AMAZING_LIFE_ACCESS = authData
+                setContentProviderAccess("amazinglife", scope, authData)
+            }
+            return authData
+        } catch (error) {
+            console.error("APlay authentication failed:", error)
+            return null
+        } finally {
+            server.close()
+        }
+    }
+
+    public static handleAuthCallback(req: express.Request, res: express.Response): void {
+        this.initializeOAuthHelper()
+        this.oauthHelper.handleCallback(req, res)
+    }
+}