Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

19.7 KB
Raw Blame
/**
 * Deck editor — `/decks/:id`.
 *
 * Header (name, kind, universe, completion) → action bar (backend + LLM pins,
 * generate prompts, render missing / all) → tabs: the card grid (one
 * three-state slot per card, drawer per card) and the style guide + samples.
 * Every card render rides the shared media queue; the server files a finished
 * image onto the card, and the grid's live slots settle through
 * `MediaJobThumb`. In-flight state lives on each card's `render` record —
 * stamped optimistically when a render is queued, flipped when the slot
 * settles — so a render started here or on a previous visit reads the same.
 *
 * The deck's render target (backend pin, card trim, local-runtime verdict)
 * resolves once here and is handed to both the action bar and the grid, so the
 * options the bar advertises are exactly the ones a single card re-renders on.
 */

import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
import { Link, useNavigate, useParams } from 'react-router';
import { ArrowLeft, Globe, Trash2 } from 'lucide-react';
import PageSkeleton from '../components/ui/PageSkeleton';
import ProgressBar from '../components/ui/ProgressBar';
import TabPills from '../components/ui/TabPills';
import Pill from '../components/ui/Pill';
import InlineConfirmRow from '../components/ui/InlineConfirmRow';
import ListLoadError from '../components/ui/ListLoadError';
import EmptyState from '../components/EmptyState';
import toast from '../components/ui/Toast';
import MediaPreview from '../components/media/MediaPreview';
import { normalizeImage } from '../components/media/normalize';
import DeckCardGrid from '../components/decks/DeckCardGrid';
import DeckCardDrawer from '../components/decks/DeckCardDrawer';
import DeckStylePanel from '../components/decks/DeckStylePanel';
import DeckRenderControls from '../components/decks/DeckRenderControls';
import useDeckRenderTarget from '../hooks/useDeckRenderTarget';
import useMounted from '../hooks/useMounted';
import useUrlParams from '../hooks/useUrlParams';
import useHydratedPreviewRoute from '../hooks/useHydratedPreviewRoute';
import useFieldDraft from '../hooks/useFieldDraft';
import useListResource from '../hooks/useListResource';
import { useSseProgress } from '../hooks/useSseProgress';
import { DECK_KIND_LABELS, cardInFlightJobId, composeCardRenderPrompt, deckCompletion } from '../lib/decks';
import {
  deleteDeck, generateDeckPrompts, getDeck, listUniverseSummaries, removeDeckSample,
  renderDeckCard, renderDeckCards, updateDeck, updateDeckCard, deckPromptsProgressUrl,
} from '../services/api';

const TABS = [{ id: 'cards', label: 'Cards' }, { id: 'style', label: 'Style & samples' }];

export default function DeckDetail() {
  const { id } = useParams();
  // Route changes replace the editor so every draft, drawer and pending-render
  // map belongs to one deck.
  return <DeckEditor key={id} id={id} />;
}

