Add library picker to Export step: choose which Plex libraries to scan

Previously export.py always auto-detected the first movie and first TV
library it found in Plex. Users with multiple libraries (4K Movies, Kids
TV, 3D Movies, etc.) had no way to control which content went into the
CSV — everything or nothing.

Changes:
- export.py: new --movie-sections and --tv-sections flags accept
  comma-separated Plex section keys. When provided, only those sections
  are fetched; titles are deduplicated across sections so a title in
  both 'Movies' and '4K Movies' appears once. Omitting a flag still
  auto-detects (first matching section), preserving CLI behaviour.
  Empty string for a flag explicitly skips that content type.

- pipeline_router.py: new GET /api/pipeline/libraries endpoint probes
  Plex and returns all movie/show sections as {key, title, type}.
  ExportOptions gains optional movie_sections and tv_sections fields
  (None = auto-detect, [] = skip that type, ["1","2"] = use those keys).
  Uses Optional[list[str]] so Pydantic can distinguish absent from empty.

- Run.tsx ExportStep: fetches libraries on mount, renders a compact
  'Libraries to scan' card with checkboxes grouped by Movies / TV Shows.
  All checked by default. Gracefully degrades if Plex is unreachable
  (shows warning, export falls back to auto-detect). Run Export button
  disabled only when libraries loaded successfully but none are checked.
  Fixed React synthetic event bug: captures e.currentTarget.checked into
  a local variable before the setState updater runs, preventing crashes
  when currentTarget is nullified after the event handler returns.

- client.ts: added PlexLibrary type and api.getLibraries().

- CLAUDE.md and README.md updated to reflect new flags, endpoint, and
  UI behaviour.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: AlpineArchitecture

CLAUDE.md

@@ -158,6 +158,7 @@ See `config.json.example` for the template.
 - Fetches full metadata directly from Plex API (`/library/sections/{key}/all`)
 - Fields: title, year, contentRating, genres, directors, season/episode counts
 - Cross-references against Tunarr to flag unsynced content
+- Supports multiple sections per type: `--movie-sections KEY1,KEY2` and `--tv-sections KEY1,KEY2` (comma-separated Plex section keys). Deduplicates titles across sections. Omit flags to auto-detect (first movie + first TV section).
 - Output: `plex_library.csv` + `export_summary.json` (movies/tv_shows/skipped counts for the UI stats card)
 
 **`generate_no_ai.py`** (Option B — no AI required)
@@ -265,7 +266,8 @@ A title can appear on multiple channels — this is intentional and expected.
 
 | Method | Path | Description |
 |--------|------|-------------|
-| POST | `/api/pipeline/export` | SSE-stream `export.py`; optional JSON body `{"no_crossref": true}` passes `--no-crossref` to skip Tunarr title matching |
+| GET | `/api/pipeline/libraries` | List Plex library sections filtered to `movie` and `show` types (`{key, title, type}`) |
+| POST | `/api/pipeline/export` | SSE-stream `export.py`; JSON body `{"no_crossref": bool, "movie_sections": ["1","2"], "tv_sections": ["3"]}` — sections are Plex section keys; `null` = auto-detect, `[]` = skip that type |
 | GET | `/api/pipeline/csv` | Download `plex_library.csv` |
 | GET | `/api/pipeline/csv/info` | Stats: rows, movies, tv_shows, skipped counts, preview lines |
 | GET | `/api/pipeline/prompt` | Fetch `PROMPT.md` with `{TARGET}` and preferences injected |
@@ -290,14 +292,14 @@ A title can appear on multiple channels — this is intentional and expected.
 - Stepper navigation is locked: only completed steps are clickable, future steps are grayed out
 
 **AI Path (6 steps):**
-1. **Export** — runs `export.py`, shows compact stats card (movies / TV shows / skipped / size) above terminal; manual Continue
+1. **Export** — fetches Plex library list on mount; shows "Libraries to scan" card with checkboxes grouped by Movies / TV Shows (all checked by default, supports multi-select across libraries of the same type); runs `export.py` with selected section keys; shows compact stats card on success; manual Continue
 2. **LLM Handoff** — config card (channel count NumberInput + theme Textarea); side-by-side prompt copy + CSV download; paste/upload LLM output; post-validate results card showing channel breakdown; "Add Plex Collections" or "Skip to Deploy" buttons
 3. **Add Plex Collections** — fetches collections on mount; 2-column grid with poster, name, count, editable channel number, checkbox (all checked by default); applies selections to `channels.json`
 4. **Deploy** — probe explainer card; runs probe; after probe completes: 2-column layout [terminal | scrollable channel review card with checkboxes + editable channel numbers]; selective deploy via `/pipeline/deploy-selective`
 5. **Fetch Images** — skippable step; runs `fetch_images.py --apply`
 6. **Sync Plex** — skippable step; runs `sync_plex.py`; post-deploy stats + links to Tunarr and Plex Live TV
 
