includio-cms 0.13.3 → 0.13.4

package/CHANGELOG.md

@@ -3,6 +3,18 @@
 All notable changes to includio-cms are documented here.
 Generated from `src/lib/updates/` — do not edit manually.
 
+## 0.13.4 — 2026-03-24
+
+Video poster regeneration, filename sanitization
+
+### Added
+- Batch regenerate video posters & thumbnails from admin maintenance page with SSE progress
+- Video poster status reporting in media GC endpoint
+- Extracted video processing to reusable module
+
+### Fixed
+- Filename sanitization normalizes Unicode to NFC (prevents NFD/NFC mismatch)
+
 ## 0.13.3 — 2026-03-23
 
 Security hardening, per-language content fixes

package/ROADMAP.md

@@ -239,6 +239,13 @@
 - [x] `[fix]` `[P1]` CMS constructor validates non-empty languages array <!-- files: src/lib/core/cms.ts -->
 - [x] `[fix]` `[P2]` Unhandled promise rejection handlers in admin components
 
+## 0.13.4 — Video poster regeneration
+
+- [x] `[feature]` `[P1]` Batch video poster regeneration — admin maintenance page with SSE progress <!-- files: src/lib/admin/api/regenerate-posters.ts, src/lib/core/server/media/operations/batchRegenerateVideoPosters.ts, src/lib/admin/client/maintenance/maintenance-page.svelte -->
+- [x] `[feature]` `[P1]` Video poster status reporting in media GC endpoint <!-- files: src/lib/admin/api/media-gc.ts -->
+- [x] `[chore]` `[P1]` Extracted video processing to reusable module <!-- files: src/lib/files-local/video.ts, src/lib/files-local/index.ts -->
+- [x] `[fix]` `[P1]` Filename sanitization normalizes Unicode to NFC <!-- files: src/lib/files-local/sanitizeFilename.ts -->
+
 ## 0.14.0 — SEO module
 
 - [ ] `[feature]` `[P1]` SERP preview + character limits for title/description <!-- files: src/lib/admin/components/fields/seo-field.svelte -->

package/dist/admin/api/handler.js

@@ -6,6 +6,7 @@ import * as inviteHandlers from './invite.js';
 import * as acceptInviteHandlers from './accept-invite.js';
 import * as mediaGcHandlers from './media-gc.js';
 import * as generateStylesHandlers from './generate-styles.js';
+import * as regeneratePostersHandlers from './regenerate-posters.js';
 import * as uploadLimitHandlers from './upload-limit.js';
 import { requireAuth } from '../remote/middleware/auth.js';
 import { getCMS } from '../../core/cms.js';
@@ -19,6 +20,7 @@ export function createAdminApiHandler(options) {
         'accept-invite': acceptInviteHandlers,
         'media-gc': mediaGcHandlers,
         'generate-styles': generateStylesHandlers,
+        'regenerate-posters': regeneratePostersHandlers,
         'upload-limit': uploadLimitHandlers,
         ...options?.extraRoutes
     };

package/dist/admin/api/media-gc.js

@@ -2,12 +2,14 @@ import { requireRole } from '../remote/middleware/auth.js';
 import { purgeAllImageStyles } from '../../core/server/media/operations/purgeImageStyles.js';
 import { getReconciliationReport, deleteOrphanedDiskFiles } from '../../core/server/media/operations/reconcileMedia.js';
 import { getStylesStatus } from '../../core/server/media/styles/operations/batchGenerateStyles.js';