function DeckEditor({ id }) {
  const navigate = useNavigate();
  const mountedRef = useMounted();
  const [params, updateParams] = useUrlParams();
  const tab = TABS.some((t) => t.id === params.get('tab')) ? params.get('tab') : 'cards';
  const cardParam = params.get('card');

  const [deck, setDeck] = useState(null);
  const fetchUniverses = useCallback(() => listUniverseSummaries({ silent: true }), []);
  const universesResource = useListResource(fetchUniverses);
  const { items: universes } = universesResource;
  const [loading, setLoading] = useState(true);
  const [confirmingDelete, setConfirmingDelete] = useState(false);
  const [generating, setGenerating] = useState(false);
  const [rendering, setRendering] = useState(false);
  const [savingCard, setSavingCard] = useState(false);
  const [promptProgressUrl, setPromptProgressUrl] = useState(null);
  const lastChunkSeen = useRef(0);
  // Live prompt-writing progress. The URL is set for the duration of one
  // generate call. The server reserves the channel on POST arrival and retains
  // each frame until attach, so starting the POST before React's EventSource
  // effect runs cannot drop progress.
  const { frames: promptFrames } = useSseProgress(promptProgressUrl, { enabled: !!promptProgressUrl });
  const loadSeqRef = useRef(0);
  // Resolved once for the page: the render bar names these options, the grid's
  // per-card re-render button renders on them, and both stand down together on
  // an unavailable local runtime. Two consumers, one settings fetch.
  const renderTarget = useDeckRenderTarget(deck);

  const load = useCallback(async () => {
    const seq = ++loadSeqRef.current;
    setLoading(true);
    const data = await getDeck(id, { silent: true }).catch(() => null);
    if (!mountedRef.current || seq !== loadSeqRef.current) return;
    setDeck(data);
    if (!data) toast.error('Deck not found');
    setLoading(false);
  }, [id, mountedRef]);

  useEffect(() => { load(); }, [load]);

  // Merge a patch into one card of the local deck.
  const patchLocalCard = useCallback((cardId, patch) => {
    setDeck((prev) => (prev ? {
      ...prev,
      cards: prev.cards.map((c) => (c.id === cardId ? { ...c, ...(typeof patch === 'function' ? patch(c) : patch) } : c)),
    } : prev));
  }, []);

  const patchDeck = useCallback(async (patch) => {
    const next = await updateDeck(id, patch, { silent: true }).catch((err) => {
      toast.error(`Save failed: ${err.message}`);
      return null;
    });
    if (next && mountedRef.current) setDeck(next);
    return !!next;
  }, [id, mountedRef]);

  const nameDraft = useFieldDraft(deck?.name, (v) => { if (v.trim()) patchDeck({ name: v.trim() }); });

  const completion = useMemo(() => (deck ? deckCompletion(deck.cards) : null), [deck]);
  const selectedCard = useMemo(
    () => (deck && cardParam ? deck.cards.find((c) => c.id === cardParam) || null : null),
    [deck, cardParam],
  );
  // The card's own `prompt` is only its subject line; the renderer was sent the
  // composed prompt (deck style clause, layout, titled subject, merged
  // negatives), which `useHydratedPreviewRoute` reads back from the sidecar of
  // whichever card the user opens. Compose it locally as the stand-in — a
  // legacy or peer-synced render has no sidecar at all, and falling back to the
  // subject line would re-show the wording that was never sent.
  const previewItems = useMemo(() => (deck
    ? deck.cards.flatMap((c) => {
      if (!c.imageRefs.length) return [];
      const composed = composeCardRenderPrompt(deck, c);
      return c.imageRefs.map((filename) => normalizeImage({
        filename,
        prompt: composed.prompt,
        negativePrompt: composed.negativePrompt || null,
      }));
    })
    : []), [deck]);
  const [preview, setPreview] = useHydratedPreviewRoute(previewItems);
  const previewFilename = (filename) => {
    const item = previewItems.find((i) => i.filename === filename);
    if (item) setPreview(item);
  };

  const openCard = (card) => updateParams({ card: card.id });
  const closeCard = () => updateParams({ card: null });

  // Stamp the queued jobs onto their cards, mirroring what the server wrote.
  const queueJobs = (result) => {
    const byCard = new Map(result.jobs.map((j) => [j.cardId, j.jobId]));
    setDeck((prev) => (prev ? {
      ...prev,
      cards: prev.cards.map((c) => (byCard.has(c.id) ? { ...c, render: { jobId: byCard.get(c.id), status: 'queued', mode: result.mode } } : c)),
    } : prev));
  };

  const renderCard = async (card) => {
    const result = await renderDeckCard(id, card.id, {}, { silent: true }).catch((err) => {
      toast.error(`Render failed to queue: ${err.message}`);
      return null;
    });
    if (result && mountedRef.current) queueJobs(result);
  };

  const renderBatch = async (body, label) => {
    setRendering(true);
    const result = await renderDeckCards(id, body, { silent: true }).catch((err) => {
      toast.error(`${label} failed: ${err.message}`);
      return null;
    });
    if (!mountedRef.current) return;
    setRendering(false);
    if (!result) return;
    queueJobs(result);
    toast.success(`${result.jobs.length} card render${result.jobs.length === 1 ? '' : 's'} queued`);
  };

  const generatePrompts = async ({ overwrite }) => {
    setGenerating(true);
    lastChunkSeen.current = 0;
    // Start the advisory progress stream alongside the POST. The server
    // reserves the channel at POST arrival and replays late frames.
    setPromptProgressUrl(null);
    if (typeof EventSource !== 'undefined') setPromptProgressUrl(deckPromptsProgressUrl(id));
    const result = await generateDeckPrompts(id, { overwrite }, { silent: true }).catch((err) => {
      toast.error(`Prompt generation failed: ${err.message}`);
      return null;
    });
    if (!mountedRef.current) return;
    // Close the stream once the POST has settled — frames stay rendered until
    // the next run, when the chunk counter is reset above.
    setPromptProgressUrl(null);
    setGenerating(false);
    if (!result) return;
    setDeck(result.deck);
    toast.success(`${result.written} prompt${result.written === 1 ? '' : 's'} written${result.cast ? `, ${result.cast} cards cast from the universe` : ''}`);
  };

  // Each persisted chunk refetches the deck so freshly written prompts land
  // in the grid while the run is still going — not just when the POST
  // settles. The server persists every chunk before emitting its frame, so a
  // refetch on that frame always has something new to show.
  useEffect(() => {
    if (!generating || !promptFrames.length) return undefined;
    const latest = promptFrames[promptFrames.length - 1];
    if (latest?.type !== 'chunk' || promptFrames.length <= lastChunkSeen.current) return undefined;
    lastChunkSeen.current = promptFrames.length;
    if (Number.isFinite(latest.cardsWritten) && latest.cardsWritten === 0) return undefined;
    let active = true;
    getDeck(id, { silent: true }).then((data) => {
      if (active && mountedRef.current && data) setDeck(data);
    }).catch(() => {});
    return () => { active = false; };
  }, [promptFrames, generating, id, mountedRef]);

  // One live line for step 1 while a run is in flight: which phase, how many
  // prompts are written of how many requested, and which batch just landed.
  // Null when idle — the step note then falls back to the deck counts.
  const generatingStatus = useMemo(() => {
    if (!generating) return null;
    let phaseLabel = 'Writing prompts…';
    let batchState = null;
    let written = null;
    let requested = null;
    let chunk = null;
    let chunks = null;
    for (const f of promptFrames) {
      if (f?.type === 'phase' && f.label) phaseLabel = f.label;
      else if (f?.type === 'start') {
        if (Number.isFinite(f.requested)) requested = f.requested;
        if (Number.isFinite(f.chunks)) chunks = f.chunks;
        phaseLabel = `Preparing ${requested || 0} prompts in ${chunks || 0} batches…`;
        batchState = null;
      } else if (f?.type === 'batch-start' || f?.type === 'activity') {
        if (Number.isFinite(f.written)) written = f.written;
        if (Number.isFinite(f.requested)) requested = f.requested;
        if (Number.isFinite(f.chunk)) chunk = f.chunk;
        if (Number.isFinite(f.chunks)) chunks = f.chunks;
        batchState = f.type;
      } else if (f?.type === 'chunk') {
        if (Number.isFinite(f.written)) written = f.written;
        if (Number.isFinite(f.requested)) requested = f.requested;
        if (Number.isFinite(f.chunk)) chunk = f.chunk;
        if (Number.isFinite(f.chunks)) chunks = f.chunks;
        batchState = 'saved';
      }
    }
    // Casting runs before the first prompt chunk — name the phase, not a 0/N.
    if (chunk === null && phaseLabel !== 'Writing prompts…') return phaseLabel;
    if (written === null || requested === null) return 'Writing prompts…';
    const batch = chunk !== null && chunks !== null ? ` · batch ${chunk} of ${chunks}` : '';
    if (batchState === 'batch-start') return `Waiting for the AI · ${written} of ${requested} prompts saved${batch}`;
    if (batchState === 'activity') return `AI is responding · ${written} of ${requested} prompts saved${batch}`;
    if (batchState === 'saved') {
      const latest = promptFrames[promptFrames.length - 1];
      const added = Number.isFinite(latest?.cardsWritten) ? latest.cardsWritten : null;
      return added === 0
        ? `Batch finished with no usable prompts · ${written} of ${requested} saved${batch}`
        : `${added === null ? 'Batch saved' : `Saved ${added} prompts`} · ${written} of ${requested}${batch}`;
    }
    return `Writing prompts… ${written} of ${requested}${batch}`;
  }, [generating, promptFrames]);

  const saveCard = async (patch) => {
    if (!selectedCard) return;
    setSavingCard(true);
    const card = await updateDeckCard(id, selectedCard.id, patch, { silent: true }).catch((err) => {
      toast.error(`Card save failed: ${err.message}`);
      return null;
    });
    if (!mountedRef.current) return;
    setSavingCard(false);
    if (card) patchLocalCard(card.id, card);
  };

  const handleSetActiveVersion = async (cardId, filename) => {
    const prev = deck?.cards?.find((c) => c.id === cardId)?.primaryImageRef;
    patchLocalCard(cardId, { primaryImageRef: filename });
    const card = await updateDeckCard(id, cardId, { primaryImageRef: filename }, { silent: true }).catch((err) => {
      toast.error(`Card save failed: ${err.message}`);
      return null;
    });
    if (!mountedRef.current) return;
    if (card) {
      patchLocalCard(cardId, card);
      toast.success('Active version updated');
    } else if (prev !== undefined) {
      // The save failed: roll back the optimistic patch so the grid never
      // displays a version the server doesn't have as active.
      patchLocalCard(cardId, { primaryImageRef: prev });
    }
  };

  // The slot settled with a file — the same merge the server hook performs.
  const onRenderComplete = useCallback((cardId, filename) => {
    if (!filename) return;
    patchLocalCard(cardId, (c) => ({
      imageRefs: [...c.imageRefs.filter((f) => f !== filename), filename],
      primaryImageRef: filename,
      render: { ...(c.render || {}), status: 'completed', filename },
    }));
  }, [patchLocalCard]);

  // Mirror what the server's own completion hook writes (`markCardRenderTerminal`)
  // so the grid can explain a failure immediately instead of only after a reload.
  const onRenderTerminal = useCallback((cardId, status, error = null) => {
    patchLocalCard(cardId, (c) => ({ render: { ...(c.render || {}), status, error: error || null } }));
  }, [patchLocalCard]);

  const handleDelete = async () => {
    setConfirmingDelete(false);
    const ok = await deleteDeck(id, { silent: true }).then(() => true).catch(() => false);
    if (!ok) { toast.error('Failed to delete deck'); return; }
    toast.success('Deck deleted');
    navigate('/decks');
  };

  const handleRemoveSample = async (sampleId) => {
    const next = await removeDeckSample(id, sampleId, { silent: true }).catch(() => null);
    if (next && mountedRef.current) setDeck(next);
    else if (mountedRef.current) toast.error('Failed to remove sample');
  };

  if (loading) return <PageSkeleton header="none" label="Loading deck" cards={4} sidebar={false} />;
  if (!deck) {
    return (
      <EmptyState title="Deck not found" message="This deck may have been deleted." actionTo="/decks" actionLabel="Back to decks" />
    );
  }

  const universe = universes.find((u) => u.id === deck.universeId) || null;

  return (
    <div className="max-w-7xl mx-auto space-y-4">
      <div className="flex items-start gap-3 flex-wrap">
        <Link to="/decks" className="min-h-[44px] min-w-[44px] inline-flex items-center justify-center text-gray-400 hover:text-white" aria-label="Back to decks">
          <ArrowLeft className="w-5 h-5" aria-hidden="true" />
        </Link>
        <div className="flex-1 min-w-[240px] space-y-1">
          <h1 className="sr-only">{deck.name}</h1>
          <label htmlFor="deck-name" className="sr-only">Deck name</label>
          <input
            id="deck-name"
            value={nameDraft.value}
            onChange={nameDraft.onChange}
            onBlur={nameDraft.onBlur}
            maxLength={120}
            className="w-full bg-transparent text-xl font-semibold text-white border-b border-transparent hover:border-port-border focus:border-port-accent focus:outline-none"
          />
          <div className="flex items-center gap-3 text-xs text-gray-400 flex-wrap">
            <Pill tone="context" size="xs">{DECK_KIND_LABELS[deck.kind] || deck.kind}</Pill>
            {universe ? (
              <Link to={`/universes/${universe.id}`} className="inline-flex items-center gap-1 hover:text-white"><Globe className="w-3 h-3" aria-hidden="true" />{universe.name}</Link>
            ) : null}
            {/* Both counters read as fractions of the deck: a bare "79 prompted"
                beside "0/79 rendered" looks like a different denominator. */}
            <span>{completion.rendered}/{completion.total} rendered · {completion.prompted}/{completion.total} prompted{completion.inFlight ? ` · ${completion.inFlight} rendering` : ''}{completion.failed ? ` · ${completion.failed} failed` : ''}</span>
          </div>
          <div className="max-w-md">
            <ProgressBar percent={completion.percent} label="Deck render progress" tone={completion.percent === 100 ? 'success' : 'accent'} />
          </div>
        </div>
        <button
          type="button"
          onClick={() => setConfirmingDelete(true)}
          className="min-h-[44px] min-w-[44px] inline-flex items-center justify-center text-gray-500 hover:text-port-error"
          aria-label={`Delete ${deck.name}`}
          title="Delete deck"
        >
          <Trash2 className="w-4 h-4" aria-hidden="true" />
        </button>
      </div>
      {universesResource.state === 'error' ? (
        <ListLoadError what="universes" error={universesResource.error} onRetry={universesResource.retry} />
      ) : null}
      {confirmingDelete ? (
        <InlineConfirmRow
          question={`Delete "${deck.name}"? Its cards and prompts are removed; rendered images stay in the gallery.`}
          onConfirm={handleDelete}
          onCancel={() => setConfirmingDelete(false)}
        />
      ) : null}

      <DeckRenderControls
        deck={deck}
        completion={completion}
        renderTarget={renderTarget}
        onPatch={patchDeck}
        onGeneratePrompts={generatePrompts}
        onRenderMissing={() => renderBatch({ onlyMissing: true }, 'Render missing')}
        onRenderAll={() => renderBatch({}, 'Render whole deck')}
        generating={generating}
        generatingStatus={generatingStatus}
        rendering={rendering}
      />

      <TabPills tabs={TABS} activeTab={tab} onChange={(next) => updateParams({ tab: next === 'cards' ? null : next })} ariaLabel="Deck sections" />

      {tab === 'style' ? (
        <DeckStylePanel
          deck={deck}
          universes={universes}
          onPatch={patchDeck}
          onDeckReplaced={setDeck}
          onRemoveSample={handleRemoveSample}
        />
      ) : (
        <DeckCardGrid
          deck={deck}
          renderTarget={renderTarget}
          onOpenCard={openCard}
          onRenderCard={renderCard}
          onPreview={(card, filename) => previewFilename(filename || card.primaryImageRef || card.imageRefs.at(-1))}
          onSetActiveVersion={handleSetActiveVersion}
          onRenderComplete={onRenderComplete}
          onRenderTerminal={onRenderTerminal}
        />
      )}

      <DeckCardDrawer
        deck={deck}
        card={selectedCard}
        open={!!selectedCard}
        inFlight={selectedCard ? cardInFlightJobId(selectedCard) : null}
        saving={savingCard}
        onClose={closeCard}
        onSave={saveCard}
        onRender={() => selectedCard && renderCard(selectedCard)}
        onPreview={previewFilename}
      />

      <MediaPreview preview={preview} setPreview={setPreview} items={previewItems} />
    </div>
  );
}