-**No-AI Path (6 steps):** Same as AI but step 2 runs `generate_no_ai.py` instead of LLM handoff.
+**No-AI Path (6 steps):** Same as AI but step 2 runs `generate_no_ai.py` instead of LLM handoff. Step 1 (Export) has the same library picker.
 
 **Collections Path (4 steps):** Collections → Deploy → Fetch Images → Sync Plex (no export or LLM).
 

README.md

@@ -147,6 +147,7 @@ All three paths end with a probe (dry run) → deploy to Tunarr. The app streams
 
 ### Also included
 
+- **Library picker** — choose which Plex libraries to scan (Movies, 4K Movies, Kids TV, etc.) before each export; supports mixing multiple libraries of the same type
 - **Channel logo fetching** — pulls TMDB clearlogos for single-show/movie channels
 - **Plex DVR sync** — maps new channels into the Plex Live TV guide automatically
 - **Channel editor** — edit names, numbers, shuffle mode, and content lists in the browser

backend/routers/pipeline_router.py

@@ -93,10 +93,38 @@ def _sse(gen: AsyncGenerator[str, None]) -> StreamingResponse:
 
 class ExportOptions(BaseModel):
     no_crossref: bool = False
+    movie_sections: Optional[list[str]] = None  # None = auto-detect; [] = skip type entirely
+    tv_sections: Optional[list[str]] = None
+
+
+@router.get("/pipeline/libraries")
+def list_libraries():
+    cfg = _load_config()
+    plex_url = cfg.get("plex_url", "").rstrip("/")
+    plex_token = cfg.get("plex_token", "")
+    if not plex_url or not plex_token:
+        raise HTTPException(400, "Plex not configured")
+    try:
+        data = _plex_get(plex_url, plex_token, "/library/sections")
+        sections = data["MediaContainer"].get("Directory", [])
+    except Exception as e:
+        raise HTTPException(502, f"Could not reach Plex: {e}")
+    return [
+        {"key": s["key"], "title": s["title"], "type": s["type"]}
+        for s in sections
+        if s.get("type") in ("movie", "show")
+    ]
+
 
 @router.post("/pipeline/export")
 async def run_export(opts: ExportOptions = ExportOptions()):
-    args = ["--no-crossref"] if opts.no_crossref else []
+    args = []
+    if opts.no_crossref:
+        args.append("--no-crossref")
+    if opts.movie_sections is not None:
+        args += ["--movie-sections", ",".join(opts.movie_sections)]
+    if opts.tv_sections is not None:
+        args += ["--tv-sections", ",".join(opts.tv_sections)]
     return _sse(_stream("export.py", args, "export"))
 
 

export.py

@@ -163,6 +163,8 @@ def main():
     parser = argparse.ArgumentParser(description="Export Plex library to CSV")
     parser.add_argument("--out", default=OUTPUT_FILE, help="Output CSV path")
     parser.add_argument("--no-crossref", action="store_true", help="Skip Tunarr sync check")
+    parser.add_argument("--movie-sections", default=None, help="Comma-separated section keys for movies (auto-detect if omitted, empty string = skip)")
+    parser.add_argument("--tv-sections", default=None, help="Comma-separated section keys for TV shows (auto-detect if omitted, empty string = skip)")
     args = parser.parse_args()
 
     cfg = load_config()
@@ -177,23 +179,49 @@ def main():
         print("ERROR: Could not reach Plex or no sections found")
         sys.exit(1)
 
-    movie_section = next((s for s in sections if s.get("type") == "movie"), None)
-    tv_section = next((s for s in sections if s.get("type") == "show"), None)
+    if args.movie_sections is not None:
+        keys = {k.strip() for k in args.movie_sections.split(",") if k.strip()}
+        movie_sections = [s for s in sections if s.get("key") in keys and s.get("type") == "movie"]
+    else:
+        first = next((s for s in sections if s.get("type") == "movie"), None)
+        movie_sections = [first] if first else []
 
