feat(reels): file d'attente persistante des rendus (reel_jobs)

L'ancienne file comptait les posts « processing » : un redémarrage pendant
un rendu la bloquait définitivement. Les rendus passent désormais par une
table reel_jobs, réservée avec FOR UPDATE SKIP LOCKED, avec heartbeat et
reprise des jobs interrompus au démarrage (2 tentatives maximum).

- Pipeline vidéo et pipeline images (Remotion) extraits des routes vers
  server/services/reels/, les routes ne font que valider (zod) et mettre en file
- Rendus d'images suivis en base au lieu d'une Map en mémoire
- storeName conservé pour les jobs mis en attente
- Publication Facebook en binaire : l'URL relative /uploads/... transmise
  auparavant n'était pas téléchargeable par Facebook
- Job en échec si toutes les pages échouent ou si la voix demandée manque
  (le service Python renseigne enfin tts_error)
- La voix choisie sur la page images est réellement utilisée
- sync-info mesure la voix Gemini avec sa clé
- Timeouts sur les appels au service FFmpeg, vignettes via execFile,
  /debug-ffmpeg protégé par la clé API, plus de voix anglaise en secours

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018Ze4bs7tpF1KGWUk6ZZSZ4

server/services/ffmpeg.ts

@@ -33,6 +33,11 @@ interface FFmpegReelResponse {
     tts_error?: string;
 }
 
+/** Un rendu long (stabilisation + encodage) peut dépasser plusieurs minutes. */
+const PROCESS_TIMEOUT_MS = 15 * 60_000;
+const TTS_TIMEOUT_MS = 2 * 60_000;
+const HEALTH_TIMEOUT_MS = 5_000;
+
 interface FFmpegConfig {
     apiUrl: string;
     apiKey: string;
@@ -131,6 +136,7 @@ export class FFmpegService {
                     'X-API-Key': config.apiKey,
                 },
                 body: JSON.stringify(requestBody),
+                signal: AbortSignal.timeout(PROCESS_TIMEOUT_MS),
             });
 
             if (!response.ok) {
@@ -240,6 +246,7 @@ export class FFmpegService {
                     'X-API-Key': config.apiKey,
                 },
                 body: JSON.stringify(requestBody),
+                signal: AbortSignal.timeout(PROCESS_TIMEOUT_MS),
             });
 
             if (!response.ok) {
@@ -292,6 +299,7 @@ export class FFmpegService {
                 headers: {
                     'X-API-Key': config.apiKey,
                 },
+                signal: AbortSignal.timeout(HEALTH_TIMEOUT_MS),
             });
             return response.ok;
         } catch {
@@ -320,6 +328,7 @@ export class FFmpegService {
                     tts_engine: ttsEngine,
                     gemini_api_key: geminiApiKey,
                 }),