+import { getVideoPosterStatus } from '../../core/server/media/operations/batchRegenerateVideoPosters.js';
 import { json } from '@sveltejs/kit';
 export const GET = async ({ url }) => {
     requireRole('admin');
-    const [stylesStatus, report] = await Promise.all([
+    const [stylesStatus, report, videoPosterStatus] = await Promise.all([
         getStylesStatus(),
-        getReconciliationReport()
+        getReconciliationReport(),
+        getVideoPosterStatus()
     ]);
     return json({
         imageStylesCount: stylesStatus.existingStyles,
@@ -15,7 +17,10 @@ export const GET = async ({ url }) => {
         expectedStylesCount: stylesStatus.expectedStyles,
         missingStylesCount: stylesStatus.missingStyles,
         orphanedDiskFiles: report.orphanedDisk,
-        missingDiskRecords: report.missingDisk
+        missingDiskRecords: report.missingDisk,
+        videosCount: videoPosterStatus.videosCount,
+        videosWithPosters: videoPosterStatus.videosWithPosters,
+        videosMissingPosters: videoPosterStatus.videosMissingPosters
     });
 };
 export const DELETE = async ({ url }) => {

package/dist/admin/api/regenerate-posters.d.ts

@@ -0,0 +1,2 @@
+import type { RequestHandler } from '@sveltejs/kit';
+export declare const POST: RequestHandler;

package/dist/admin/api/regenerate-posters.js

@@ -0,0 +1,32 @@
+import { requireRole } from '../remote/middleware/auth.js';
+import { batchRegenerateVideoPosters } from '../../core/server/media/operations/batchRegenerateVideoPosters.js';
+export const POST = async () => {
+    requireRole('admin');
+    const abort = new AbortController();
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+        async start(controller) {
+            try {
+                for await (const event of batchRegenerateVideoPosters(abort.signal)) {
+                    controller.enqueue(encoder.encode(`data: ${JSON.stringify(event)}\n\n`));
+                }
+            }
+            catch (e) {
+                controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'error', error: e instanceof Error ? e.message : String(e) })}\n\n`));
+            }
+            finally {
+                controller.close();
+            }
+        },
+        cancel() {
+            abort.abort();
+        }
+    });
+    return new Response(stream, {
+        headers: {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            Connection: 'keep-alive'
+        }
+    });
+};

package/dist/admin/client/maintenance/maintenance-page.svelte

@@ -8,6 +8,7 @@
 	import PlayerPlay from '@tabler/icons-svelte/icons/player-play';
 	import PlayerStop from '@tabler/icons-svelte/icons/player-stop';
 	import CircleCheck from '@tabler/icons-svelte/icons/circle-check';
+	import Video from '@tabler/icons-svelte/icons/video';
 	import Button from '../../../components/ui/button/button.svelte';
 	import * as Card from '../../../components/ui/card/index.js';
 	import { toast } from 'svelte-sonner';
@@ -19,6 +20,9 @@
 		missingStylesCount: number;
 		orphanedDiskFiles: string[];
 		missingDiskRecords: { table: string; id: string; url: string }[];
+		videosCount: number;
+		videosWithPosters: number;
+		videosMissingPosters: number;
 	}
 
 	let report = $state<GcReport | null>(null);
@@ -38,6 +42,18 @@
 
 	let genPercent = $derived(genTotal > 0 ? Math.round((genProcessed / genTotal) * 100) : 0);
 
+	// Video poster generation state
+	let posterGenerating = $state(false);
+	let posterTotal = $state(0);
+	let posterProcessed = $state(0);
+	let posterCreated = $state(0);
+	let posterSkipped = $state(0);
+	let posterCurrentFile = $state('');
+	let posterErrors = $state(0);
+	let posterAbort: AbortController | null = null;
+
+	let posterPercent = $derived(posterTotal > 0 ? Math.round((posterProcessed / posterTotal) * 100) : 0);
+
 	async function loadReport() {
 		loading = true;
 		try {
@@ -152,6 +168,77 @@
 		genAbort?.abort();
 	}
 
+	async function startPosterGenerate() {
+		posterGenerating = true;
+		posterTotal = 0;
+		posterProcessed = 0;
+		posterCreated = 0;
+		posterSkipped = 0;
+		posterCurrentFile = '';
+		posterErrors = 0;
+		posterAbort = new AbortController();
+
+		try {
+			const res = await fetch('/admin/api/regenerate-posters', {
+				method: 'POST',
+				signal: posterAbort.signal
+			});
+
+			if (!res.ok) throw new Error('Failed to start');
+			if (!res.body) throw new Error('No response body');
+
+			const reader = res.body.getReader();
+			const decoder = new TextDecoder();
+			let buffer = '';
+
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) break;
+
+				buffer += decoder.decode(value, { stream: true });
+				const chunks = buffer.split('\n\n');
+				buffer = chunks.pop() || '';
+
+				for (const chunk of chunks) {
+					if (!chunk.startsWith('data: ')) continue;
+					const event = JSON.parse(chunk.slice(6));
+
+					posterTotal = event.total ?? posterTotal;
+					posterProcessed = event.processed ?? posterProcessed;
+					posterCreated = event.created ?? posterCreated;
+					posterSkipped = event.skipped ?? posterSkipped;
+					posterCurrentFile = event.currentFile ?? posterCurrentFile;
+
+					if (event.type === 'error') {
+						posterErrors++;
+					}
+
+					if (event.type === 'done') {
+						const parts = [`Przetworzono ${posterTotal} filmów`];
+						if (posterCreated > 0) parts.push(`utworzono ${posterCreated} posterów`);
+						if (posterSkipped > 0) parts.push(`pominięto ${posterSkipped} (już istnieją)`);
+						if (posterErrors > 0) parts.push(`${posterErrors} błędów`);
+						toast.success(parts.join(', '));
+					}
+				}
+			}
+		} catch (e) {
+			if (e instanceof DOMException && e.name === 'AbortError') {
+				toast.info(`Przerwano po ${posterProcessed}/${posterTotal} filmów`);
+			} else {
+				toast.error('Błąd podczas generowania posterów');
+			}
+		} finally {
+			posterGenerating = false;
+			posterAbort = null;
+			await loadReport();
+		}
+	}
+
+	function cancelPosterGenerate() {
+		posterAbort?.abort();
+	}
+
 	$effect(() => {
 		loadReport();
 	});
@@ -260,6 +347,72 @@
 				</Card.Content>
 			</Card.Root>
 
+			<!-- Video posters -->
+			<Card.Root>
+				<Card.Header>
+					<div class="flex items-center gap-2">
+						<Video class="size-5" style="color: var(--primary);" />
+						<Card.Title>Postery video</Card.Title>
+					</div>
+					<Card.Description>
+						Miniaturki i postery generowane z plików wideo (ffmpeg)
+					</Card.Description>
+				</Card.Header>
+				<Card.Content>
+					<p class="mb-1 text-3xl font-bold" style="color: var(--primary);">
+						{report.videosWithPosters}
+						<span class="text-base font-normal" style="color: var(--muted-foreground);">/ {report.videosCount}</span>
+					</p>
+					<p class="mb-4 text-xs" style="color: var(--muted-foreground);">
+						{report.videosCount} filmów, {report.videosMissingPosters} bez posterów
+					</p>
+
+					{#if posterGenerating}
+						<div class="mb-4">
+							<div class="mb-1 flex items-center justify-between text-xs" style="color: var(--muted-foreground);">
+								<span>{posterProcessed}/{posterTotal} filmów</span>
+								<span>{posterPercent}%</span>
+							</div>
+							<div class="h-2 w-full overflow-hidden rounded-full" style="background: var(--muted, #e5e7eb);">
+								<div
+									class="h-full rounded-full transition-all duration-300"
+									style="width: {posterPercent}%; background: var(--primary);"
+								></div>
+							</div>
+							<p class="mt-1 text-xs" style="color: var(--muted-foreground);">
+								Utworzono: {posterCreated}, pominięto: {posterSkipped}{posterErrors > 0 ? `, błędów: ${posterErrors}` : ''}
+							</p>
+							<p class="mt-0.5 truncate text-xs" style="color: var(--muted-foreground);">
+								{posterCurrentFile}
+							</p>
+							<Button
+								variant="outline"
+								size="sm"
+								onclick={cancelPosterGenerate}
+								class="mt-2"
+							>
+								<PlayerStop class="size-4" />
+								Anuluj
+							</Button>
+						</div>
+					{:else if report.videosCount > 0}
+						<Button
+							variant="default"
+							size="sm"
+							onclick={startPosterGenerate}
+						>
+							<PlayerPlay class="size-4" />
+							Generuj brakujące postery
+						</Button>
+					{:else}
+						<div class="mb-3 flex items-center gap-1.5 text-sm" style="color: var(--success, #3A8A5C);">
+							<CircleCheck class="size-4" />
+							Brak plików wideo
+						</div>
+					{/if}
+				</Card.Content>
+			</Card.Root>
+
 			<!-- Orphaned disk files -->
 			<Card.Root>
 				<Card.Header>

package/dist/core/server/media/operations/batchRegenerateVideoPosters.d.ts

@@ -0,0 +1,15 @@
+export type PosterBatchProgress = {
+    type: 'progress' | 'error' | 'done';
+    total: number;
+    processed: number;
+    created: number;
+    skipped: number;
+    currentFile?: string;
+    error?: string;
+};
+export declare function batchRegenerateVideoPosters(signal?: AbortSignal): AsyncGenerator<PosterBatchProgress>;
+export declare function getVideoPosterStatus(): Promise<{
+    videosCount: number;
+    videosWithPosters: number;
+    videosMissingPosters: number;
+}>;

package/dist/core/server/media/operations/batchRegenerateVideoPosters.js

@@ -0,0 +1,112 @@
+import { getCMS } from '../../../cms.js';
+import { processVideo } from '../../../../files-local/video.js';
+import { fullDir } from '../../../../files-local/index.js';
+import { resolve } from 'node:path';
+import { unlink } from 'node:fs/promises';
+const VIDEO_MIME_TYPES = [
+    'video/mp4',
+    'video/quicktime',
+    'video/webm',
+    'video/x-msvideo',
+    'video/x-matroska'
+];
+export async function* batchRegenerateVideoPosters(signal) {
+    const cms = getCMS();
+    const allFiles = await cms.databaseAdapter.getMediaFiles({
+        data: { mimeTypes: VIDEO_MIME_TYPES }
+    });
+    const total = allFiles.length;
+    let totalCreated = 0;
+    let totalSkipped = 0;
+    for (let i = 0; i < allFiles.length; i++) {
+        if (signal?.aborted)
+            return;
+        const file = allFiles[i];
+        yield {
+            type: 'progress',
+            total,
+            processed: i,
+            created: totalCreated,
+            skipped: totalSkipped,
+            currentFile: file.name
+        };
+        // Check if poster and thumbnail already exist on disk
+        const posterFilename = file.posterUrl?.split('/').pop();
+        const thumbFilename = file.thumbnailUrl?.split('/').pop();
+        const hasPoster = posterFilename ? await fileExists(resolve(fullDir, posterFilename)) : false;
+        const hasThumb = thumbFilename ? await fileExists(resolve(fullDir, thumbFilename)) : false;
+        if (hasPoster && hasThumb) {
+            totalSkipped++;
+            continue;
+        }
+        try {
+            // Get video filepath
+            const videoFilename = file.url.split('/').pop();
+            if (!videoFilename) {
+                throw new Error('No video filename');
+            }
+            const videoPath = resolve(fullDir, videoFilename);
+            // Delete old poster/thumb if they exist
+            if (posterFilename) {
+                try {
+                    await unlink(resolve(fullDir, posterFilename));
+                }
+                catch { /* ok */ }
+            }
+            if (thumbFilename) {
+                try {
+                    await unlink(resolve(fullDir, thumbFilename));
+                }
+                catch { /* ok */ }
+            }
+            // Regenerate
+            const meta = await processVideo(videoPath, file.name, fullDir);
+            // Update DB
+            await cms.databaseAdapter.updateMediaFile({
+                id: file.id,
+                data: {
+                    posterUrl: meta.posterUrl,
+                    thumbnailUrl: meta.thumbnailUrl,
+                    ...(meta.width != null && { width: meta.width }),
+                    ...(meta.height != null && { height: meta.height }),
+                    ...(meta.duration != null && { duration: meta.duration })
+                }
+            });
+            totalCreated++;
+        }
+        catch (e) {
+            yield {
+                type: 'error',
+                total,
+                processed: i + 1,
+                created: totalCreated,
+                skipped: totalSkipped,
+                currentFile: file.name,
+                error: e instanceof Error ? e.message : String(e)
+            };
+            continue;
+        }
+    }
+    yield { type: 'done', total, processed: total, created: totalCreated, skipped: totalSkipped };
+}
+async function fileExists(path) {
+    try {
+        const { stat } = await import('node:fs/promises');
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function getVideoPosterStatus() {
+    const allFiles = await getCMS().databaseAdapter.getMediaFiles({
+        data: { mimeTypes: VIDEO_MIME_TYPES }
+    });
+    const videosWithPosters = allFiles.filter((f) => f.posterUrl != null).length;
+    return {
+        videosCount: allFiles.length,
+        videosWithPosters,
+        videosMissingPosters: allFiles.length - videosWithPosters
+    };
+}

package/dist/files-local/index.d.ts

@@ -1,2 +1,3 @@
 import type { FilesAdapter } from '../types/adapters/files.js';
+export declare const fullDir: string;
 export declare function local(): FilesAdapter;

package/dist/files-local/index.js

@@ -2,152 +2,15 @@ import { basename, extname, resolve } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { readFile, writeFile, rename, unlink, mkdir, readdir } from 'node:fs/promises';
 import sharp from 'sharp';
-import ffmpeg from 'fluent-ffmpeg';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
 import { sanitizeFilename } from './sanitizeFilename.js';
+import { processVideo } from './video.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 global.__dirname = __dirname ?? '';
-const fullDir = process.env.NODE_ENV === 'production' ? `/data/uploads` : `./static/uploads`;
+export const fullDir = process.env.NODE_ENV === 'production' ? `/data/uploads` : `./static/uploads`;
 const privateDir = process.env.NODE_ENV === 'production' ? `/data/private-uploads` : `./data/private-uploads`;
-// Ustawienie ścieżek do ffmpeg
-const ffmpegPath = process.env.FFMPEG_PATH || '/usr/bin/ffmpeg';
-const ffprobePath = process.env.FFPROBE_PATH || '/usr/bin/ffprobe';
-ffmpeg.setFfmpegPath(ffmpegPath);
-ffmpeg.setFfprobePath(ffprobePath);
-function withTimeout(promise, ms, label) {
-    return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
-        promise.then((val) => {
-            clearTimeout(timer);
-            resolve(val);
-        }, (err) => {
-            clearTimeout(timer);
-            reject(err);
-        });
-    });
-}
-function probeVideo(filepath) {
-    return new Promise((resolve, reject) => {
-        ffmpeg.ffprobe(filepath, (err, metadata) => {
-            if (err) {
-                reject(new Error(`ffprobe failed: ${err.message || err}`));
-                return;
-            }
-            const videoStream = metadata.streams.find((s) => s.codec_type === 'video');
-            const duration = metadata.format.duration ?? null;
-            resolve({
-                width: videoStream?.width ?? null,
-                height: videoStream?.height ?? null,
-                duration: duration ? Math.round(duration * 100) / 100 : null
-            });
-        });
-    });
-}
-function takeScreenshot(filepath, config) {
-    return new Promise((resolve, reject) => {
-        ffmpeg(filepath)
-            .on('error', (err) => reject(new Error(`Screenshot failed: ${err.message || err}`)))
-            .on('end', () => resolve())
-            .screenshots({
-            timestamps: [config.timestamp],
-            filename: config.filename,
-            folder: config.folder,
-            size: config.size
-        });
-    });
-}
-function getSafeTimestamp(duration) {
-    if (duration === null || duration <= 0)
-        return '00:00:00.000';
-    if (duration < 1)
-        return '00:00:00.000';
-    if (duration < 3) {
-        const t = duration * 0.1;
-        return formatTimestamp(t);
-    }
-    return formatTimestamp(Math.min(1, duration * 0.1));
-}
-function formatTimestamp(seconds) {
-    const h = Math.floor(seconds / 3600);
-    const m = Math.floor((seconds % 3600) / 60);
-    const s = seconds % 60;
-    return `${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}:${s.toFixed(3).padStart(6, '0')}`;
-}
-let ffmpegAvailable = null;
-async function checkFfmpegAvailable() {
-    if (ffmpegAvailable !== null)
-        return ffmpegAvailable;
-    return new Promise((resolve) => {
-        ffmpeg.ffprobe('/dev/null', (err) => {
-            if (err && (String(err).includes('ENOENT') || String(err).includes('spawn'))) {
-                console.warn('[video] ffmpeg/ffprobe not found — video thumbnails disabled');
-                ffmpegAvailable = false;
-            }
-            else {
-                ffmpegAvailable = true;
-            }
-            resolve(ffmpegAvailable);
-        });
-    });
-}
-async function processVideo(filepath, filename) {
-    if (!(await checkFfmpegAvailable())) {
-        console.warn(`[video] Skipping processing for ${filename}: ffmpeg not available`);
-        return { width: null, height: null, duration: null, thumbnailUrl: null, posterUrl: null };
-    }
-    const thumbnailFilename = `${filename}_thumb.jpg`;
-    const thumbnailUrl = `/uploads/${thumbnailFilename}`;
-    const posterFilename = `${filename}_poster.jpg`;
-    const posterUrl = `/uploads/${posterFilename}`;
-    // 1. Probe — get metadata first
-    let probe;
-    try {
-        probe = await withTimeout(probeVideo(filepath), 10_000, 'ffprobe');
-    }
-    catch (err) {
-        console.warn(`[video] ffprobe failed for ${filename}:`, err);
-        return { width: null, height: null, duration: null, thumbnailUrl: null, posterUrl: null };
-    }
-    const timestamp = getSafeTimestamp(probe.duration);
-    // 2. Thumbnail (320px wide, maintain aspect ratio)
-    let finalThumbnailUrl = null;
-    try {
-        await withTimeout(takeScreenshot(filepath, {
-            timestamp,
-            filename: thumbnailFilename,
-            folder: fullDir,
-            size: '320x?'
-        }), 15_000, 'thumbnail');
-        finalThumbnailUrl = thumbnailUrl;
-    }
-    catch (err) {
-        console.warn(`[video] Thumbnail failed for ${filename}:`, err);
-    }
-    // 3. Poster (up to 1280px wide, no upscale)
-    let finalPosterUrl = null;
-    const posterWidth = Math.min(1280, probe.width ?? 1280);
-    try {
-        await withTimeout(takeScreenshot(filepath, {
-            timestamp,
-            filename: posterFilename,
-            folder: fullDir,
-            size: `${posterWidth}x?`
-        }), 15_000, 'poster');
-        finalPosterUrl = posterUrl;
-    }
-    catch (err) {
-        console.warn(`[video] Poster failed for ${filename}:`, err);
-    }
-    return {
-        width: probe.width,
-        height: probe.height,
-        duration: probe.duration ? Math.round(probe.duration) : null,
-        thumbnailUrl: finalThumbnailUrl,
-        posterUrl: finalPosterUrl
-    };
-}
 async function ensureDir(dir) {
     try {
         await mkdir(dir, { recursive: true });
@@ -228,7 +91,7 @@ export function local() {
             else if (file.type.startsWith('video/')) {
                 type = 'video';
                 try {
-                    const videoMeta = await processVideo(filepath, filename);
+                    const videoMeta = await processVideo(filepath, filename, fullDir);
                     width = videoMeta.width;
                     height = videoMeta.height;
                     duration = videoMeta.duration;

package/dist/files-local/sanitizeFilename.js

@@ -3,7 +3,8 @@
  * Prevents path traversal, null byte injection, and other attacks.
  */
 export function sanitizeFilename(name) {
-    let sanitized = name;
+    // Normalize Unicode to NFC (composed form) to prevent NFD/NFC mismatch
+    let sanitized = name.normalize('NFC');
     // Remove null bytes
     sanitized = sanitized.replace(/\0/g, '');
     // Remove path separators and traversal patterns

package/dist/files-local/video.d.ts

@@ -0,0 +1,9 @@
+export interface VideoMetadata {
+    width: number | null;
+    height: number | null;
+    duration: number | null;
+    thumbnailUrl: string | null;
+    posterUrl: string | null;
+}
+export declare function checkFfmpegAvailable(): Promise<boolean>;
+export declare function processVideo(filepath: string, filename: string, outputDir: string): Promise<VideoMetadata>;

package/dist/files-local/video.js

@@ -0,0 +1,145 @@
+import ffmpeg from 'fluent-ffmpeg';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+if (typeof globalThis.__dirname === 'undefined') {
+    globalThis.__dirname = __dirname ?? '';
+}
+// Ustawienie ścieżek do ffmpeg
+const ffmpegPath = process.env.FFMPEG_PATH || '/usr/bin/ffmpeg';
+const ffprobePath = process.env.FFPROBE_PATH || '/usr/bin/ffprobe';
+ffmpeg.setFfmpegPath(ffmpegPath);
+ffmpeg.setFfprobePath(ffprobePath);
+function withTimeout(promise, ms, label) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
+        promise.then((val) => {
+            clearTimeout(timer);
+            resolve(val);
+        }, (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+    });
+}
+function probeVideo(filepath) {
+    return new Promise((resolve, reject) => {
+        ffmpeg.ffprobe(filepath, (err, metadata) => {
+            if (err) {
+                reject(new Error(`ffprobe failed: ${err.message || err}`));
+                return;
+            }
+            const videoStream = metadata.streams.find((s) => s.codec_type === 'video');
+            const duration = metadata.format.duration ?? null;
+            resolve({
+                width: videoStream?.width ?? null,
+                height: videoStream?.height ?? null,
+                duration: duration ? Math.round(duration * 100) / 100 : null
+            });
+        });
+    });
+}
+function takeScreenshot(filepath, config) {
+    return new Promise((resolve, reject) => {
+        ffmpeg(filepath)
+            .on('error', (err) => reject(new Error(`Screenshot failed: ${err.message || err}`)))
+            .on('end', () => resolve())
+            .screenshots({
+            timestamps: [config.timestamp],
+            filename: config.filename,
+            folder: config.folder,
+            size: config.size
+        });
+    });
+}
+function getSafeTimestamp(duration) {
+    if (duration === null || duration <= 0)
+        return '00:00:00.000';
+    if (duration < 1)
+        return '00:00:00.000';
+    if (duration < 3) {
+        const t = duration * 0.1;
+        return formatTimestamp(t);
+    }
+    return formatTimestamp(Math.min(1, duration * 0.1));
+}
+function formatTimestamp(seconds) {
+    const h = Math.floor(seconds / 3600);
+    const m = Math.floor((seconds % 3600) / 60);
+    const s = seconds % 60;
+    return `${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}:${s.toFixed(3).padStart(6, '0')}`;
+}
+let ffmpegAvailable = null;
+export async function checkFfmpegAvailable() {
+    if (ffmpegAvailable !== null)
+        return ffmpegAvailable;
+    return new Promise((resolve) => {
+        ffmpeg.ffprobe('/dev/null', (err) => {
+            if (err && (String(err).includes('ENOENT') || String(err).includes('spawn'))) {
+                console.warn('[video] ffmpeg/ffprobe not found — video thumbnails disabled');
+                ffmpegAvailable = false;
+            }
+            else {
+                ffmpegAvailable = true;
+            }
+            resolve(ffmpegAvailable);
+        });
+    });
+}
+export async function processVideo(filepath, filename, outputDir) {
+    if (!(await checkFfmpegAvailable())) {
+        console.warn(`[video] Skipping processing for ${filename}: ffmpeg not available`);
+        return { width: null, height: null, duration: null, thumbnailUrl: null, posterUrl: null };
+    }
+    const thumbnailFilename = `${filename}_thumb.jpg`;
+    const thumbnailUrl = `/uploads/${thumbnailFilename}`;
+    const posterFilename = `${filename}_poster.jpg`;
+    const posterUrl = `/uploads/${posterFilename}`;
+    // 1. Probe — get metadata first
+    let probe;
+    try {
+        probe = await withTimeout(probeVideo(filepath), 10_000, 'ffprobe');
+    }
+    catch (err) {
+        console.warn(`[video] ffprobe failed for ${filename}:`, err);
+        return { width: null, height: null, duration: null, thumbnailUrl: null, posterUrl: null };
+    }
+    const timestamp = getSafeTimestamp(probe.duration);
+    // 2. Thumbnail (320px wide, maintain aspect ratio)
+    let finalThumbnailUrl = null;
+    try {
+        await withTimeout(takeScreenshot(filepath, {
+            timestamp,
+            filename: thumbnailFilename,
+            folder: outputDir,
+            size: '320x?'
+        }), 15_000, 'thumbnail');
+        finalThumbnailUrl = thumbnailUrl;
+    }
+    catch (err) {
+        console.warn(`[video] Thumbnail failed for ${filename}:`, err);
+    }
+    // 3. Poster (up to 1280px wide, no upscale)
+    let finalPosterUrl = null;
+    const posterWidth = Math.min(1280, probe.width ?? 1280);
+    try {
+        await withTimeout(takeScreenshot(filepath, {
+            timestamp,
+            filename: posterFilename,
+            folder: outputDir,
+            size: `${posterWidth}x?`
+        }), 15_000, 'poster');
+        finalPosterUrl = posterUrl;
+    }
+    catch (err) {
+        console.warn(`[video] Poster failed for ${filename}:`, err);
+    }
+    return {
+        width: probe.width,
+        height: probe.height,
+        duration: probe.duration ? Math.round(probe.duration) : null,
+        thumbnailUrl: finalThumbnailUrl,
+        posterUrl: finalPosterUrl
+    };
+}

package/dist/updates/0.13.4/index.d.ts

@@ -0,0 +1,2 @@
+import type { CmsUpdate } from '../index.js';
+export declare const update: CmsUpdate;

package/dist/updates/0.13.4/index.js

@@ -0,0 +1,14 @@
+export const update = {
+    version: '0.13.4',
+    date: '2026-03-24',
+    description: 'Video poster regeneration, filename sanitization',
+    features: [
+        'Batch regenerate video posters & thumbnails from admin maintenance page with SSE progress',
+        'Video poster status reporting in media GC endpoint',
+        'Extracted video processing to reusable module'
+    ],
+    fixes: [
+        'Filename sanitization normalizes Unicode to NFC (prevents NFD/NFC mismatch)'
+    ],
+    breakingChanges: []
+};

package/dist/updates/index.js

@@ -36,7 +36,8 @@ import { update as update0130 } from './0.13.0/index.js';
 import { update as update0131 } from './0.13.1/index.js';
 import { update as update0132 } from './0.13.2/index.js';
 import { update as update0133 } from './0.13.3/index.js';
-export const updates = [update0065, update0066, update0067, update0068, update0069, update010, update011, update012, update013, update014, update015, update020, update022, update050, update051, update052, update053, update054, update055, update056, update057, update058, update060, update061, update062, update070, update071, update072, update073, update080, update090, update0100, update0110, update0120, update0130, update0131, update0132, update0133];
+import { update as update0134 } from './0.13.4/index.js';
+export const updates = [update0065, update0066, update0067, update0068, update0069, update010, update011, update012, update013, update014, update015, update020, update022, update050, update051, update052, update053, update054, update055, update056, update057, update058, update060, update061, update062, update070, update071, update072, update073, update080, update090, update0100, update0110, update0120, update0130, update0131, update0132, update0133, update0134];
 export const getUpdatesFrom = (fromVersion) => {
     const fromParts = fromVersion.split('.').map(Number);
     return updates.filter((update) => {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "includio-cms",
-	"version": "0.13.3",
+	"version": "0.13.4",
 	"scripts": {
 		"dev": "vite dev",
 		"build": "vite build && npm run prepack",