import { ResponseError } from "@homarr/common/server"; import { fetchWithTrustedCertificatesAsync } from "@homarr/core/infrastructure/http"; import { ImageProxy } from "@homarr/image-proxy"; import type { IntegrationTestingInput } from "../base/integration"; import { Integration } from "../base/integration"; import type { TestingResult } from "../base/test-connection/test-connection-service"; import { tracearrHealthResponseSchema } from "./tracearr-types"; import type { TracearrDashboardData, TracearrHealthResponse, TracearrHistoryResponse, TracearrStatsResponse, TracearrStreamsResponse, TracearrViolationsResponse, } from "./tracearr-types"; export class TracearrIntegration extends Integration { protected async testingAsync(input: IntegrationTestingInput): Promise { const healthUrl = this.url("/api/v1/public/health"); const healthResponse = await input.fetchAsync(healthUrl, { headers: this.getAuthHeaders(), }); if (!healthResponse.ok) { throw new ResponseError(healthResponse); } return { success: true }; } /** * GET /api/v1/public/health * Check server connectivity and status */ public async getHealthAsync(): Promise { const url = this.url("/api/v1/public/health"); const response = await fetchWithTrustedCertificatesAsync(url, { headers: this.getAuthHeaders(), }); if (!response.ok) { throw new ResponseError(response); } return tracearrHealthResponseSchema.parse(await response.json()); } /** * GET /api/v1/public/stats * Dashboard statistics with optional server filter */ public async getStatsAsync(serverId?: string): Promise { const url = this.url("/api/v1/public/stats", { serverId }); const response = await fetchWithTrustedCertificatesAsync(url, { headers: this.getAuthHeaders(), }); if (!response.ok) { throw new ResponseError(response); } return (await response.json()) as TracearrStatsResponse; } /** * GET /api/v1/public/streams * Active playback sessions with codec and quality details */ public async getStreamsAsync(serverId?: string): Promise { const url = this.url("/api/v1/public/streams", { serverId }); const response = await fetchWithTrustedCertificatesAsync(url, { headers: this.getAuthHeaders(), }); if (!response.ok) { throw new ResponseError(response); } const json = (await response.json()) as TracearrStreamsResponse; const imageProxy = new ImageProxy(); return { ...json, data: await Promise.all( json.data.map(async (stream) => { if (stream.userAvatarUrl) { stream.userAvatarUrl = await this.proxyImageAsync(imageProxy, stream.userAvatarUrl, stream.id, "avatar"); } if (stream.posterUrl) { stream.posterUrl = await this.proxyImageAsync(imageProxy, stream.posterUrl, stream.id, "poster"); } return stream; }), ), }; } /** * GET /api/v1/public/violations * Recent rule violations with optional pagination */ public async getViolationsAsync(pageSize = 5): Promise { const url = this.url("/api/v1/public/violations", { page: "1", pageSize: String(pageSize), }); const response = await fetchWithTrustedCertificatesAsync(url, { headers: this.getAuthHeaders(), }); if (!response.ok) { throw new ResponseError(response); } const json = (await response.json()) as TracearrViolationsResponse; const imageProxy = new ImageProxy(); return { ...json, data: await Promise.all( json.data.map(async (violation) => { violation.user.avatarUrl = await this.proxyImageAsync( imageProxy, violation.user.avatarUrl, violation.user.id, "avatar", ); return violation; }), ), }; } /** * GET /api/v1/public/history * Session history with optional pagination */ public async getHistoryAsync(pageSize = 10): Promise { const url = this.url("/api/v1/public/history", { page: "1", pageSize: String(pageSize), }); const response = await fetchWithTrustedCertificatesAsync(url, { headers: this.getAuthHeaders(), }); if (!response.ok) { throw new ResponseError(response); } const json = (await response.json()) as TracearrHistoryResponse; const imageProxy = new ImageProxy(); return { ...json, data: await Promise.all( json.data.map(async (session) => { session.user.avatarUrl = await this.proxyImageAsync( imageProxy, session.user.avatarUrl, session.user.id, "avatar", ); return session; }), ), }; } /** * Get combined dashboard data (stats + streams + violations + history) * Uses Promise.allSettled for optional endpoints so failures don't break the dashboard. */ public async getDashboardDataAsync(): Promise { const [stats, streams] = await Promise.all([this.getStatsAsync(), this.getStreamsAsync()]); const [violationsResult, historyResult] = await Promise.allSettled([ this.getViolationsAsync(), this.getHistoryAsync(), ]); return { stats, streams, violations: violationsResult.status === "fulfilled" ? violationsResult.value : null, recentActivity: historyResult.status === "fulfilled" ? historyResult.value : null, }; } private getAuthHeaders(): Record { return { Authorization: `Bearer ${this.getSecretValue("apiKey")}`, }; } private async proxyImageAsync( imageProxy: ImageProxy, url: string | null | undefined, uniqueId: string, discriminator: string, ): Promise { if (!url) return null; try { // ImageProxy doesn't support fallback urls so we need to remove them const cleanUrl = url.replace(/&fallback=[^&]+/, "").replace(/\?fallback=[^&]+&?/, "?"); // Build the full URL, then inject _uid as the FIRST query param. // This is critical because ImageProxy uses bcrypt which truncates at 72 bytes. // Without this, all long avatar/poster URLs from the same session hash identically // since they share the same first 72+ bytes. const baseUrl = this.url(cleanUrl as `/${string}`).toString(); const prefix = `_uid=${discriminator}_${uniqueId}&`; const fullUrl = baseUrl.includes("?") ? baseUrl.replace("?", `?${prefix}`) : `${baseUrl}?${prefix}`; return await imageProxy.createImageAsync(fullUrl, this.getAuthHeaders()); } catch { return null; } } }