611 lines
18 KiB
TypeScript
611 lines
18 KiB
TypeScript
/**
|
|
* Protocole partagé entre le serveur de contrôle, les agents et le dashboard.
|
|
*
|
|
* Transport : WebSocket, messages JSON, un champ `type` discriminant.
|
|
* - agent <-> serveur : /ws/agent (l'agent initie la connexion sortante)
|
|
* - browser <- serveur : /ws/dashboard (flux de statut temps réel)
|
|
*/
|
|
|
|
export const PROTOCOL_VERSION = 1;
|
|
|
|
export type Platform = 'windows' | 'linux' | 'darwin' | 'unknown';
|
|
|
|
/** Paramètres de connexion à obs-websocket (plugin intégré à OBS >= 28). */
|
|
export interface ObsSettings {
|
|
host: string;
|
|
port: number;
|
|
/** Mot de passe obs-websocket ; chaîne vide si l'authentification est désactivée. */
|
|
password: string;
|
|
}
|
|
|
|
export const DEFAULT_OBS_SETTINGS: ObsSettings = {
|
|
host: '127.0.0.1',
|
|
port: 4455,
|
|
password: '',
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Actions pilotables sur un agent
|
|
// ---------------------------------------------------------------------------
|
|
|
|
export const AGENT_ACTIONS = [
|
|
'obs.connect',
|
|
'obs.disconnect',
|
|
'obs.refresh',
|
|
'record.start',
|
|
'record.stop',
|
|
'record.pause',
|
|
'record.resume',
|
|
'record.split',
|
|
'stream.start',
|
|
'stream.stop',
|
|
'scene.set',
|
|
'profile.set',
|
|
'collection.set',
|
|
'recordDirectory.set',
|
|
'watch.check',
|
|
'hotkey.fullscreen',
|
|
'browser.open',
|
|
'browser.close',
|
|
'capture.start',
|
|
'capture.stop',
|
|
'agent.update',
|
|
'agent.ping',
|
|
] as const;
|
|
|
|
export type AgentAction = (typeof AGENT_ACTIONS)[number];
|
|
|
|
export function isAgentAction(value: unknown): value is AgentAction {
|
|
return typeof value === 'string' && (AGENT_ACTIONS as readonly string[]).includes(value);
|
|
}
|
|
|
|
/** Paramètres attendus par action (les autres actions n'en prennent aucun). */
|
|
export interface AgentActionParams {
|
|
'scene.set': { scene: string };
|
|
'profile.set': { profile: string };
|
|
'collection.set': { collection: string };
|
|
'recordDirectory.set': { directory: string };
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Surveillance du statut d'un stream (pause auto pendant les shows privés)
|
|
// ---------------------------------------------------------------------------
|
|
|
|
export const WATCH_PROVIDERS = ['stripchat'] as const;
|
|
export type WatchProvider = (typeof WATCH_PROVIDERS)[number];
|
|
|
|
/** État normalisé du stream surveillé. */
|
|
export type StreamState = 'public' | 'private' | 'offline' | 'unknown';
|
|
|
|
export interface FullscreenSettings {
|
|
/** Rappeler le plein écran à la fin d'un show privé. */
|
|
enabled: boolean;
|
|
/** Touche à envoyer au lecteur (raccourci plein écran, « f » sur Stripchat). */
|
|
key: string;
|
|
/** Fragment de titre de fenêtre identifiant le lecteur (insensible à la casse). */
|
|
windowMatch: string;
|
|
/** Délai avant l'envoi, le temps que le flux public soit rechargé. */
|
|
delayMs: number;
|
|
}
|
|
|
|
export interface WatchSettings {
|
|
enabled: boolean;
|
|
provider: WatchProvider;
|
|
/** Pseudo du streamer, tel qu'il apparaît dans l'URL de sa page. */
|
|
username: string;
|
|
pollIntervalMs: number;
|
|
/**
|
|
* Statuts bruts de l'API considérés comme « pas de flux public ».
|
|
* Valeurs observées côté Stripchat : public, private, p2p, groupShow, idle.
|
|
*/
|
|
privateStatuses: string[];
|
|
/**
|
|
* Lectures « privé » consécutives exigées avant de mettre en pause.
|
|
* Asymétrique volontairement : une fausse pause coûte du contenu perdu,
|
|
* une fausse reprise ne coûte que quelques secondes d'écran d'attente.
|
|
*/
|
|
confirmations: number;
|
|
pauseOnPrivate: boolean;
|
|
resumeOnPublic: boolean;
|
|
fullscreen: FullscreenSettings;
|
|
}
|
|
|
|
/**
|
|
* Pilotage du navigateur de la VM.
|
|
*
|
|
* On lance le navigateur déjà installé, avec son profil et sa session : c'est ce
|
|
* qui donne accès au flux comme si l'opérateur l'ouvrait lui-même. Aucune
|
|
* instance dédiée, aucun profil de test.
|
|
*/
|
|
export interface BrowserSettings {
|
|
enabled: boolean;
|
|
/** Exécutable du navigateur. */
|
|
command: string;
|
|
/** Arguments placés avant l'URL. */
|
|
args: string[];
|
|
/** Délai avant l'envoi du plein écran, le temps que le lecteur démarre. */
|
|
readyDelayMs: number;
|
|
/** Fermer la fenêtre quand l'enregistrement s'arrête. */
|
|
closeOnStop: boolean;
|
|
}
|
|
|
|
export const DEFAULT_BROWSER_SETTINGS: BrowserSettings = {
|
|
enabled: false,
|
|
command: 'firefox',
|
|
args: ['--new-window'],
|
|
readyDelayMs: 8000,
|
|
closeOnStop: true,
|
|
};
|
|
|
|
export function normalizeBrowserSettings(raw: unknown): BrowserSettings {
|
|
const input = (raw ?? {}) as Partial<BrowserSettings>;
|
|
const base = DEFAULT_BROWSER_SETTINGS;
|
|
const delay = Number(input.readyDelayMs);
|
|
|
|
return {
|
|
enabled: input.enabled === true,
|
|
command:
|
|
typeof input.command === 'string' && input.command.trim()
|
|
? input.command.trim()
|
|
: base.command,
|
|
args: Array.isArray(input.args)
|
|
? input.args.filter((arg): arg is string => typeof arg === 'string' && arg.trim() !== '')
|
|
: base.args,
|
|
readyDelayMs: Number.isFinite(delay)
|
|
? Math.min(Math.max(Math.round(delay), 0), 120_000)
|
|
: base.readyDelayMs,
|
|
closeOnStop: input.closeOnStop !== false,
|
|
};
|
|
}
|
|
|
|
export const DEFAULT_WATCH_SETTINGS: WatchSettings = {
|
|
enabled: false,
|
|
provider: 'stripchat',
|
|
username: '',
|
|
pollIntervalMs: 10_000,
|
|
privateStatuses: ['private', 'p2p', 'groupShow', 'virtualPrivate', 'ticketShow'],
|
|
confirmations: 2,
|
|
pauseOnPrivate: true,
|
|
resumeOnPublic: true,
|
|
fullscreen: {
|
|
enabled: true,
|
|
key: 'f',
|
|
windowMatch: 'Stripchat',
|
|
delayMs: 4000,
|
|
},
|
|
};
|
|
|
|
/** État courant de la surveillance, remonté avec le statut de l'agent. */
|
|
export interface WatchState {
|
|
enabled: boolean;
|
|
provider: WatchProvider;
|
|
username: string;
|
|
state: StreamState;
|
|
/** Statut brut renvoyé par l'API, utile pour diagnostiquer un mapping. */
|
|
rawStatus?: string;
|
|
/** Depuis quand l'état normalisé est stable. */
|
|
since: number;
|
|
lastCheckedAt: number;
|
|
lastError?: string;
|
|
/** Vrai si c'est la surveillance — et non l'opérateur — qui a mis en pause. */
|
|
autoPaused: boolean;
|
|
/** Lectures « privé » accumulées, en attente du seuil de confirmation. */
|
|
pendingConfirmations: number;
|
|
}
|
|
|
|
export function emptyWatchState(settings: WatchSettings): WatchState {
|
|
return {
|
|
enabled: settings.enabled,
|
|
provider: settings.provider,
|
|
username: settings.username,
|
|
state: 'unknown',
|
|
since: Date.now(),
|
|
lastCheckedAt: 0,
|
|
autoPaused: false,
|
|
pendingConfirmations: 0,
|
|
};
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Statut remonté par un agent
|
|
// ---------------------------------------------------------------------------
|
|
|
|
export interface AgentStatus {
|
|
/** L'agent a-t-il une session obs-websocket établie ? */
|
|
obsConnected: boolean;
|
|
obsVersion?: string;
|
|
obsError?: string;
|
|
|
|
recording: boolean;
|
|
recordPaused: boolean;
|
|
/** Durée d'enregistrement au format HH:MM:SS.mmm renvoyé par OBS. */
|
|
recordTimecode?: string;
|
|
recordBytes?: number;
|
|
/** Chemin du dernier fichier écrit (renseigné à l'arrêt de l'enregistrement). */
|
|
lastRecordingPath?: string;
|
|
recordDirectory?: string;
|
|
|
|
streaming: boolean;
|
|
streamTimecode?: string;
|
|
|
|
currentScene?: string;
|
|
scenes: string[];
|
|
currentProfile?: string;
|
|
profiles: string[];
|
|
currentCollection?: string;
|
|
collections: string[];
|
|
|
|
/** Statistiques OBS. */
|
|
cpuUsage?: number;
|
|
fps?: number;
|
|
droppedFrames?: number;
|
|
renderSkippedFrames?: number;
|
|
|
|
/** Statistiques machine (collectées par l'agent, pas par OBS). */
|
|
systemCpu?: number;
|
|
systemMemoryUsed?: number;
|
|
systemMemoryTotal?: number;
|
|
diskFreeBytes?: number;
|
|
diskTotalBytes?: number;
|
|
|
|
/** Surveillance du stream source, absente si elle n'est pas configurée. */
|
|
watch?: WatchState;
|
|
|
|
/**
|
|
* Empreinte courte du binaire en cours d'exécution. Deux agents partageant
|
|
* cette valeur tournent sur le même build — c'est ce qui rend visible un
|
|
* agent resté en arrière après une mise à jour.
|
|
*/
|
|
buildId?: string;
|
|
/** Vrai si l'agent sait se mettre à jour seul (URL de paquet connue). */
|
|
canSelfUpdate?: boolean;
|
|
|
|
updatedAt: number;
|
|
}
|
|
|
|
export function emptyStatus(): AgentStatus {
|
|
return {
|
|
obsConnected: false,
|
|
recording: false,
|
|
recordPaused: false,
|
|
streaming: false,
|
|
scenes: [],
|
|
profiles: [],
|
|
collections: [],
|
|
updatedAt: 0,
|
|
};
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Messages agent -> serveur
|
|
// ---------------------------------------------------------------------------
|
|
|
|
export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
|
|
|
|
export interface HelloMessage {
|
|
type: 'hello';
|
|
protocol: number;
|
|
/** Absent lors du tout premier enrôlement : le serveur en attribue un. */
|
|
agentId?: string;
|
|
name: string;
|
|
hostname: string;
|
|
platform: Platform;
|
|
agentVersion: string;
|
|
}
|
|
|
|
export interface StatusMessage {
|
|
type: 'status';
|
|
status: AgentStatus;
|
|
}
|
|
|
|
export interface ResultMessage {
|
|
type: 'result';
|
|
requestId: string;
|
|
ok: boolean;
|
|
data?: unknown;
|
|
error?: string;
|
|
}
|
|
|
|
export interface LogMessage {
|
|
type: 'log';
|
|
level: LogLevel;
|
|
message: string;
|
|
ts: number;
|
|
}
|
|
|
|
export interface PongMessage {
|
|
type: 'pong';
|
|
ts: number;
|
|
}
|
|
|
|
export type AgentToServer =
|
|
| HelloMessage
|
|
| StatusMessage
|
|
| ResultMessage
|
|
| LogMessage
|
|
| PongMessage;
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Messages serveur -> agent
|
|
// ---------------------------------------------------------------------------
|
|
|
|
export interface WelcomeMessage {
|
|
type: 'welcome';
|
|
agentId: string;
|
|
/** Fourni uniquement lors de l'enrôlement : l'agent doit le persister. */
|
|
token?: string;
|
|
obs: ObsSettings;
|
|
/** Fréquence de remontée de statut demandée. */
|
|
statusIntervalMs: number;
|
|
/** Si vrai, l'agent tente de se connecter à OBS dès le démarrage. */
|
|
autoConnectObs: boolean;
|
|
watch: WatchSettings;
|
|
browser: BrowserSettings;
|
|
}
|
|
|
|
export interface CommandMessage {
|
|
type: 'command';
|
|
requestId: string;
|
|
action: AgentAction;
|
|
params?: Record<string, unknown>;
|
|
}
|
|
|
|
export interface ConfigMessage {
|
|
type: 'config';
|
|
obs: ObsSettings;
|
|
autoConnectObs: boolean;
|
|
watch: WatchSettings;
|
|
browser: BrowserSettings;
|
|
}
|
|
|
|
export interface PingMessage {
|
|
type: 'ping';
|
|
ts: number;
|
|
}
|
|
|
|
export type ServerToAgent = WelcomeMessage | CommandMessage | ConfigMessage | PingMessage;
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Vue agrégée exposée au dashboard
|
|
// ---------------------------------------------------------------------------
|
|
|
|
export interface AgentView {
|
|
id: string;
|
|
name: string;
|
|
hostname: string | null;
|
|
platform: Platform;
|
|
agentVersion: string | null;
|
|
online: boolean;
|
|
lastSeenAt: number | null;
|
|
createdAt: number;
|
|
obs: ObsSettings;
|
|
autoConnectObs: boolean;
|
|
watch: WatchSettings;
|
|
browser: BrowserSettings;
|
|
notes: string | null;
|
|
status: AgentStatus;
|
|
}
|
|
|
|
export interface LogEntry {
|
|
id: number;
|
|
agentId: string | null;
|
|
agentName: string | null;
|
|
level: LogLevel;
|
|
message: string;
|
|
ts: number;
|
|
}
|
|
|
|
/**
|
|
* Profil surveillé par le serveur : on colle l'URL d'un streamer, le serveur
|
|
* sonde son statut et signale les passages en direct.
|
|
*/
|
|
export interface WatchTarget {
|
|
id: string;
|
|
provider: WatchProvider;
|
|
username: string;
|
|
/** Nom lisible, à défaut le pseudo. */
|
|
label: string | null;
|
|
url: string;
|
|
/** Agent qui enregistrera ce streamer, s'il est assigné. */
|
|
agentId: string | null;
|
|
notify: boolean;
|
|
state: StreamState;
|
|
rawStatus: string | null;
|
|
/** Depuis quand l'état est stable, selon nos propres observations. */
|
|
stateSince: number;
|
|
lastCheckedAt: number | null;
|
|
lastError: string | null;
|
|
createdAt: number;
|
|
|
|
/** Photo de profil. */
|
|
avatarUrl: string | null;
|
|
/**
|
|
* Début du statut courant d'après la plateforme. Quand `state` vaut `public`,
|
|
* c'est l'heure de début du stream en cours.
|
|
*/
|
|
statusChangedAt: number | null;
|
|
/** Dernier stream terminé : début et fin observés. */
|
|
lastLiveStartedAt: number | null;
|
|
lastLiveEndedAt: number | null;
|
|
}
|
|
|
|
export type ServerToDashboard =
|
|
| { type: 'snapshot'; agents: AgentView[]; logs: LogEntry[]; targets: WatchTarget[] }
|
|
| { type: 'agent'; agent: AgentView }
|
|
| { type: 'agent.removed'; agentId: string }
|
|
| { type: 'log'; entry: LogEntry }
|
|
| { type: 'target'; target: WatchTarget }
|
|
| { type: 'target.removed'; targetId: string }
|
|
/** Transition vers le direct : c'est ce qui déclenche la notification. */
|
|
| { type: 'target.live'; target: WatchTarget };
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Helpers
|
|
// ---------------------------------------------------------------------------
|
|
|
|
export function detectPlatform(raw: string): Platform {
|
|
if (raw === 'win32') return 'windows';
|
|
if (raw === 'linux') return 'linux';
|
|
if (raw === 'darwin') return 'darwin';
|
|
return 'unknown';
|
|
}
|
|
|
|
export function safeJsonParse<T>(raw: string): T | null {
|
|
try {
|
|
return JSON.parse(raw) as T;
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Normalise une configuration de surveillance venue du réseau ou de la base :
|
|
* champs manquants complétés, valeurs numériques bornées.
|
|
*/
|
|
export function normalizeWatchSettings(raw: unknown): WatchSettings {
|
|
const input = (raw ?? {}) as Partial<WatchSettings>;
|
|
const base = DEFAULT_WATCH_SETTINGS;
|
|
const fullscreen = (input.fullscreen ?? {}) as Partial<FullscreenSettings>;
|
|
|
|
const clamp = (value: unknown, fallback: number, min: number, max: number): number => {
|
|
const parsed = Number(value);
|
|
if (!Number.isFinite(parsed)) return fallback;
|
|
return Math.min(Math.max(Math.round(parsed), min), max);
|
|
};
|
|
|
|
const statuses = Array.isArray(input.privateStatuses)
|
|
? input.privateStatuses.filter((s): s is string => typeof s === 'string' && s.trim() !== '')
|
|
: base.privateStatuses;
|
|
|
|
return {
|
|
enabled: input.enabled === true,
|
|
provider: WATCH_PROVIDERS.includes(input.provider as WatchProvider)
|
|
? (input.provider as WatchProvider)
|
|
: base.provider,
|
|
username: typeof input.username === 'string' ? input.username.trim() : base.username,
|
|
// Plancher à 3 s : inutile de marteler l'API, un show privé dure des minutes.
|
|
pollIntervalMs: clamp(input.pollIntervalMs, base.pollIntervalMs, 3000, 300_000),
|
|
privateStatuses: statuses.length > 0 ? statuses : base.privateStatuses,
|
|
confirmations: clamp(input.confirmations, base.confirmations, 1, 10),
|
|
pauseOnPrivate: input.pauseOnPrivate !== false,
|
|
resumeOnPublic: input.resumeOnPublic !== false,
|
|
fullscreen: {
|
|
enabled: fullscreen.enabled !== false,
|
|
key:
|
|
typeof fullscreen.key === 'string' && fullscreen.key.trim()
|
|
? fullscreen.key.trim()
|
|
: base.fullscreen.key,
|
|
windowMatch:
|
|
typeof fullscreen.windowMatch === 'string'
|
|
? fullscreen.windowMatch.trim()
|
|
: base.fullscreen.windowMatch,
|
|
delayMs: clamp(fullscreen.delayMs, base.fullscreen.delayMs, 0, 120_000),
|
|
},
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Extrait le pseudo d'un profil Stripchat à partir d'une URL complète, d'une URL
|
|
* sans schéma, ou d'un pseudo saisi seul.
|
|
*/
|
|
export function parseStripchatUsername(input: string): string | null {
|
|
const trimmed = input.trim();
|
|
if (!trimmed) return null;
|
|
|
|
const looksLikeUrl = trimmed.includes('/') || trimmed.includes('.');
|
|
if (looksLikeUrl) {
|
|
try {
|
|
const url = new URL(trimmed.includes('://') ? trimmed : `https://${trimmed}`);
|
|
if (!/(^|\.)stripchat\.com$/i.test(url.hostname)) return null;
|
|
const first = url.pathname.split('/').filter(Boolean)[0];
|
|
return first && USERNAME_PATTERN.test(first) ? first : null;
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
return USERNAME_PATTERN.test(trimmed) ? trimmed : null;
|
|
}
|
|
|
|
const USERNAME_PATTERN = /^[A-Za-z0-9_.-]{2,64}$/;
|
|
|
|
export function stripchatProfileUrl(username: string): string {
|
|
return `https://fr.stripchat.com/${username}`;
|
|
}
|
|
|
|
/**
|
|
* Interroge le statut d'un modèle Stripchat.
|
|
*
|
|
* Le champ autoritatif est `user.user.status` sur
|
|
* `/api/front/v2/models/username/{pseudo}/cam`. Valeurs relevées en production :
|
|
* `public`, `private`, `p2p`, `groupShow`, `idle`.
|
|
*
|
|
* Mutualisé entre l'agent (pause automatique) et le serveur (veille) : une seule
|
|
* définition de l'endpoint et du chemin du champ à maintenir.
|
|
*/
|
|
export interface StripchatStatus {
|
|
raw: string;
|
|
state: StreamState;
|
|
/** Photo de profil, absente si le modèle n'en a pas. */
|
|
avatarUrl: string | null;
|
|
/**
|
|
* Début du statut courant. Quand le modèle est public, c'est l'heure de début
|
|
* du stream en cours — bien plus précis que notre propre première observation.
|
|
*/
|
|
statusChangedAt: number | null;
|
|
}
|
|
|
|
export async function fetchStripchatStatus(
|
|
username: string,
|
|
privateStatuses: string[],
|
|
timeoutMs = 8000,
|
|
): Promise<StripchatStatus> {
|
|
const url = `https://fr.stripchat.com/api/front/v2/models/username/${encodeURIComponent(
|
|
username,
|
|
)}/cam`;
|
|
|
|
const response = await fetch(url, {
|
|
headers: {
|
|
'user-agent':
|
|
'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0 Safari/537.36',
|
|
accept: 'application/json',
|
|
},
|
|
signal: AbortSignal.timeout(timeoutMs),
|
|
});
|
|
|
|
if (response.status === 404) {
|
|
return { raw: 'notFound', state: 'offline', avatarUrl: null, statusChangedAt: null };
|
|
}
|
|
if (!response.ok) throw new Error(`API Stripchat : HTTP ${response.status}`);
|
|
|
|
const payload = (await response.json()) as {
|
|
user?: { user?: { status?: string; avatarUrl?: string; statusChangedAt?: string } };
|
|
};
|
|
const profile = payload?.user?.user;
|
|
const raw = profile?.status;
|
|
if (typeof raw !== 'string') {
|
|
throw new Error('Réponse Stripchat inattendue : user.user.status absent');
|
|
}
|
|
|
|
const changedAt = profile?.statusChangedAt
|
|
? Date.parse(profile.statusChangedAt)
|
|
: Number.NaN;
|
|
|
|
return {
|
|
raw,
|
|
state: mapStreamStatus(raw, privateStatuses),
|
|
avatarUrl: typeof profile?.avatarUrl === 'string' && profile.avatarUrl ? profile.avatarUrl : null,
|
|
statusChangedAt: Number.isFinite(changedAt) ? changedAt : null,
|
|
};
|
|
}
|
|
|
|
/** Traduit un statut brut de l'API en état normalisé. */
|
|
export function mapStreamStatus(raw: string | undefined, privateStatuses: string[]): StreamState {
|
|
if (!raw) return 'unknown';
|
|
const value = raw.toLowerCase();
|
|
if (privateStatuses.some((status) => status.toLowerCase() === value)) return 'private';
|
|
if (value === 'public') return 'public';
|
|
// idle / off / offline / deleted : le modèle ne diffuse pas.
|
|
return 'offline';
|
|
}
|