aigen/pages/queue.vue

<template>
  <div class="min-h-screen">
    <header class="sticky top-0 z-20 border-b border-white/5 bg-zinc-950/70 backdrop-blur-xl">
      <div class="mx-auto flex max-w-7xl items-center justify-between px-4 py-4 sm:px-6">
        <div class="flex items-center gap-3">
          <NuxtLink to="/" class="flex h-10 w-10 items-center justify-center rounded-xl bg-amber-400 text-zinc-950 font-display font-extrabold">A</NuxtLink>
          <div>
            <h1 class="font-display text-xl font-bold leading-none">{{ instanceName }}</h1>
            <p class="text-[11px] uppercase tracking-[0.22em] text-zinc-500">Shot queue</p>
          </div>
        </div>
        <div class="flex items-center gap-3 text-sm">
          <NuxtLink to="/" class="rounded-full border border-white/10 px-3 py-1 text-zinc-300 hover:border-amber-300/50 hover:text-white">
            Studio
          </NuxtLink>
          <a v-if="authEnabled" href="/api/auth/logout" class="text-zinc-400 hover:text-white">Sign out</a>
        </div>
      </div>
    </header>

    <main class="mx-auto max-w-7xl space-y-6 px-4 py-6 sm:px-6">
      <div class="flex flex-wrap items-end justify-between gap-3">
        <div>
          <h2 class="font-display text-2xl font-bold">Queue</h2>
          <p class="mt-1 max-w-2xl text-sm text-zinc-400">
            Each shot ticks off when it saves. If a run stops, continue from the next unchecked scene.
          </p>
        </div>
        <p v-if="pendingCount" class="text-sm text-amber-100">{{ pendingCount }} shot{{ pendingCount === 1 ? '' : 's' }} waiting</p>
      </div>

      <p v-if="error" class="rounded-2xl border border-red-400/30 bg-red-400/10 px-4 py-3 text-sm text-red-200">{{ error }}</p>
      <p v-else-if="!queues.length" class="glass rounded-3xl px-5 py-10 text-center text-sm text-zinc-400">
        No batches yet. Queue extensions or paste a shot script on the studio page, generate the first shot, then come back here for the rest.
      </p>

      <section
        v-for="queue in queues"
        :key="queue.id"
        class="glass rounded-3xl p-5 sm:p-6 space-y-4"
      >
        <div class="flex flex-wrap items-start justify-between gap-3">
          <div class="min-w-0">
            <h3 class="truncate font-display text-lg font-semibold text-zinc-100">{{ queue.name }}</h3>
            <p class="mt-1 text-sm text-zinc-300">
              {{ progressLine(queue) }}
            </p>
            <p v-if="liveMessage[queue.id]" class="mt-1 text-xs text-amber-100">{{ liveMessage[queue.id] }}</p>
            <p v-if="queue.lastError" class="mt-1 text-xs text-red-300">{{ queue.lastError }}</p>
          </div>
          <div class="flex flex-wrap gap-2">
            <button
              type="button"
              class="rounded-full bg-amber-400 px-3 py-1.5 text-xs font-semibold text-zinc-950 disabled:cursor-not-allowed disabled:opacity-50"
              :disabled="busyId === queue.id || queue.status === 'running' || queue.status === 'complete' || queue.pendingCount === 0"
              @click="process(queue, 1)"
            >
              {{ continueLabel(queue) }}
            </button>
            <button
              type="button"
              class="rounded-full border border-white/10 px-3 py-1.5 text-xs text-zinc-200 hover:border-amber-300/40 disabled:cursor-not-allowed disabled:opacity-50"
              :disabled="busyId === queue.id || queue.status === 'running' || queue.status === 'complete' || queue.pendingCount < 2"
              @click="process(queue, Math.min(3, queue.pendingCount))"
            >
              Next {{ Math.min(3, queue.pendingCount) || 3 }}
            </button>
            <button
              type="button"
              class="rounded-full border border-white/10 px-3 py-1.5 text-xs text-zinc-200 hover:border-amber-300/40 disabled:cursor-not-allowed disabled:opacity-50"
              :disabled="busyId === queue.id || queue.status === 'running' || queue.status === 'complete' || queue.pendingCount === 0"
              @click="process(queue, 'all')"
            >
              Run remaining
            </button>
            <button
              v-if="queue.status === 'running'"
              type="button"
              class="rounded-full border border-red-400/40 px-3 py-1.5 text-xs text-red-200"
              @click="pause(queue)"
            >
              Pause after this shot
            </button>
            <button
              v-if="queue.status !== 'running'"
              type="button"
              class="rounded-full border border-white/10 px-3 py-1.5 text-xs text-zinc-400 hover:text-red-200"
              @click="remove(queue)"
            >
              Dismiss
            </button>
          </div>
        </div>

        <ol class="space-y-2">
          <li
            v-for="segment in queue.segments"
            :key="segment.index"
            class="rounded-2xl border px-4 py-3"
            :class="segmentClass(queue, segment)"
          >
            <div class="flex items-start gap-3">
              <span
                class="mt-0.5 flex h-6 w-6 shrink-0 items-center justify-center rounded-full text-xs font-bold"
                :class="markClass(queue, segment)"
              >{{ markLabel(queue, segment) }}</span>
              <div class="min-w-0 flex-1">
                <div class="flex flex-wrap items-center justify-between gap-2">
                  <p class="text-sm font-medium text-zinc-100">
                    Shot {{ segment.index + 1 }}
                    <span class="font-normal text-zinc-500">{{ segmentCaption(queue, segment) }}</span>
                  </p>
                  <span class="text-xs text-zinc-500">{{ segment.duration }}s</span>
                </div>
                <p
                  v-if="segment.status === 'complete'"
                  class="mt-1 truncate text-xs text-zinc-400"
                >{{ segment.prompt }}</p>
                <textarea
                  v-else
                  v-model="segment.prompt"
                  rows="3"
                  class="mt-2 w-full rounded-xl border border-white/10 bg-zinc-950 px-3 py-2 text-sm outline-none ring-amber-300/40 placeholder:text-zinc-600 focus:ring-2 disabled:opacity-70"
                  :disabled="segment.status === 'running' || queue.status === 'running'"
                  @focus="markDirty(queue.id, segment.index)"
                  @change="saveSegment(queue, segment)"
                />
                <DurationField
                  v-if="segment.status !== 'complete' && segment.status !== 'running'"
                  v-model="segment.duration"
                  class="mt-3"
                  label="Duration"
                  @update:modelValue="saveSegment(queue, segment)"
                />
                <div v-if="segment.clipId" class="mt-2">
                  <a
                    class="text-xs text-amber-200 hover:text-amber-100"
                    :href="`/api/library/clips/${segment.clipId}/video`"
                    target="_blank"
                    rel="noreferrer"
                  >Open saved clip</a>
                </div>
                <p v-if="segment.error" class="mt-2 text-xs text-red-300">{{ segment.error }}</p>
              </div>
            </div>
          </li>
        </ol>
      </section>
    </main>
  </div>
