Add a persistent clip library with folders, optional password, and hidden-thumbnail glow.

Generated videos save into a chosen folder, sensitive clips skip thumbnails until played, and Docker writes the catalog to a Coolify volume. Co-authored-by: Cursor <cursoragent@cursor.com>
2026-08-25 18:03:26 -05:00
parent 30669c7a27
commit 83051e0ea3
20 changed files with 749 additions and 60 deletions
@@ -0,0 +1,280 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { randomBytes, scrypt, timingSafeEqual } from 'node:crypto'
+import { promisify } from 'node:util'
+import type { H3Event } from 'h3'
+
+const scryptAsync = promisify(scrypt)
+
+export interface LibraryFolder {
+  id: string
+  name: string
+  createdAt: number
+}
+
+export interface LibraryClip {
+  id: string
+  folderId: string
+  prompt: string
+  aspect: string
+  width: number
+  height: number
+  steps: number
+  turbo: boolean
+  seed: number
+  hideThumbnail: boolean
+  createdAt: number
+}
+
+interface Catalog {
+  passwordHash: string | null
+  folders: LibraryFolder[]
+  clips: LibraryClip[]
+}
+
+function libraryRoot() {
+  const config = useRuntimeConfig()
+  return (config.libraryDir || process.env.LIBRARY_DIR || '/data/library').replace(/\/$/, '')
+}
+
+function catalogPath() {
+  return join(libraryRoot(), 'catalog.json')
+}
+
+function ensureRoot() {
+  const root = libraryRoot()
+  mkdirSync(join(root, 'files'), { recursive: true })
+  return root
+}
+
+function emptyCatalog(): Catalog {
+  return {
+    passwordHash: null,
+    folders: [{ id: 'inbox', name: 'Inbox', createdAt: Date.now() }],
+    clips: []
+  }
+}
+
+let writeChain = Promise.resolve()
+
+function readCatalog(): Catalog {
+  ensureRoot()
+  if (!existsSync(catalogPath())) {
+    const created = emptyCatalog()
+    writeFileSync(catalogPath(), JSON.stringify(created, null, 2))
+    return created
+  }
+  try {
+    const parsed = JSON.parse(readFileSync(catalogPath(), 'utf8')) as Catalog
+    if (!Array.isArray(parsed.folders) || !parsed.folders.length) {
+      parsed.folders = emptyCatalog().folders
+    }
+    parsed.clips = Array.isArray(parsed.clips) ? parsed.clips : []
+    parsed.passwordHash = parsed.passwordHash || null
+    return parsed
+  } catch {
+    return emptyCatalog()
+  }
+}
+
+function writeCatalog(catalog: Catalog) {
+  ensureRoot()
+  const tmp = catalogPath() + '.tmp'
+  writeFileSync(tmp, JSON.stringify(catalog, null, 2))
+  renameSync(tmp, catalogPath())
+}
+
+function mutate<T>(fn: (catalog: Catalog) => T): Promise<T> {
+  const run = writeChain.then(() => {
+    const catalog = readCatalog()
+    const result = fn(catalog)
+    writeCatalog(catalog)
+    return result
+  })
+  writeChain = run.then(() => undefined, () => undefined)
+  return run
+}
+
+export function passwordVersion(hash: string | null) {
+  return hash ? hash.slice(-24) : 'open'
+}
+
+export function currentPasswordVersion() {
+  return passwordVersion(readCatalog().passwordHash)
+}
+
+export function isLibraryLocked() {
+  return Boolean(readCatalog().passwordHash)
+}
+
+export function libraryUnlocked(event: H3Event) {
+  const catalog = readCatalog()
+  if (!catalog.passwordHash) return true
+  return getLibraryUnlockVersion(event) === passwordVersion(catalog.passwordHash)
+}
+
+export function assertLibraryAccess(event: H3Event) {
+  if (libraryUnlocked(event)) return readCatalog()
+  throw createError({ statusCode: 403, statusMessage: 'Library is locked' })
+}
+
+export async function hashLibraryPassword(password: string) {
+  const salt = randomBytes(16)
+  const hash = await scryptAsync(password, salt, 64) as Buffer
+  return `scrypt:${salt.toString('hex')}:${hash.toString('hex')}`
+}
+
+export async function verifyLibraryPassword(password: string) {
+  const stored = readCatalog().passwordHash
+  if (!stored) return true
+  const parts = stored.split(':')
+  if (parts.length !== 3 || parts[0] !== 'scrypt') return false
+  const salt = Buffer.from(parts[1], 'hex')
+  const expected = Buffer.from(parts[2], 'hex')
+  const actual = await scryptAsync(password, salt, 64) as Buffer
+  return actual.length === expected.length && timingSafeEqual(actual, expected)
+}
+
+export function publicLibrary(event: H3Event) {
+  const catalog = readCatalog()
+  const locked = Boolean(catalog.passwordHash)
+  const unlocked = libraryUnlocked(event)
+  if (locked && !unlocked) {
+    return { locked: true, unlocked: false, folders: [] as LibraryFolder[], clips: [] as LibraryClip[] }
+  }
+  return {
+    locked,
+    unlocked: true,
+    folders: catalog.folders,
+    clips: catalog.clips
+  }
+}
+
+export function createFolder(name: string) {
+  const trimmed = name.trim().slice(0, 80)
+  if (!trimmed) throw createError({ statusCode: 400, statusMessage: 'Folder name is required' })
+  return mutate((catalog) => {
+    if (catalog.folders.some(folder => folder.name.toLowerCase() === trimmed.toLowerCase())) {
+      throw createError({ statusCode: 409, statusMessage: 'A folder with that name already exists' })
+    }
+    const folder: LibraryFolder = { id: crypto.randomUUID(), name: trimmed, createdAt: Date.now() }
+    catalog.folders.push(folder)
+    return folder
+  })
+}
+
+export function renameFolder(id: string, name: string) {
+  const trimmed = name.trim().slice(0, 80)
+  if (!trimmed) throw createError({ statusCode: 400, statusMessage: 'Folder name is required' })
+  return mutate((catalog) => {
+    const folder = catalog.folders.find(item => item.id === id)
+    if (!folder) throw createError({ statusCode: 404, statusMessage: 'Folder not found' })
+    folder.name = trimmed
+    return folder
+  })
+}
+
+export function deleteFolder(id: string) {
+  return mutate((catalog) => {
+    if (catalog.folders.length <= 1) {
+      throw createError({ statusCode: 400, statusMessage: 'Keep at least one library folder' })
+    }
+    const folder = catalog.folders.find(item => item.id === id)
+    if (!folder) throw createError({ statusCode: 404, statusMessage: 'Folder not found' })
+    const clips = catalog.clips.filter(clip => clip.folderId === id)
+    catalog.folders = catalog.folders.filter(item => item.id !== id)
+    catalog.clips = catalog.clips.filter(clip => clip.folderId !== id)
+    const fallback = catalog.folders[0].id
+    for (const clip of clips) {
+      rmSync(clipDir(clip.id), { recursive: true, force: true })
+    }
+    return { fallbackFolderId: fallback }
+  })
+}
+
+export async function setLibraryPassword(password: string | null) {
+  const hash = password && password.length ? await hashLibraryPassword(password) : null
+  return mutate((catalog) => {
+    catalog.passwordHash = hash
+    return passwordVersion(hash)
+  })
+}
+
+function clipDir(id: string) {
+  return join(libraryRoot(), 'files', id)
+}
+
+export function clipVideoPath(id: string) {
+  return join(clipDir(id), 'video.mp4')
+}
+
+export function clipThumbPath(id: string) {
+  return join(clipDir(id), 'thumb')
+}
+
+export async function saveClip(params: {
+  folderId: string
+  prompt: string
+  aspect: string
+  width: number
+  height: number
+  steps: number
+  turbo: boolean
+  seed: number
+  hideThumbnail: boolean
+  video: Buffer
+  thumb?: Buffer | null
+}) {
+  const catalog = readCatalog()
+  const folder = catalog.folders.find(item => item.id === params.folderId) || catalog.folders[0]
+  if (!folder) throw createError({ statusCode: 400, statusMessage: 'No library folder available' })
+  const clip: LibraryClip = {
+    id: crypto.randomUUID(),
+    folderId: folder.id,
+    prompt: params.prompt,
+    aspect: params.aspect,
+    width: params.width,
+    height: params.height,
+    steps: params.steps,
+    turbo: params.turbo,
+    seed: params.seed,
+    hideThumbnail: params.hideThumbnail,
+    createdAt: Date.now()
+  }
+  mkdirSync(clipDir(clip.id), { recursive: true })
+  writeFileSync(clipVideoPath(clip.id), params.video)
+  if (!params.hideThumbnail && params.thumb?.length) {
+    writeFileSync(clipThumbPath(clip.id), params.thumb)
+  }
+  await mutate((next) => {
+    next.clips.unshift(clip)
+  })
+  return clip
+}
+
+export function getClip(id: string) {
+  const clip = readCatalog().clips.find(item => item.id === id)
+  if (!clip) throw createError({ statusCode: 404, statusMessage: 'Clip not found' })
+  return clip
+}
+
+export function deleteClip(id: string) {
+  return mutate((catalog) => {
+    const clip = catalog.clips.find(item => item.id === id)
+    if (!clip) throw createError({ statusCode: 404, statusMessage: 'Clip not found' })
+    catalog.clips = catalog.clips.filter(item => item.id !== id)
+    rmSync(clipDir(id), { recursive: true, force: true })
+    return clip
+  })
+}
+
+export async function downloadComfyVideo(video: { filename: string; subfolder: string; type: string }) {
+  const params = new URLSearchParams({
+    filename: video.filename,
+    subfolder: video.subfolder,
+    type: video.type
+  })
+  const res = await comfyFetch(`/view?${params.toString()}`)
+  if (!res.ok) throw new Error('Failed to fetch completed video from ComfyUI')
+  return Buffer.from(await res.arrayBuffer())
+}