libre-webui 0.21.2 → 0.22.0

package/backend/dist/services/galleryService.js

@@ -1,290 +1,395 @@
 /*
  * Libre WebUI
  * Copyright (C) 2025 Kroonen AI, Inc.
- *
  * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at:
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
  */
+import { Readable } from 'node:stream';
 import { v4 as uuidv4 } from 'uuid';
-import { getDatabaseSafe } from '../db.js';
-import { encryptionService } from './encryptionService.js';
+import { getPlatformStorageRuntime } from '../platform/storage/index.js';
+import { transactionalResourceDeletionEnqueuer } from '../platform/jobs/resourceDeletionEnqueuer.js';
+import { getDurableJobRuntime } from '../platform/jobs/durableJobRuntime.js';
+import { VIDEO_RESUME_IDEMPOTENCY_SCOPE, VIDEO_SUBMIT_IDEMPOTENCY_SCOPE, } from '../platform/jobs/domainJobContracts.js';
+import { getCoordinator } from '../platform/coordination/service.js';
 import { createLogger } from '../utils/logger.js';
 const logger = createLogger('services:gallery-service');
-class GalleryService {
-    /**
-     * Save a generated image to the gallery
-     */
-    saveImage(userId, params) {
-        const db = getDatabaseSafe();
-        if (!db) {
-            logger.error('Database not available for saving image');
-            return null;
-        }
-        try {
-            const id = uuidv4();
-            const createdAt = Date.now();
-            // Encrypt the image data and prompt before storing
-            const encryptedImageData = encryptionService.encrypt(params.imageData);
-            const encryptedPrompt = encryptionService.encrypt(params.prompt);
-            db.prepare(`
-        INSERT INTO generated_images
-          (id, user_id, kind, prompt, model, image_data, mime_type, size, quality, created_at)
-        VALUES (?, ?, 'image', ?, ?, ?, ?, ?, ?, ?)
-        `).run(id, userId, encryptedPrompt, params.model, encryptedImageData, inferImageMimeType(params.imageData), params.size || null, params.quality || null, createdAt);
-            return {
-                id,
-                userId,
-                prompt: params.prompt,
-                model: params.model,
-                imageData: params.imageData,
-                size: params.size,
-                quality: params.quality,
-                createdAt,
-            };
-        }
-        catch (error) {
-            logger.error('Error saving image to gallery:', error);
-            return null;
-        }
+const RESOURCE_TYPE = 'generated-media';
+const BLOB_PURPOSE = 'gallery.media';
+const LEGACY_MAX_BYTES = 200 * 1024 * 1024;
+const parseDataUrl = (mediaData, expectedMimeType) => {
+    const match = /^data:([a-z0-9.+-]+\/[a-z0-9.+-]+);base64,([a-z0-9+/]+={0,2})$/i.exec(mediaData);
+    if (!match) {
+        // Remote provider URLs were historically persisted and redirected to.
+        // New writes reject them: provider content must be downloaded first so
+        // retention, checksums, deletion, and access policy stay under Libre.
+        throw new Error('Generated media must be a base64 data URL');
     }
-    saveMedia(userId, params) {
-        const db = getDatabaseSafe();
-        if (!db)
-            return null;
-        try {
-            const id = uuidv4();
-            const createdAt = Date.now();
-            db.prepare(`INSERT INTO generated_images
-           (id, user_id, kind, prompt, model, plugin_id, image_data,
-            mime_type, size, quality, metadata, created_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, userId, params.kind, encryptionService.encrypt(params.prompt), params.model, params.pluginId || null, encryptionService.encrypt(params.mediaData), params.mimeType, params.size || null, params.quality || null, params.metadata ? JSON.stringify(params.metadata) : null, createdAt);
-            return { id, userId, createdAt, ...params };
+    const mimeType = match[1].toLowerCase();
+    if (expectedMimeType && mimeType !== expectedMimeType.toLowerCase()) {
+        throw new Error('Generated media MIME type does not match its data URL');
+    }
+    const bytes = Buffer.from(match[2], 'base64');
+    if (bytes.length > LEGACY_MAX_BYTES)
+        throw new Error('Generated media is too large');
+    if (bytes.toString('base64') !== match[2]) {
+        throw new Error('Generated media base64 is not canonical');
+    }
+    return { mimeType, bytes };
+};
+class GalleryService {
+    async cancelVideoLifecycle(mediaId, userId) {
+        const service = getDurableJobRuntime().service;
+        const runningIds = [];
+        for (const scope of [
+            VIDEO_SUBMIT_IDEMPOTENCY_SCOPE,
+            VIDEO_RESUME_IDEMPOTENCY_SCOPE,
+        ]) {
+            const job = await service.getByIdempotency(userId, scope, mediaId);
+            if (job?.state !== 'queued' && job?.state !== 'running')
+                continue;
+            const cancelled = await service.cancel(job.id, userId, 'superseded');
+            if (cancelled.state === 'running')
+                runningIds.push(cancelled.id);
         }
-        catch (error) {
-            logger.error('Error saving generated media:', error);
-            return null;
+        const deadline = Date.now() + 15000;
+        while (runningIds.length > 0) {
+            for (let index = runningIds.length - 1; index >= 0; index -= 1) {
+                const job = await service.getMetadata(runningIds[index]);
+                if (!job || job.state !== 'running')
+                    runningIds.splice(index, 1);
+            }
+            if (runningIds.length === 0)
+                return;
+            if (Date.now() >= deadline) {
+                throw new Error('Generated media work is still stopping; retry deletion');
+            }
+            await new Promise(resolve => setTimeout(resolve, 50));
         }
     }
-    /**
-     * Get user's images with pagination
-     */
-    getImages(userId, params = {}) {
-        const db = getDatabaseSafe();
-        if (!db) {
-            return { images: [], total: 0 };
+    async withMediaWriteLease(mediaId, userId, operation) {
+        const coordinator = getCoordinator();
+        const deadline = Date.now() + 15000;
+        let lease = await coordinator.acquireLease(`resource:${userId}:${RESOURCE_TYPE}:${mediaId}`, 30000);
+        while (!lease && Date.now() < deadline) {
+            await new Promise(resolve => setTimeout(resolve, 25));
+            lease = await coordinator.acquireLease(`resource:${userId}:${RESOURCE_TYPE}:${mediaId}`, 30000);
         }
+        if (!lease)
+            throw new Error('Generated media is still being updated');
+        let closed = false;
+        let lost = false;
+        let renewalTimer;
+        const assertHeld = async () => {
+            if (closed || lost) {
+                throw new Error('The shared generated media write lease was lost');
+            }
+            try {
+                if (await lease.extend(30000))
+                    return;
+            }
+            catch {
+                // Report expiry and coordination outages through one safe fence.
+            }
+            lost = true;
+            throw new Error('The shared generated media write lease was lost');
+        };
+        const renew = async () => {
+            if (closed || lost)
+                return;
+            try {
+                if (!(await lease.extend(30000)))
+                    lost = true;
+            }
+            catch {
+                lost = true;
+            }
+            if (!closed && !lost)
+                renewalTimer = setTimeout(renew, 10000);
+        };
+        renewalTimer = setTimeout(renew, 10000);
+        renewalTimer.unref?.();
         try {
-            const limit = params.limit || 20;
-            const offset = params.offset || 0;
-            // Get total count
-            const countResult = db
-                .prepare(`SELECT COUNT(*) as total FROM generated_images
-           WHERE user_id = ? AND kind = 'image'`)
-                .get(userId);
-            // Get paginated images
-            const rows = db
-                .prepare(`
-          SELECT id, user_id, prompt, model, image_data, size, quality, created_at
-          FROM generated_images
-          WHERE user_id = ? AND kind = 'image'
-          ORDER BY created_at DESC
-          LIMIT ? OFFSET ?
-          `)
-                .all(userId, limit, offset);
-            const images = rows.map(row => ({
-                id: row.id,
-                userId: row.user_id,
-                prompt: encryptionService.decrypt(row.prompt),
-                model: row.model,
-                imageData: encryptionService.decrypt(row.image_data),
-                size: row.size || undefined,
-                quality: row.quality || undefined,
-                createdAt: row.created_at,
-            }));
-            return {
-                images,
-                total: countResult.total,
-            };
+            await assertHeld();
+            const result = await operation(assertHeld);
+            return result;
         }
-        catch (error) {
-            logger.error('Error getting images from gallery:', error);
-            return { images: [], total: 0 };
+        finally {
+            closed = true;
+            if (renewalTimer)
+                clearTimeout(renewalTimer);
+            await lease.release().catch(() => false);
         }
     }
-    getMedia(userId, params = {}) {
-        const db = getDatabaseSafe();
-        if (!db)
-            return { media: [], total: 0 };
-        try {
-            const limit = params.limit || 20;
-            const offset = params.offset || 0;
-            const where = params.kind
-                ? 'WHERE user_id = ? AND kind = ?'
-                : 'WHERE user_id = ?';
-            const bindings = params.kind ? [userId, params.kind] : [userId];
-            const count = db
-                .prepare(`SELECT COUNT(*) as total FROM generated_images ${where}`)
-                .get(...bindings);
-            const rows = db
-                .prepare(`SELECT id, user_id, kind, prompt, model, plugin_id, image_data,
-                  mime_type, size, quality, metadata, created_at
-           FROM generated_images
-           ${where}
-           ORDER BY created_at DESC
-           LIMIT ? OFFSET ?`)
-                .all(...bindings, limit, offset);
-            return {
-                media: rows.map(toGeneratedMedia),
-                total: count.total,
-            };
-        }
-        catch (error) {
-            logger.error('Error getting generated media:', error);
-            return { media: [], total: 0 };
-        }
+    async getRecord(mediaId, userId) {
+        return getPlatformStorageRuntime().domains.gallery.findByOwner(mediaId, userId);
     }
-    getMediaItem(mediaId, userId) {
-        const db = getDatabaseSafe();
-        if (!db)
-            return null;
+    async migrateLegacyBlob(record) {
+        if (!record.legacyMediaData)
+            return undefined;
+        const platform = getPlatformStorageRuntime();
+        const existing = await platform.blobReferences.find(RESOURCE_TYPE, record.id, BLOB_PURPOSE);
+        if (existing)
+            return existing.blobId;
+        const parsed = parseDataUrl(record.legacyMediaData, record.mimeType);
+        const blob = await platform.blobStore.put({
+            ownerUserId: record.userId,
+            purpose: BLOB_PURPOSE,
+            contentType: record.mimeType,
+            expectedSize: parsed.bytes.length,
+            metadata: { resourceType: RESOURCE_TYPE, resourceId: record.id },
+            source: Readable.from(parsed.bytes),
+        });
         try {
-            const row = db
-                .prepare(`SELECT id, user_id, kind, prompt, model, plugin_id, image_data,
-                  mime_type, size, quality, metadata, created_at
-           FROM generated_images
-           WHERE id = ? AND user_id = ?`)
-                .get(mediaId, userId);
-            return row ? toGeneratedMedia(row) : null;
+            await platform.domains.gallery.adoptLegacyBlob({
+                blobId: blob.id,
+                ownerUserId: record.userId,
+                resourceType: RESOURCE_TYPE,
+                resourceId: record.id,
+                purpose: BLOB_PURPOSE,
+                createdAt: Date.now(),
+            });
+            const authoritative = await platform.blobReferences.find(RESOURCE_TYPE, record.id, BLOB_PURPOSE);
+            if (!authoritative) {
+                throw new Error('Legacy gallery migration did not publish a blob reference');
+            }
+            if (authoritative.blobId !== blob.id) {
+                await platform.blobStore
+                    .delete({ id: blob.id, ownerUserId: record.userId })
+                    .catch(error => {
+                    logger.warn('Concurrent gallery migration left an orphan for reconciliation', error);
+                    return false;
+                });
+            }
+            return authoritative.blobId;
         }
         catch (error) {
-            logger.error('Error getting generated media item:', error);
-            return null;
+            await platform.blobStore
+                .delete({ id: blob.id, ownerUserId: record.userId })
+                .catch(() => undefined);
+            throw error;
         }
     }
-    /**
-     * Get a single image by ID
-     */
-    getImage(imageId, userId) {
-        const db = getDatabaseSafe();
-        if (!db) {
-            return null;
-        }
+    async saveImage(userId, params) {
+        const saved = await this.saveMedia(userId, {
+            kind: 'image',
+            prompt: params.prompt,
+            model: params.model,
+            mediaData: params.imageData,
+            mimeType: inferImageMimeType(params.imageData),
+            ...(params.size ? { size: params.size } : {}),
+            ...(params.quality ? { quality: params.quality } : {}),
+        });
+        return saved
+            ? {
+                id: saved.id,
+                userId: saved.userId,
+                prompt: saved.prompt,
+                model: saved.model,
+                imageData: params.imageData,
+                ...(saved.size ? { size: saved.size } : {}),
+                ...(saved.quality ? { quality: saved.quality } : {}),
+                createdAt: saved.createdAt,
+            }
+            : null;
+    }
+    async saveMedia(userId, params) {
+        let blobId;
         try {
-            const row = db
-                .prepare(`
-          SELECT id, user_id, prompt, model, image_data, size, quality, created_at
-          FROM generated_images
-          WHERE id = ? AND user_id = ? AND kind = 'image'
-          `)
-                .get(imageId, userId);
-            if (!row) {
-                return null;
+            const { id: requestedId, createdAt: requestedCreatedAt, ...mediaParams } = params;
+            const id = requestedId ?? uuidv4();
+            const createdAt = requestedCreatedAt ?? Date.now();
+            if (requestedId) {
+                const existing = await this.getRecord(requestedId, userId);
+                if (existing) {
+                    return { ...existing, mediaData: mediaParams.mediaData };
+                }
+            }
+            const parsed = parseDataUrl(mediaParams.mediaData, mediaParams.mimeType);
+            const platform = getPlatformStorageRuntime();
+            const blob = await platform.blobStore.put({
+                ownerUserId: userId,
+                purpose: BLOB_PURPOSE,
+                contentType: mediaParams.mimeType,
+                expectedSize: parsed.bytes.length,
+                metadata: { resourceType: RESOURCE_TYPE, resourceId: id },
+                source: Readable.from(parsed.bytes),
+            });
+            blobId = blob.id;
+            try {
+                await platform.domains.gallery.insert({
+                    id,
+                    userId,
+                    kind: mediaParams.kind,
+                    prompt: mediaParams.prompt,
+                    model: mediaParams.model,
+                    ...(mediaParams.pluginId ? { pluginId: mediaParams.pluginId } : {}),
+                    mimeType: mediaParams.mimeType,
+                    ...(mediaParams.size ? { size: mediaParams.size } : {}),
+                    ...(mediaParams.quality ? { quality: mediaParams.quality } : {}),
+                    ...(mediaParams.metadata ? { metadata: mediaParams.metadata } : {}),
+                    createdAt,
+                }, {
+                    blobId: blob.id,
+                    ownerUserId: userId,
+                    resourceType: RESOURCE_TYPE,
+                    resourceId: id,
+                    purpose: BLOB_PURPOSE,
+                    createdAt,
+                });
+            }
+            catch (error) {
+                let existing;
+                let reference;
+                try {
+                    existing = await this.getRecord(id, userId);
+                    reference = await platform.blobReferences.find(RESOURCE_TYPE, id, BLOB_PURPOSE);
+                    const committedRecordMatches = existing !== undefined &&
+                        existing.id === id &&
+                        existing.userId === userId &&
+                        existing.kind === mediaParams.kind &&
+                        existing.prompt === mediaParams.prompt &&
+                        existing.model === mediaParams.model &&
+                        (existing.pluginId ?? undefined) === mediaParams.pluginId &&
+                        existing.mimeType === mediaParams.mimeType &&
+                        (existing.size ?? undefined) === mediaParams.size &&
+                        (existing.quality ?? undefined) === mediaParams.quality &&
+                        JSON.stringify(existing.metadata ?? undefined) ===
+                            JSON.stringify(mediaParams.metadata ?? undefined) &&
+                        existing.createdAt === createdAt;
+                    if (existing &&
+                        committedRecordMatches &&
+                        reference?.blobId === blob.id &&
+                        reference.ownerUserId === userId &&
+                        reference.resourceType === RESOURCE_TYPE &&
+                        reference.resourceId === id &&
+                        reference.purpose === BLOB_PURPOSE) {
+                        await platform.blobStore.stat(blob.id, userId);
+                        return { ...existing, mediaData: mediaParams.mediaData };
+                    }
+                }
+                catch {
+                    throw new Error('Generated media insert outcome is ambiguous; reconciliation is required');
+                }
+                if (!existing && !reference) {
+                    await platform.blobStore.delete({
+                        id: blob.id,
+                        ownerUserId: userId,
+                    });
+                    blobId = undefined;
+                }
+                else {
+                    throw new Error('Generated media insert outcome conflicts with authoritative metadata; reconciliation is required');
+                }
+                throw error;
             }
-            return {
-                id: row.id,
-                userId: row.user_id,
-                prompt: encryptionService.decrypt(row.prompt),
-                model: row.model,
-                imageData: encryptionService.decrypt(row.image_data),
-                size: row.size || undefined,
-                quality: row.quality || undefined,
-                createdAt: row.created_at,
-            };
+            return { id, userId, createdAt, ...mediaParams };
         }
         catch (error) {
-            logger.error('Error getting image from gallery:', error);
+            logger.error('Error saving generated media:', error);
+            if (blobId)
+                logger.warn(`Gallery blob ${blobId} may require reconciliation`);
             return null;
         }
     }
-    /**
-     * Delete an image from the gallery
-     */
-    deleteImage(imageId, userId) {
-        const db = getDatabaseSafe();
-        if (!db) {
-            return false;
-        }
-        try {
-            // Verify ownership before deleting
-            const result = db
-                .prepare(`DELETE FROM generated_images
-           WHERE id = ? AND user_id = ? AND kind = 'image'`)
-                .run(imageId, userId);
-            return result.changes > 0;
-        }
-        catch (error) {
-            logger.error('Error deleting image from gallery:', error);
-            return false;
-        }
+    async getMedia(userId, params = {}) {
+        const limit = Math.max(1, Math.min(100, params.limit || 20));
+        const offset = Math.max(0, params.offset || 0);
+        const result = await getPlatformStorageRuntime().domains.gallery.listByOwner(userId, {
+            limit,
+            offset,
+            ...(params.kind ? { kind: params.kind } : {}),
+        });
+        return {
+            media: result.records.map(record => ({ ...record, mediaData: '' })),
+            total: result.total,
+        };
     }
-    /**
-     * Delete all images for a user
-     */
-    deleteAllImages(userId) {
-        const db = getDatabaseSafe();
-        if (!db) {
-            return false;
-        }
-        try {
-            db.prepare(`DELETE FROM generated_images WHERE user_id = ? AND kind = 'image'`).run(userId);
-            return true;
-        }
-        catch (error) {
-            logger.error('Error deleting all images from gallery:', error);
-            return false;
-        }
+    async getMediaItem(mediaId, userId) {
+        const record = await this.getRecord(mediaId, userId);
+        if (!record)
+            return null;
+        return { ...record, mediaData: record.legacyMediaData || '' };
     }
-    deleteMedia(mediaId, userId) {
-        const db = getDatabaseSafe();
-        if (!db)
-            return false;
-        try {
-            return (db
-                .prepare('DELETE FROM generated_images WHERE id = ? AND user_id = ?')
-                .run(mediaId, userId).changes > 0);
-        }
-        catch (error) {
-            logger.error('Error deleting generated media:', error);
-            return false;
+    async openMediaContent(mediaId, userId, range, signal) {
+        const record = await this.getRecord(mediaId, userId);
+        if (!record)
+            return undefined;
+        const platform = getPlatformStorageRuntime();
+        let reference = await platform.blobReferences.find(RESOURCE_TYPE, mediaId, BLOB_PURPOSE);
+        if (!reference) {
+            await this.migrateLegacyBlob(record);
+            reference = await platform.blobReferences.find(RESOURCE_TYPE, mediaId, BLOB_PURPOSE);
         }
+        if (!reference || reference.ownerUserId !== userId)
+            return undefined;
+        const content = await platform.blobStore.open({
+            id: reference.blobId,
+            ownerUserId: userId,
+            ...(range ? { range } : {}),
+            ...(signal ? { signal } : {}),
+        });
+        return { record, content };
     }
-}
-function toGeneratedMedia(row) {
-    let metadata;
-    if (row.metadata) {
-        try {
-            const parsed = JSON.parse(row.metadata);
-            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
-                metadata = parsed;
-            }
-        }
-        catch {
-            metadata = undefined;
+    async getImages(userId, params = {}) {
+        const result = await this.getMedia(userId, { ...params, kind: 'image' });
+        return {
+            images: result.media.map(item => ({
+                id: item.id,
+                userId: item.userId,
+                prompt: item.prompt,
+                model: item.model,
+                imageData: `/api/media/gallery/${encodeURIComponent(item.id)}/content`,
+                ...(item.size ? { size: item.size } : {}),
+                ...(item.quality ? { quality: item.quality } : {}),
+                createdAt: item.createdAt,
+            })),
+            total: result.total,
+        };
+    }
+    async getImage(imageId, userId) {
+        const item = await this.getMediaItem(imageId, userId);
+        if (!item || item.kind !== 'image')
+            return null;
+        return {
+            id: item.id,
+            userId: item.userId,
+            prompt: item.prompt,
+            model: item.model,
+            imageData: `/api/media/gallery/${encodeURIComponent(item.id)}/content`,
+            ...(item.size ? { size: item.size } : {}),
+            ...(item.quality ? { quality: item.quality } : {}),
+            createdAt: item.createdAt,
+        };
+    }
+    async deleteMedia(mediaId, userId) {
+        await this.cancelVideoLifecycle(mediaId, userId);
+        return this.withMediaWriteLease(mediaId, userId, async (assertHeld) => {
+            await this.cancelVideoLifecycle(mediaId, userId);
+            const platform = getPlatformStorageRuntime();
+            const existing = await this.getRecord(mediaId, userId);
+            if (!existing)
+                return false;
+            await assertHeld();
+            return platform.domains.gallery.deleteAndEnqueue(mediaId, userId, transactionalResourceDeletionEnqueuer);
+        });
+    }
+    async deleteImage(imageId, userId) {
+        const record = await this.getRecord(imageId, userId);
+        return record?.kind === 'image' ? this.deleteMedia(imageId, userId) : false;
+    }
+    async deleteAllImages(userId) {
+        const items = await this.getMedia(userId, { kind: 'image', limit: 100 });
+        let offset = 0;
+        let page = items;
+        while (page.media.length > 0) {
+            for (const item of page.media)
+                await this.deleteMedia(item.id, userId);
+            offset += page.media.length;
+            if (offset >= page.total)
+                break;
+            page = await this.getMedia(userId, { kind: 'image', limit: 100 });
         }
+        return true;
     }
-    return {
-        id: row.id,
-        userId: row.user_id,
-        kind: row.kind,
-        prompt: encryptionService.decrypt(row.prompt),
-        model: row.model,
-        ...(row.plugin_id ? { pluginId: row.plugin_id } : {}),
-        mediaData: encryptionService.decrypt(row.image_data),
-        mimeType: row.mime_type,
-        ...(row.size ? { size: row.size } : {}),
-        ...(row.quality ? { quality: row.quality } : {}),
-        ...(metadata ? { metadata } : {}),
-        createdAt: row.created_at,
-    };
 }
 function inferImageMimeType(imageData) {
     const match = /^data:(image\/[a-z0-9.+-]+);base64,/i.exec(imageData);