</template>

<script setup lang="ts">
type Segment = {
  index: number
  prompt: string
  duration: number
  status: 'pending' | 'running' | 'complete' | 'error'
  clipId?: string
  error?: string
}

type Queue = {
  id: string
  name: string
  status: string
  lastError?: string
  pendingCount: number
  completedCount: number
  totalCount: number
  currentJobId?: string
  segments: Segment[]
}

const instanceName = ref(String(useRuntimeConfig().public.instanceName || 'AIGen'))
const authEnabled = ref(false)
const queues = ref<Queue[]>([])
const pendingCount = ref(0)
const error = ref('')
const busyId = ref('')
const liveMessage = ref<Record<string, string>>({})
const dirty = new Set<string>()
const sources = new Map<string, EventSource>()
let pollTimer: ReturnType<typeof setInterval> | null = null

function dirtyKey(queueId: string, index: number) {
  return `${queueId}:${index}`
}

function markDirty(queueId: string, index: number) {
  dirty.add(dirtyKey(queueId, index))
}

function nextSegment(queue: Queue) {
  return queue.segments.find(segment => segment.status === 'pending' || segment.status === 'error')
    || queue.segments.find(segment => segment.status === 'running')
}

function progressLine(queue: Queue) {
  const next = nextSegment(queue)
  if (queue.status === 'complete') return `All ${queue.totalCount} shots saved.`
  if (queue.status === 'running' && next) {
    return `Generating shot ${next.index + 1} of ${queue.totalCount}. ${queue.completedCount} saved.`
  }
  if (queue.completedCount === 0) return `Not started · ${queue.totalCount} shots`
  if (next) return `Left off after shot ${queue.completedCount} of ${queue.totalCount}. Next is shot ${next.index + 1}.`
  return `Shot ${queue.completedCount} of ${queue.totalCount}`
}

function continueLabel(queue: Queue) {
  const next = nextSegment(queue)
  if (!next) return 'Process next'
  return `Continue shot ${next.index + 1}`
}

function segmentCaption(queue: Queue, segment: Segment) {
  if (segment.status === 'complete') return '· saved'
  if (segment.status === 'running') return '· generating now'
  if (segment.status === 'error') return '· failed · retry from here'
  if (nextSegment(queue)?.index === segment.index) return '· next up'
  return '· waiting'
}

function segmentClass(queue: Queue, segment: Segment) {
  if (segment.status === 'complete') return 'border-emerald-400/25 bg-emerald-400/5'
  if (segment.status === 'running') return 'border-amber-300/50 bg-amber-400/10'
  if (segment.status === 'error') return 'border-red-400/30 bg-red-400/5'
  if (nextSegment(queue)?.index === segment.index) return 'border-amber-300/30 bg-zinc-950/70'
  return 'border-white/10 bg-zinc-950/50'
}