-    if not movie_section:
-        print("ERROR: No movie library found in Plex")
-        sys.exit(1)
-    if not tv_section:
-        print("ERROR: No TV show library found in Plex")
+    if args.tv_sections is not None:
+        keys = {k.strip() for k in args.tv_sections.split(",") if k.strip()}
+        tv_sections = [s for s in sections if s.get("key") in keys and s.get("type") == "show"]
+    else:
+        first = next((s for s in sections if s.get("type") == "show"), None)
+        tv_sections = [first] if first else []
+
+    if not movie_sections and not tv_sections:
+        print("ERROR: No movie or TV library sections found or selected")
         sys.exit(1)
 
-    print(f"  Movie section: [{movie_section['key']}] {movie_section['title']}")
-    print(f"  TV section:    [{tv_section['key']}] {tv_section['title']}")
+    for s in movie_sections:
+        print(f"  Movie section: [{s['key']}] {s['title']}")
+    for s in tv_sections:
+        print(f"  TV section:    [{s['key']}] {s['title']}")
 
     # ── Fetch Plex content ─────────────────────────────────────────────────────
     print("\n[2/4] Fetching Plex content...")
-    plex_movies = fetch_plex_movies(plex_url, plex_token, movie_section["key"])
-    plex_shows = fetch_plex_shows(plex_url, plex_token, tv_section["key"])
+
+    plex_movies: list = []
+    seen_movie_titles: set = set()
+    for sec in movie_sections:
+        for item in fetch_plex_movies(plex_url, plex_token, sec["key"]):
+            t = item.get("title", "").lower().strip()
+            if t not in seen_movie_titles:
+                seen_movie_titles.add(t)
+                plex_movies.append(item)
+
+    plex_shows: list = []
+    seen_show_titles: set = set()
+    for sec in tv_sections:
+        for item in fetch_plex_shows(plex_url, plex_token, sec["key"]):
+            t = item.get("title", "").lower().strip()
+            if t not in seen_show_titles:
+                seen_show_titles.add(t)
+                plex_shows.append(item)
 
     # ── Cross-reference with Tunarr ────────────────────────────────────────────
     tunarr_movies = None

frontend/src/api/client.ts