+                signal: AbortSignal.timeout(TTS_TIMEOUT_MS),
             });
 
             if (!response.ok) {

server/services/reels/assets.ts

@@ -0,0 +1,65 @@
+/**
+ * Résolution des ressources d'un Reel (musique, logo, clé Gemini, nom du
+ * magasin), jusqu'ici recopiée dans chaque route.
+ */
+
+import { storage } from "../../storage";
+import { buildMinioUrl, resolveInternalUrl } from "../minio";
+
+/**
+ * URL de la musique téléchargeable par le service FFmpeg (réseau Docker
+ * interne : l'URL publique HTTPS n'y est pas joignable).
+ */
+export async function resolveMusicUrl(
+  musicTrackId?: string,
+  musicUrl?: string,
+): Promise<string | undefined> {
+  if (musicUrl) return resolveInternalUrl(musicUrl);
+  if (!musicTrackId?.startsWith("internal_")) return undefined;
+
+  try {
+    const track = await storage.getAudioTrack(musicTrackId.slice("internal_".length));
+    return track ? resolveInternalUrl(track.url) : undefined;
+  } catch (error) {
+    console.error("⚠️ [Reels] Piste audio introuvable :", error);
+    return undefined;
+  }
+}
+
+/** Chemin relatif (/uploads/...) du logo configuré, s'il existe. */
+export async function resolveLogoPath(): Promise<string | undefined> {
+  try {
+    const config = await storage.getCloudinaryConfig();
+    if (config?.logoPublicId) {
+      return buildMinioUrl(config.cloudName, config.logoPublicId, config.publicUrl);
+    }
+  } catch (error) {
+    console.error("⚠️ [Reels] Configuration du logo illisible :", error);
+  }
+  return undefined;
+}
+
+/** Clé Gemini : configuration de l'application, sinon variable d'environnement. */
+export async function resolveGeminiApiKey(ttsEngine?: string): Promise<string | undefined> {
+  if (ttsEngine !== "gemini") return undefined;
+  const appConfig = await storage.getAppConfig();
+  return appConfig?.geminiApiKey ?? process.env.GEMINI_API_KEY ?? undefined;
+}
+
+/** Nom affiché dans l'outro : celui de la page choisie, sinon de la première page de l'utilisateur. */
+export async function resolveStoreName(
+  userId: string,
+  preferredPageId?: string,
+): Promise<string | undefined> {
+  try {
+    if (preferredPageId) {
+      const page = await storage.getSocialPage(preferredPageId);
+      if (page) return page.pageName;
+    }
+    const pages = await storage.getSocialPages(userId);
+    return pages[0]?.pageName;
+  } catch (error) {
+    console.error("⚠️ [Reels] Nom du magasin introuvable :", error);
+    return undefined;
+  }
+}

server/services/reels/imagesPipeline.ts

@@ -0,0 +1,234 @@
+/**
+ * Rendu d'un Reel à partir d'images avec Remotion.
+ * Exécuté par la file `reel_jobs` ; la publication reste une étape distincte,
+ * déclenchée par l'utilisateur après l'aperçu.
+ */
+
+import fs from "fs";
+import path from "path";
+import * as musicMetadata from "music-metadata";
+import { bundle } from "@remotion/bundler";
+import { renderMedia, selectComposition } from "@remotion/renderer";
+import { imagesReelParamsSchema, type ImagesReelResult } from "@shared/reel";
+import { ffmpegService } from "../ffmpeg";
+import { generateVideoThumbnail } from "../thumbnail";
+import type { JobContext } from "./queue";
+import { resolveGeminiApiKey, resolveLogoPath } from "./assets";
+
+export const REMOTION_TEMP_DIR = path.join(process.cwd(), "uploads", "temp");
+
+// Durées
+const FPS = 30;
+const ENDING_SECONDS = 3; // diapositive de fin (logo + nom du magasin)
+const MIN_CONTENT_SECONDS = 22; // total >= 25 s
+const MAX_CONTENT_SECONDS = 27; // total <= 30 s
+
+/** Bundle Remotion mis en cache : un seul bundle par processus. */
+let bundleCache: Promise<string> | null = null;
+
+function getBundle(): Promise<string> {
+  if (!bundleCache) {
+    // process.cwd() = /app dans Docker, racine du projet en dev
+    const entryPoint = path.resolve(process.cwd(), "client/src/remotion/index.ts");
+    console.log("📦 Bundling Remotion from:", entryPoint);
+    bundleCache = bundle({ entryPoint }).catch((error) => {
+      bundleCache = null; // réessayer au prochain rendu
+      throw error;
+    });
+  }
+  return bundleCache;
+}
+
+/** URL HTTP locale : l'audio est lu par Chromium, trop lourd pour une data URL. */
+function localHttpUrl(url: string): string {
+  if (!url.startsWith("/")) return url;
+  const port = process.env.PORT || "5555";
+  return `http://localhost:${port}${url}`;
+}
+
+const MIME_BY_EXT: Record<string, string> = {
+  png: "image/png",
+  gif: "image/gif",
+  webp: "image/webp",
+};
+
+/**
+ * Convertit un chemin local /uploads/... en data URL : Chromium dans Docker ne
+ * lit pas http://localhost de façon fiable, les images sont donc embarquées.
+ */
+async function toDataUrl(relativeUrl: string): Promise<string> {
+  if (!relativeUrl.startsWith("/uploads/")) return relativeUrl;
+  const uploadsRoot = path.join(process.cwd(), "uploads") + path.sep;
+  const filePath = path.resolve(process.cwd(), "." + relativeUrl);
+  if (!filePath.startsWith(uploadsRoot)) {
+    throw new Error(`Chemin d'image refusé : ${relativeUrl}`);
+  }
+  try {
+    const buffer = await fs.promises.readFile(filePath);
+    const ext = path.extname(filePath).slice(1).toLowerCase();
+    const mime = MIME_BY_EXT[ext] ?? "image/jpeg";
+    return `data:${mime};base64,${buffer.toString("base64")}`;
+  } catch {
+    console.warn(`⚠️ toDataUrl: fichier introuvable : ${filePath}`);
+    return relativeUrl;
+  }
+}
+
+/**
+ * Retire hashtags et emojis avant la synthèse vocale. Les lettres accentuées
+ * font partie du hashtag (#AménagementExtérieur est retiré en entier).
+ */
+export function stripForTTS(text: string): string {
+  return text
+    .replace(/#[\wÀ-ɏḀ-ỿ]*/g, " ")
+    .replace(/[\uD800-\uDFFF][\uDC00-\uDFFF]/g, " ") // paires de substitution (la plupart des emojis)
+    .replace(/[☀-➿]/g, " ") // symboles divers
+    .replace(/[⬀-⯿]/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+/** Nombre de syllabes d'un mot français (groupes de voyelles). */
+function countSyllablesFr(word: string): number {
+  const clean = word.replace(/[^a-zàâéèêëîïôùûüç]/gi, "").toLowerCase();
+  if (!clean) return 1;
+  return Math.max(1, clean.match(/[aeiouyàâéèêëîïôùûü]+/gi)?.length ?? 1);
+}
+
+const PUNCT_ONLY = /^[.,!?;:…\-—«»"''()\[\]]+$/;
+const EDGE_PUNCT = /^[.,!?;:…«»"''()\[\]]+|[.,!?;:…«»"''()\[\]]+$/g;
+
+/**
+ * Timings des mots prononcés (en images), répartis au prorata des syllabes.
+ * Estimation provisoire : remplacée par les vrais timings de la voix au lot
+ * « voix et sous-titres ».
+ */
+export function computeWordTimings(
+  displayText: string,
+  audioDurationSeconds: number,
+  fps: number,
+  startFrame: number,
+): Array<{ word: string; startFrame: number; endFrame: number }> {
+  const spokenWords = stripForTTS(displayText)
+    .split(/\s+/)
+    .filter((w) => w && !PUNCT_ONLY.test(w));
+  if (spokenWords.length === 0) return [];
+
+  const cleanWords = spokenWords.map((w) => w.replace(EDGE_PUNCT, "") || w);
+  const syllables = cleanWords.map(countSyllablesFr);
+  const totalSyllables = syllables.reduce((a, b) => a + b, 0);
+  const totalFrames = audioDurationSeconds * fps;
+
+  let currentFrame = startFrame;
+  return cleanWords.map((word, i) => {
+    const wordStart = currentFrame;
+    currentFrame += Math.round((syllables[i] / totalSyllables) * totalFrames);
+    return { word, startFrame: wordStart, endFrame: currentFrame };
+  });
+}
+
+export async function runImagesReelJob({ job, progress }: JobContext): Promise<ImagesReelResult> {
+  const params = imagesReelParamsSchema.parse(job.params);
+  const jobTempFiles: string[] = [];
+
+  try {
+    await progress(5, "prepare");
+    const images = await Promise.all(params.imageUrls.map(toDataUrl));
+    const logoPath = await resolveLogoPath();
+    const logoUrl = logoPath ? await toDataUrl(logoPath) : undefined;
+    const musicUrl = params.musicUrl ? localHttpUrl(params.musicUrl) : undefined;
+    const { overlayText, storeName } = params;
+
+    // --- Voix ---
+    let audioUrl: string | undefined;
+    let wordTimings: ReturnType<typeof computeWordTimings> | undefined;
+    let audioDuration = 0;
+
+    const ttsText = overlayText ? stripForTTS(overlayText) : "";
+    if (overlayText && ttsText) {
+      await progress(15, "voice");
+      const geminiApiKey = await resolveGeminiApiKey(params.ttsEngine);
+      const tts = await ffmpegService.previewTTS(ttsText, params.ttsVoice, params.ttsEngine, geminiApiKey);
+      if (!tts.success || !tts.audioBase64) {
+        throw new Error(`La voix n'a pas pu être générée : ${tts.error ?? "réponse vide"}`);
+      }
+
+      const audioFilename = `tts-${job.id}.mp3`;
+      const audioPath = path.join(REMOTION_TEMP_DIR, audioFilename);
+      const audioBuffer = Buffer.from(tts.audioBase64, "base64");
+      await fs.promises.writeFile(audioPath, audioBuffer);
+      jobTempFiles.push(audioPath);
+      audioUrl = localHttpUrl(`/uploads/temp/${audioFilename}`);
+
+      try {
+        audioDuration = (await musicMetadata.parseFile(audioPath)).format.duration ?? 0;
+      } catch {
+        audioDuration = audioBuffer.length / 16000; // estimation à 128 kb/s
+      }
+      audioDuration = Math.max(audioDuration, ttsText.split(/\s+/).length * 0.35);
+      wordTimings = computeWordTimings(overlayText, audioDuration, FPS, 0);
+    }
+
+    // --- Durée : 25 à 30 s ---
+    const naturalContent = Math.max(audioDuration, images.length * 3);
+    const contentSeconds = Math.min(Math.max(naturalContent, MIN_CONTENT_SECONDS), MAX_CONTENT_SECONDS);
+    const endingFrames = logoUrl || storeName ? ENDING_SECONDS * FPS : 0;
+    const totalFrames = Math.round(contentSeconds * FPS) + endingFrames;
+
+    await progress(25, "render");
+    const serveUrl = await getBundle();
+    const inputProps = {
+      images,
+      overlayText,
+      audioUrl,
+      wordTimings,
+      musicUrl,
+      musicVolume: params.musicVolume,
+      logoUrl,
+      storeName,
+      endingFrames,
+    };
+    const composition = await selectComposition({ serveUrl, id: "ImageVideo", inputProps });
+
+    const outputFilename = `out-${job.id}.mp4`;
+    const outputLocation = path.join(REMOTION_TEMP_DIR, outputFilename);
+    let lastReported = 25;
+
+    await renderMedia({
+      composition: { ...composition, durationInFrames: totalFrames },
+      serveUrl,
+      codec: "h264",
+      outputLocation,
+      inputProps,
+      chromiumOptions: {
+        disableWebSecurity: true,
+        ignoreCertificateErrors: true,
+      },
+      concurrency: 1, // évite d'épuiser la mémoire du conteneur
+      onProgress: ({ progress: ratio }) => {
+        const pct = 25 + Math.floor(ratio * 70);
+        if (pct >= lastReported + 5) {
+          lastReported = pct;
+          progress(pct, "render").catch(() => { /* non bloquant */ });
+        }
+      },
+    });
+
+    const thumbnailFilename = outputFilename.replace(".mp4", "-thumb.jpg");
+    const thumbnailOk = await generateVideoThumbnail(
+      outputLocation,
+      path.join(REMOTION_TEMP_DIR, thumbnailFilename),
+      2,
+    );
+
+    return {
+      url: `/uploads/temp/${outputFilename}`,
+      thumbnailUrl: thumbnailOk ? `/uploads/temp/${thumbnailFilename}` : null,
+    };
+  } finally {
+    // Images, musique importée et voix ne servent plus une fois le rendu fini
+    for (const file of [...params.tempFiles, ...jobTempFiles]) {
+      await fs.promises.unlink(file).catch(() => { /* déjà absent */ });
+    }
+  }
+}

server/services/reels/index.ts

@@ -0,0 +1,14 @@
+/**
+ * Point d'entrée des Reels : enregistre les traitements de la file et démarre
+ * le worker.
+ */
+
+import { registerReelJobHandler, startReelWorker } from "./queue";
+import { runVideoReelJob } from "./videoPipeline";
+import { runImagesReelJob } from "./imagesPipeline";
+
+export function startReelProcessing(): Promise<void> {
+  registerReelJobHandler("video", runVideoReelJob);
+  registerReelJobHandler("images", runImagesReelJob);
+  return startReelWorker();
+}

server/services/reels/publish.ts

@@ -0,0 +1,133 @@
+/**
+ * Enregistrement et publication d'un Reel rendu, commun aux Reels vidéo et
+ * images.
+ *
+ * La vidéo est toujours envoyée en binaire : les fichiers vivent sous
+ * /uploads, une URL relative que Facebook ne peut pas télécharger (c'était le
+ * cas de l'ancien `publishReel(originalUrl)`).
+ */
+
+import type { Media } from "@shared/schema";
+import { storage } from "../../storage";
+import { minioService } from "../minio";
+import { createVideoThumbnail } from "../thumbnail";
+import { facebookService } from "../facebook";
+import { tiktokService } from "../tiktok";
+
+export interface PagePublishResult {
+  pageId: string;
+  success: boolean;
+  reelId?: string;
+  error?: string;
+}
+
+/** Range la vidéo rendue dans la médiathèque, avec sa vignette. */
+export async function storeRenderedVideo(
+  userId: string,
+  videoBuffer: Buffer,
+  fileName: string,
+): Promise<Media> {
+  const uploaded = await minioService.uploadMedia(videoBuffer, fileName, userId, "video/mp4");
+  // Vignette extraite maintenant : la vidéo sera supprimée du disque après
+  // publication, mais l'historique doit rester illustré.
+  const thumbnailUrl = await createVideoThumbnail(videoBuffer);
+
+  return storage.createMedia({
+    userId,
+    type: "video",
+    cloudinaryPublicId: uploaded.publicId,
+    originalUrl: uploaded.originalUrl,
+    facebookFeedUrl: uploaded.facebookFeedUrl,
+    instagramFeedUrl: uploaded.instagramFeedUrl,
+    instagramStoryUrl: uploaded.instagramStoryUrl,
+    thumbnailUrl,
+    fileName,
+    fileSize: videoBuffer.length,
+  });
+}
+
+/**
+ * Publie (ou planifie) la vidéo sur chaque page, crée les entrées
+ * `scheduled_posts` et met à jour le statut du post.
+ */
+export async function publishReelToPages(options: {
+  postId: string;
+  pageIds: string[];
+  videoBuffer: Buffer;
+  description: string;
+  scheduledFor?: string;
+}): Promise<PagePublishResult[]> {
+  const { postId, pageIds, videoBuffer, description, scheduledFor } = options;
+  const results: PagePublishResult[] = [];
+
+  for (const pageId of pageIds) {
+    try {
+      const page = await storage.getSocialPage(pageId);
+      if (!page) {
+        results.push({ pageId, success: false, error: "Page non trouvée" });
+        continue;
+      }
+      if (page.platform !== "facebook" && page.platform !== "tiktok") {
+        results.push({
+          pageId,
+          success: false,
+          error: `Plateforme non supportée pour les reels : ${page.platform}`,
+        });
+        continue;
+      }
+
+      const scheduledPost = await storage.createScheduledPost({
+        postId,
+        pageId: page.id,
+        postType: "reel",
+        scheduledAt: scheduledFor ? new Date(scheduledFor) : new Date(),
+      });
+
+      if (scheduledFor) {
+        // Le planificateur publiera à l'heure dite
+        results.push({ pageId, success: true, reelId: "scheduled" });
+        continue;
+      }
+
+      console.log(`🚀 [Reels] Publication sur ${page.platform} ${page.pageName}...`);
+      if (page.platform === "facebook") {
+        const reelId = await facebookService.publishVideoFromBuffer(page, videoBuffer, description);
+        await storage.updateScheduledPost(scheduledPost.id, {
+          publishedAt: new Date(),
+          externalPostId: reelId,
+        });
+        results.push({ pageId, success: true, reelId });
+      } else {
+        // TikTok finalise la publication de son côté : l'envoi est marqué comme
+        // effectué pour ne pas republier, et le poller de statut renseignera
+        // l'identifiant définitif du post.
+        const publishId = await tiktokService.publishVideoFromBuffer(page, videoBuffer, description);
+        await storage.updateScheduledPost(scheduledPost.id, {
+          publishedAt: new Date(),
+          publishId,
+          publishStatus: "PROCESSING_UPLOAD",
+        });
+        results.push({ pageId, success: true, reelId: publishId });
+      }
+    } catch (error) {
+      console.error(`❌ [Reels] Publication sur la page ${pageId} impossible :`, error);
+      results.push({
+        pageId,
+        success: false,
+        error: error instanceof Error ? error.message : "Erreur inconnue",
+      });
+    }
+  }
+
+  const succeeded = results.filter((r) => r.success).length;
+  const status = scheduledFor && succeeded > 0 ? "scheduled" : succeeded > 0 ? "published" : "failed";
+  await storage.updatePost(postId, { status });
+
+  return results;
+}
+
+/** Message d'erreur lisible lorsque toutes les publications ont échoué. */
+export function describePublishFailure(results: PagePublishResult[]): string {
+  const details = results.map((r) => r.error).filter(Boolean).join(" ; ");
+  return `Publication impossible sur toutes les pages${details ? ` : ${details}` : ""}`;
+}

server/services/reels/queue.ts

@@ -0,0 +1,277 @@
+/**
+ * File d'attente persistante des rendus de Reels.
+ *
+ * L'ancienne file comptait les posts « processing » pour décider de lancer un
+ * rendu : un redémarrage pendant un job laissait ce compteur à 1 pour toujours
+ * et bloquait tous les Reels suivants. Ici, chaque job est une ligne de
+ * `reel_jobs` :
+ *  - le worker la réserve atomiquement (`FOR UPDATE SKIP LOCKED`), ce qui exclut
+ *    tout double traitement, même avec plusieurs instances ;
+ *  - un battement de cœur est écrit pendant le rendu ; au démarrage, les jobs
+ *    dont le cœur ne bat plus sont remis en file (ou échouent après
+ *    MAX_ATTEMPTS tentatives).
+ */
+
+import { and, eq, sql } from "drizzle-orm";
+import { db } from "../../db";
+import { posts, reelJobs, type ReelJob } from "@shared/schema";
+import type { ReelJobKind, ReelJobStatus } from "@shared/reel";
+
+const HEARTBEAT_INTERVAL_MS = 15_000;
+/** Au-delà, un job « processing » est considéré comme orphelin. */
+const STALE_AFTER_MS = 2 * 60_000;
+const POLL_INTERVAL_MS = 10_000;
+const MAX_ATTEMPTS = 2;
+
+/** Outils fournis à un handler pour rendre compte de son avancement. */
+export interface JobContext {
+  job: ReelJob;
+  progress(progress: number, step?: string): Promise<void>;
+}
+
+export type JobHandler = (ctx: JobContext) => Promise<unknown>;
+
+const handlers = new Map<ReelJobKind, JobHandler>();
+let running = false;
+let started = false;
+let pollTimer: NodeJS.Timeout | null = null;
+
+export function registerReelJobHandler(kind: ReelJobKind, handler: JobHandler): void {
+  handlers.set(kind, handler);
+}
+
+/** Ajoute un job à la file et réveille le worker. */
+export async function enqueueReelJob(input: {
+  kind: ReelJobKind;
+  userId: string;
+  postId?: string;
+  params: unknown;
+}): Promise<ReelJob> {
+  const [job] = await db
+    .insert(reelJobs)
+    .values({
+      kind: input.kind,
+      userId: input.userId,
+      postId: input.postId,
+      params: input.params,
+    })
+    .returning();
+
+  if (job.postId) {
+    await syncPost(job.postId, "pending", 0);
+  }
+
+  kick();
+  return job;
+}
+
+export async function getReelJob(id: string): Promise<ReelJob | undefined> {
+  const [job] = await db.select().from(reelJobs).where(eq(reelJobs.id, id));
+  return job;
+}
+
+/** Nombre de jobs qui passeront avant un nouveau job (utile pour informer l'utilisateur). */
+export async function countActiveReelJobs(): Promise<number> {
+  const [row] = await db
+    .select({ count: sql<number>`count(*)::int` })
+    .from(reelJobs)
+    .where(sql`${reelJobs.status} IN ('pending', 'processing')`);
+  return row?.count ?? 0;
+}
+
+/**
+ * Démarre le worker : récupère les jobs orphelins puis traite la file.
+ * Idempotent.
+ */
+export async function startReelWorker(): Promise<void> {
+  if (started) return;
+  started = true;
+
+  try {
+    await recoverStaleJobs();
+    await failLegacyStuckPosts();
+  } catch (error) {
+    console.error("❌ [ReelQueue] Récupération des jobs orphelins impossible :", error);
+  }
+
+  pollTimer = setInterval(kick, POLL_INTERVAL_MS);
+  pollTimer.unref();
+  kick();
+}
+
+/** Relance la boucle si elle est à l'arrêt. */
+function kick(): void {
+  if (!started || running) return;
+  running = true;
+  drain()
+    .catch((error) => console.error("❌ [ReelQueue] Erreur de la boucle :", error))
+    .finally(() => {
+      running = false;
+    });
+}
+
+async function drain(): Promise<void> {
+  for (;;) {
+    const job = await claimNextJob();
+    if (!job) return;
+    await runJob(job);
+  }
+}
+
+async function claimNextJob(): Promise<ReelJob | undefined> {
+  const result = await db.execute<{ id: string }>(sql`
+    UPDATE reel_jobs
+       SET status = 'processing',
+           attempts = attempts + 1,
+           heartbeat_at = now(),
+           updated_at = now(),
+           error = NULL
+     WHERE id = (
+       SELECT id FROM reel_jobs
+        WHERE status = 'pending'
+        ORDER BY created_at
+        FOR UPDATE SKIP LOCKED
+        LIMIT 1
+     )
+    RETURNING id
+  `);
+  const id = result.rows[0]?.id;
+  return id ? getReelJob(id) : undefined;
+}
+
+async function runJob(job: ReelJob): Promise<void> {
+  const handler = handlers.get(job.kind as ReelJobKind);
+  console.log(`🎬 [ReelQueue] Job ${job.id} (${job.kind}), tentative ${job.attempts}`);
+
+  const heartbeat = setInterval(() => {
+    db.update(reelJobs)
+      .set({ heartbeatAt: new Date() })
+      .where(eq(reelJobs.id, job.id))
+      .catch((error) => console.warn(`⚠️ [ReelQueue] Heartbeat ${job.id} :`, error));
+  }, HEARTBEAT_INTERVAL_MS);
+
+  const ctx: JobContext = {
+    job,
+    async progress(progress, step) {
+      await updateJob(job, { progress, step });
+    },
+  };
+
+  try {
+    if (!handler) {
+      throw new Error(`Aucun traitement enregistré pour les jobs « ${job.kind} »`);
+    }
+    if (job.postId) {
+      await syncPost(job.postId, "processing", 0);
+    }
+    const result = await handler(ctx);
+    await updateJob(job, { status: "completed", progress: 100, step: "done", result: result ?? null });
+    console.log(`✅ [ReelQueue] Job ${job.id} terminé`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`❌ [ReelQueue] Job ${job.id} en échec :`, error);
+    await updateJob(job, { status: "failed", error: message }).catch((e) =>
+      console.error(`⚠️ [ReelQueue] Statut d'échec non enregistré pour ${job.id} :`, e),
+    );
+  } finally {
+    clearInterval(heartbeat);
+  }
+}
+
+async function updateJob(
+  job: ReelJob,
+  patch: {
+    status?: ReelJobStatus;
+    progress?: number;
+    step?: string;
+    result?: unknown;
+    error?: string;
+  },
+): Promise<void> {
+  await db
+    .update(reelJobs)
+    .set({ ...patch, heartbeatAt: new Date(), updatedAt: new Date() })
+    .where(eq(reelJobs.id, job.id));
+
+  if (job.postId) {
+    const status = patch.status ?? "processing";
+    const progress = patch.status === "failed" ? 0 : patch.progress;
+    await syncPost(job.postId, status, progress, patch.error);
+  }
+}
+
+/**
+ * Reflète l'état du job sur le post : l'interface (`/reels/ongoing`) lit les
+ * colonnes `generation_*` du post.
+ */
+async function syncPost(
+  postId: string,
+  status: ReelJobStatus,
+  progress?: number,
+  error?: string,
+): Promise<void> {
+  const patch: Partial<typeof posts.$inferInsert> = {
+    generationStatus: status,
+    updatedAt: new Date(),
+  };
+  if (progress !== undefined) patch.generationProgress = progress;
+  if (error !== undefined) patch.generationError = error;
+  if (status === "failed") patch.status = "failed";
+  await db.update(posts).set(patch).where(eq(posts.id, postId));
+}
+
+/**
+ * Remet en file les jobs interrompus (serveur arrêté pendant un rendu), ou les
+ * fait échouer s'ils ont déjà épuisé leurs tentatives : un job qui fait tomber
+ * le serveur ne doit pas le faire tomber en boucle.
+ */
+async function recoverStaleJobs(): Promise<void> {
+  const staleBefore = new Date(Date.now() - STALE_AFTER_MS);
+  const stale = await db
+    .select()
+    .from(reelJobs)
+    .where(
+      and(
+        eq(reelJobs.status, "processing"),
+        sql`(${reelJobs.heartbeatAt} IS NULL OR ${reelJobs.heartbeatAt} < ${staleBefore})`,
+      ),
+    );
+
+  for (const job of stale) {
+    if (job.attempts >= MAX_ATTEMPTS) {
+      console.warn(`⚠️ [ReelQueue] Job ${job.id} abandonné après ${job.attempts} tentatives`);
+      await updateJob(job, {
+        status: "failed",
+        error: "Le rendu a été interrompu à plusieurs reprises (redémarrage du serveur).",
+      });
+    } else {
+      console.warn(`♻️ [ReelQueue] Job ${job.id} interrompu, remis en file`);
+      await db
+        .update(reelJobs)
+        .set({ status: "pending", step: null, progress: 0, updatedAt: new Date() })
+        .where(eq(reelJobs.id, job.id));
+      if (job.postId) await syncPost(job.postId, "pending", 0);
+    }
+  }
+}
+
+/**
+ * Posts laissés « processing »/« pending » par l'ancienne file (avant
+ * reel_jobs) : ils n'ont aucun job pour les reprendre et bloquaient l'affichage
+ * des Reels en cours. On les marque en échec pour que l'utilisateur relance.
+ */
+async function failLegacyStuckPosts(): Promise<void> {
+  const result = await db.execute(sql`
+    UPDATE posts
+       SET generation_status = 'failed',
+           generation_progress = 0,
+           generation_error = 'Génération interrompue, veuillez relancer le Reel.',
+           status = 'failed',
+           updated_at = now()
+     WHERE generation_status IN ('processing', 'pending')
+       AND NOT EXISTS (SELECT 1 FROM reel_jobs j WHERE j.post_id = posts.id)
+  `);
+  if (result.rowCount) {
+    console.warn(`⚠️ [ReelQueue] ${result.rowCount} Reel(s) de l'ancienne file marqués en échec`);
+  }
+}

server/services/reels/videoPipeline.ts

@@ -0,0 +1,78 @@
+/**
+ * Rendu d'un Reel à partir d'une vidéo : FFmpeg → médiathèque → publication.
+ * Exécuté par la file `reel_jobs` (voir queue.ts).
+ */
+
+import { videoReelParamsSchema } from "@shared/reel";
+import { storage } from "../../storage";
+import { ffmpegService } from "../ffmpeg";
+import { resolveInternalUrl } from "../minio";
+import type { JobContext } from "./queue";
+import { resolveGeminiApiKey, resolveLogoPath, resolveMusicUrl } from "./assets";
+import { describePublishFailure, publishReelToPages, storeRenderedVideo } from "./publish";
+
+export async function runVideoReelJob({ job, progress }: JobContext) {
+  if (!job.postId) throw new Error("Job vidéo sans post associé");
+  const postId = job.postId;
+  const params = videoReelParamsSchema.parse(job.params);
+
+  await progress(5, "prepare");
+  const media = await storage.getMediaById(params.videoMediaId);
+  if (!media || media.type !== "video") {
+    throw new Error("Vidéo source introuvable ou invalide");
+  }
+
+  const [musicUrl, logoPath, geminiApiKey] = await Promise.all([
+    resolveMusicUrl(params.musicTrackId, params.musicUrl),
+    resolveLogoPath(),
+    resolveGeminiApiKey(params.ttsEngine),
+  ]);
+
+  await progress(15, "render");
+  const startedAt = Date.now();
+  const rendered = await ffmpegService.processReelFromUrl(resolveInternalUrl(media.originalUrl), {
+    text: params.overlayText,
+    musicUrl,
+    ttsEnabled: params.ttsEnabled,
+    ttsVoice: params.ttsVoice,
+    ttsEngine: params.ttsEngine,
+    geminiApiKey,
+    wordDuration: params.wordDuration,
+    fontSize: params.fontSize,
+    musicVolume: params.musicVolume,
+    drawText: params.drawText,
+    stabilize: params.stabilize,
+    watermarkUrl: logoPath ? resolveInternalUrl(logoPath) : undefined,
+    storeName: params.storeName,
+    enableEndingEffect: params.enableEndingEffect,
+  });
+  console.log(`⏱️ [Reels] FFmpeg : ${((Date.now() - startedAt) / 1000).toFixed(1)} s`);
+
+  if (!rendered.success || !rendered.videoBase64) {
+    throw new Error(rendered.error || "Erreur de traitement vidéo FFmpeg");
+  }
+  if (rendered.ttsError) {
+    // Voix demandée mais absente : ne jamais publier un Reel muet sans le dire
+    throw new Error(`La voix n'a pas pu être générée : ${rendered.ttsError}`);
+  }
+
+  await progress(65, "store");
+  const videoBuffer = Buffer.from(rendered.videoBase64, "base64");
+  const processedMedia = await storeRenderedVideo(job.userId, videoBuffer, `reel-${Date.now()}.mp4`);
+  await storage.updatePostMedia(postId, [processedMedia.id]);
+
+  await progress(85, "publish");
+  const results = await publishReelToPages({
+    postId,
+    pageIds: params.pageIds,
+    videoBuffer,
+    description: params.description || params.overlayText || "",
+    scheduledFor: params.scheduledFor,
+  });
+
+  if (!results.some((r) => r.success)) {
+    throw new Error(describePublishFailure(results));
+  }
+
+  return { mediaId: processedMedia.id, results };
+}

server/services/thumbnail.ts

@@ -13,11 +13,11 @@
 
 import fs from 'fs';
 import path from 'path';
-import { exec } from 'child_process';
+import { execFile } from 'child_process';
 import { promisify } from 'util';
 import { minioService } from './minio';
 
-const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
 
 const TEMP_DIR = path.join(process.cwd(), 'uploads', 'temp');
 
@@ -35,8 +35,10 @@ export async function generateVideoThumbnail(
   seekTime: number = 1
 ): Promise<boolean> {
   try {
-    const cmd = `ffmpeg -y -ss ${seekTime} -i "${videoPath}" -vframes 1 -q:v 2 "${outputPath}"`;
-    await execAsync(cmd);
+    // Arguments séparés : aucun passage par le shell, les chemins ne sont jamais interprétés
+    await execFileAsync('ffmpeg', [
+      '-y', '-ss', String(seekTime), '-i', videoPath, '-vframes', '1', '-q:v', '2', outputPath,
+    ]);
     return fs.existsSync(outputPath);
   } catch (error) {
     console.warn('⚠️ Failed to generate video thumbnail:', error);

server/services/ttsSync.ts

@@ -15,11 +15,16 @@ export class TtsSyncService {
    * Calcule le word_duration optimal pour synchroniser l'affichage du texte
    * avec la durée réelle de la voix TTS générée.
    */
-  async calculateSyncTiming(text: string, voice: string, ttsEngine?: string): Promise<SyncTiming> {
+  async calculateSyncTiming(
+    text: string,
+    voice: string,
+    ttsEngine?: string,
+    geminiApiKey?: string
+  ): Promise<SyncTiming> {
     const cleanText = this.cleanText(text);
 
-    // 1. Générer le TTS preview et mesurer sa durée exacte
-    const ttsResult = await ffmpegService.previewTTS(cleanText, voice, ttsEngine);
+    // 1. Générer le TTS preview (avec la même voix que le rendu) et mesurer sa durée exacte
+    const ttsResult = await ffmpegService.previewTTS(cleanText, voice, ttsEngine, geminiApiKey);
     if (!ttsResult.success || !ttsResult.audioBase64) {
       throw new Error('TTS preview failed: ' + (ttsResult.error || 'unknown'));
     }