function markClass(queue: Queue, segment: Segment) {
  if (segment.status === 'complete') return 'bg-emerald-400 text-zinc-950'
  if (segment.status === 'running') return 'bg-amber-400 text-zinc-950'
  if (segment.status === 'error') return 'bg-red-400 text-zinc-950'
  if (nextSegment(queue)?.index === segment.index) return 'border border-amber-300/70 text-amber-100'
  return 'border border-white/15 text-zinc-500'
}

function markLabel(queue: Queue, segment: Segment) {
  if (segment.status === 'complete') return '✓'
  if (segment.status === 'running') return '▶'
  if (segment.status === 'error') return '!'
  if (nextSegment(queue)?.index === segment.index) return String(segment.index + 1)
  return String(segment.index + 1)
}

function mergeQueues(incoming: Queue[]) {
  const previous = new Map(queues.value.map(queue => [queue.id, queue]))
  return incoming.map((next) => {
    const old = previous.get(next.id)
    if (!old) return next
    return {
      ...next,
      segments: next.segments.map((segment) => {
        const prior = old.segments.find(item => item.index === segment.index)
        if (!prior || !dirty.has(dirtyKey(next.id, segment.index))) return segment
        return {
          ...segment,
          prompt: prior.prompt,
          duration: prior.duration
        }
      })
    }
  })
}

async function loadQueues() {
  const data = await $fetch<{ queues?: Queue[]; pendingCount?: number }>('/api/queues')
  queues.value = mergeQueues(data.queues || [])
  pendingCount.value = data.pendingCount || 0
  for (const queue of queues.value) {
    if (queue.status === 'running' && queue.currentJobId) listen(queue)
  }
}

function listen(queue: Queue) {
  if (!queue.currentJobId || sources.has(queue.id)) return
  const source = new EventSource(`/api/generate/${queue.currentJobId}/stream`)
  sources.set(queue.id, source)
  source.onmessage = (event) => {
    try {
      const payload = JSON.parse(event.data) as { message?: string; type?: string }
      if (payload.message) liveMessage.value = { ...liveMessage.value, [queue.id]: payload.message }
      if (payload.type === 'checkpoint' || payload.type === 'complete' || payload.type === 'error') {
        void loadQueues()
      }
      if (payload.type === 'complete' || payload.type === 'error') {
        source.close()
        sources.delete(queue.id)
      }
    } catch { /* ignore */ }
  }
}

async function process(queue: Queue, count: number | 'all') {
  busyId.value = queue.id
  error.value = ''
  try {
    await $fetch(`/api/queues/${queue.id}`, {
      method: 'PATCH',
      body: {
        segments: queue.segments
          .filter(segment => segment.status !== 'complete')
          .map(segment => ({ index: segment.index, prompt: segment.prompt, duration: segment.duration }))
      }
    }).catch(() => null)
    for (const segment of queue.segments) dirty.delete(dirtyKey(queue.id, segment.index))
    const started = await $fetch<{ jobId: string }>(`/api/queues/${queue.id}/process`, {
      method: 'POST',
      body: { count }
    })
    queue.currentJobId = started.jobId
    listen({ ...queue, currentJobId: started.jobId })
    await loadQueues()
  } catch (err: any) {
    error.value = err?.data?.statusMessage || err?.statusMessage || err?.message || 'Could not start the next shot'
  } finally {
    busyId.value = ''
  }
}

async function pause(queue: Queue) {
  await $fetch(`/api/queues/${queue.id}/pause`, { method: 'POST' }).catch(() => null)
  await loadQueues()
}

async function remove(queue: Queue) {
  if (!confirm('Remove this batch from the queue? Saved clips stay in the library.')) return
  await $fetch(`/api/queues/${queue.id}`, { method: 'DELETE' }).catch((err: any) => {
    error.value = err?.data?.statusMessage || err?.message || 'Could not remove that batch'
  })
  await loadQueues()
}

let saveTimer: ReturnType<typeof setTimeout> | null = null
function saveSegment(queue: Queue, segment: Segment) {
  markDirty(queue.id, segment.index)
  if (saveTimer) clearTimeout(saveTimer)
  saveTimer = setTimeout(() => {
    void $fetch(`/api/queues/${queue.id}`, {
      method: 'PATCH',
      body: { segments: [{ index: segment.index, prompt: segment.prompt, duration: segment.duration }] }
    }).then(() => {
      dirty.delete(dirtyKey(queue.id, segment.index))
    }).catch(() => null)
  }, 400)
}

onMounted(async () => {
  const me = await $fetch<{ user?: { name?: string }; authEnabled?: boolean; instanceName?: string }>('/api/auth/me').catch(() => ({ user: null }))
  authEnabled.value = Boolean(me.authEnabled)
  instanceName.value = me.instanceName || instanceName.value
  await loadQueues().catch((err: any) => {
    error.value = err?.data?.statusMessage || err?.message || 'Could not load the queue'
  })
  pollTimer = setInterval(() => { void loadQueues().catch(() => null) }, 4000)
})

onBeforeUnmount(() => {
  if (pollTimer) clearInterval(pollTimer)
  if (saveTimer) clearTimeout(saveTimer)
  for (const source of sources.values()) source.close()
  sources.clear()
})
</script>