@@ -52,6 +52,7 @@ export const api = {
   getLogs: () => req<LogEntry[]>('/logs'),
   getLog: (name: string) => req<{ name: string; content: string }>(`/logs/${name}`),
 
+  getLibraries: () => req<PlexLibrary[]>('/pipeline/libraries'),
   getCollections: () => req<PlexCollection[]>('/pipeline/collections'),
   applyCollections: (selections: CollectionSelection[]) =>
     req<{ ok: boolean; added: number }>('/pipeline/collections/apply', {
@@ -83,6 +84,7 @@ export interface CsvInfo {
   skipped_shows?: number;
 }
 export interface ValidateResult { ok: boolean; count?: number; error?: string; channels?: Channel[] }
+export interface PlexLibrary { key: string; title: string; type: 'movie' | 'show' }
 export interface PlexCollection { id: string; name: string; count: number; section: string; summary: string; has_poster: boolean }
 export interface CollectionSelection { name: string; channel_number: number; include: boolean }
 export interface LogEntry { name: string; size: number; modified: number }

frontend/src/pages/Run.tsx

@@ -10,7 +10,7 @@ import {
   IconExternalLink, IconPlayerPlay, IconUpload, IconX,
 } from '@tabler/icons-react';
 import { useEffect, useState } from 'react';
-import { api, streamPipeline, StreamEvent, PlexCollection, CollectionSelection } from '../api/client';
+import { api, streamPipeline, StreamEvent, PlexCollection, PlexLibrary, CollectionSelection } from '../api/client';
 import type { Channel } from '../api/client';
 import TerminalOutput from '../components/TerminalOutput';
 
@@ -63,19 +63,40 @@ function parseRunStats(lines: string[]) {
 // ── Step: Export ───────────────────────────────────────────────────────────────
 
 function ExportStep({ onDone }: { onDone: () => void }) {
+  const [libraries, setLibraries] = useState<PlexLibrary[]>([]);
+  const [libSels, setLibSels] = useState<Record<string, boolean>>({});
+  const [libLoading, setLibLoading] = useState(true);
+  const [libError, setLibError] = useState<string | null>(null);
+
   const [lines, setLines] = useState<string[]>([]);
   const [running, setRunning] = useState(false);
   const [done, setDone] = useState(false);
   const [success, setSuccess] = useState(false);
   const [summary, setSummary] = useState<Awaited<ReturnType<typeof api.getCsvInfo>> | null>(null);
   const [noCrossref, setNoCrossref] = useState(false);
 
+  useEffect(() => {
+    api.getLibraries()
+      .then(libs => {
+        setLibraries(libs);
+        setLibSels(Object.fromEntries(libs.map(l => [l.key, true])));
+      })
+      .catch(err => setLibError(err.message))
+      .finally(() => setLibLoading(false));
+  }, []);
+
+  const movieLibs = libraries.filter(l => l.type === 'movie');
+  const tvLibs = libraries.filter(l => l.type === 'show');
+  const selectedCount = Object.values(libSels).filter(Boolean).length;
+
   async function run() {
+    const movieSections = movieLibs.filter(l => libSels[l.key]).map(l => l.key);
+    const tvSections = tvLibs.filter(l => libSels[l.key]).map(l => l.key);
     setLines([]); setDone(false); setSummary(null); setRunning(true);
     try {
       const code = await streamPipeline('/pipeline/export', {}, (ev: StreamEvent) => {
         if (ev.type === 'line') setLines(l => [...l, ev.text]);
-      }, noCrossref ? { no_crossref: true } : undefined);
+      }, { no_crossref: noCrossref, movie_sections: movieSections, tv_sections: tvSections });
       const ok = code === 0;
       setSuccess(ok); setDone(true);
       if (ok) setSummary(await api.getCsvInfo());
@@ -91,8 +112,64 @@ function ExportStep({ onDone }: { onDone: () => void }) {
 
   return (
     <Stack gap="md">
+      {/* Library picker */}
+      <Card withBorder p="md">
+        <Text fw={700} mb="sm">Libraries to scan</Text>
+        {libLoading && (
+          <Group gap="sm">
+            <Loader size="xs" color="orange" />
+            <Text size="sm" c="dimmed">Fetching Plex libraries…</Text>
+          </Group>
+        )}
+        {!libLoading && libError && (
+          <Alert color="yellow" variant="light" icon={<IconAlertCircle size={16} />}>
+            Could not load libraries — export will auto-detect: {libError}
+          </Alert>
+        )}
+        {!libLoading && !libError && libraries.length > 0 && (
+          <SimpleGrid cols={{ base: 1, sm: 2 }} spacing="xs">
+            {movieLibs.length > 0 && (
+              <Stack gap={6}>
+                <Text size="xs" fw={600} c="dimmed" tt="uppercase">Movies</Text>
+                {movieLibs.map(lib => (
+                  <Checkbox
+                    key={lib.key}
+                    label={lib.title}
+                    checked={libSels[lib.key] ?? true}
+                    onChange={(e) => { const v = e.currentTarget.checked; setLibSels(s => ({ ...s, [lib.key]: v })); }}
+                    size="sm"
+                    disabled={running}
+                  />
+                ))}
+              </Stack>
+            )}
+            {tvLibs.length > 0 && (
+              <Stack gap={6}>
+                <Text size="xs" fw={600} c="dimmed" tt="uppercase">TV Shows</Text>
+                {tvLibs.map(lib => (
+                  <Checkbox
+                    key={lib.key}
+                    label={lib.title}
+                    checked={libSels[lib.key] ?? true}
+                    onChange={(e) => { const v = e.currentTarget.checked; setLibSels(s => ({ ...s, [lib.key]: v })); }}
+                    size="sm"
+                    disabled={running}
+                  />
+                ))}
+              </Stack>
+            )}
+          </SimpleGrid>
+        )}
+      </Card>
+
       <Group align="center">
-        <Button leftSection={<IconPlayerPlay size={15} />} color="orange" onClick={run} loading={running}>
+        <Button
+          leftSection={<IconPlayerPlay size={15} />}
+          color="orange"
+          onClick={run}
+          loading={running}
+          disabled={!libLoading && !libError && selectedCount === 0}
+        >
           {running ? 'Exporting…' : done ? 'Re-run Export' : 'Run Export'}
         </Button>
         {done && !success && <Button variant="subtle" color="red" onClick={run}>Retry</Button>}