kryten-webqueue 0.8.2__tar.gz → 0.9.0__tar.gz

{kryten_webqueue-0.8.2 → kryten_webqueue-0.9.0}/CHANGELOG.md

@@ -4,6 +4,32 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+## [0.9.0] — 2026-06-09
+
+### Added
+
+- **Reimplemented content jobs (vendored).** Five tools are vendored into `kryten_webqueue/integrations/` and driven in-process as parameterized jobs, replacing the Windows-script workflow:
+  - `enrichtitles`, `enrichmeta`, `enrichtv` — clean titles / enrich movie & TV metadata via TMDb/OMDb, pushing to MediaCMS. Params: `dry_run`, `limit`, `days` (+ tool-specific `tubi_upgrade`, `min_score`, `min_duration`, `max_duration`, `delay`).
+  - `fetch` — download a yt-dlp-supported URL (single or playlist) to MediaCMS with `quality` (`best`/`good`/`medium`) and an optional **Add to playlist** that appends the uploaded item(s) to a saved playlist.
+  - `fetchurls` — read the upcoming **weekend's** Channel Z workbook from a local `.xlsx` (file-only, no SharePoint/Graph in v1), resolve off-site URLs via the in-process downloader, and import each section as a saved playlist named `{sheet}-{section}` (idempotent re-runs replace items). The target sheet is always the imminent Fri/Sat (Friday → today; Sat/Sun → next Friday).
+  Each blocking tool runs off the event loop via `asyncio.to_thread`, bridging progress back to the `job_runs` row. Jobs whose optional dependencies are missing register normally but fail the run fast with a clear "dependency not installed" message. New optional extra `jobs` (`yt-dlp`, `openpyxl`, `requests`, `pyyaml`); `fetch` additionally needs `ffmpeg` on the host. New config: `fetch_cookies_path`, `fetchurls.workbook_path`.
+- **Parameterized background jobs.** The job framework now supports declarative parameter schemas: `JobManager.register(name, func, *, label, schema)` and `run(name, *, triggered_by, params)`. Job functions receive `(params, ctx)` where `ctx` exposes `db`, `api_gate`, `config`, `triggered_by`, and an async `progress(detail)` callback that writes live progress to the run's `job_runs` row. Submitted params are validated/coerced against the schema (required, defaults, `string`/`int`/`float`/`bool`/`enum`/`playlist` types) and persisted to the new `job_runs.params` column. The admin **Run** button opens a schema-driven modal for jobs that declare parameters (and runs immediately for those that don't); each job also shows a last-run summary. New endpoint `GET /admin/jobs/{name}/schema`; `GET /admin/jobs` now includes each job's `schema` + `last_run`; `POST /admin/jobs/{name}/run` accepts a JSON `{params}` body (400 on invalid params).
+- **Browse sort control.** Browse and search now offer a *Sort by* dropdown — `Default` (quality-weighted), `Title A–Z`, `Title Z–A`, `Newest first`, `Oldest first` — available to everyone. The choice carries through pagination and the facet form and is remembered per-browser via `localStorage`. `Newest`/`Oldest` order by the catalog `added_at`, which is now populated from the MediaCMS `add_date` on sync (and backfilled from `synced_at` for existing rows).
+- **Branded placeholder art with hover-to-thumbnail.** Tiles without a real poster match (no TMDB/OMDB art) now show a random branded placeholder from `placeholder_dir` instead of the raw MediaCMS thumbnail; hovering reveals the real thumbnail via a CSS crossfade. The placeholder list is cached in memory and rescanned periodically.
+- **Admin tile actions.** Catalog tiles now offer admins (rank ≥ 3) *Add to playlist* (picker modal), *+ Recent* (append to the admin's most recently created playlist, no modal), and *Hide* (tags the item `kryten-hidden` in MediaCMS and hides it locally immediately). New endpoints: `POST /admin/playlists/{id}/append`, `POST /admin/playlists/recent/append`, `POST /admin/catalog/{token}/hide`, and `POST /admin/catalog/{token}/unhide`.
+
+### Changed
+
+- **Tile action buttons stack vertically**, full-width, for clearer affordance at narrow tile widths.
+
+### Fixed
+
+- **Job-run history no longer shows phantom `running` rows.** A job's running flag lived only in memory, so a restart or killed worker mid-run left the `job_runs` row stuck at `running` forever. On startup such orphans are now reconciled to a new `interrupted` status (styled in the admin dashboard).
+
+### Removed
+
+- **Live queue page no longer shows the order number or a drag handle.** The `qi-pos` index and the non-functional `qi-drag` (☰) affordance were removed; reordering lives in the playlist editor, not the live queue.
+
 ## [0.8.2] - 2026-06-08
 
 ### Fixed

{kryten_webqueue-0.8.2 → kryten_webqueue-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kryten-webqueue
-Version: 0.8.2
+Version: 0.9.0
 Summary: Netflix/Tubi-style catalog browser and pay-to-play queue management for CyTube
 Author: grobertson
 License-Expression: MIT
@@ -23,6 +23,11 @@ Requires-Dist: mypy>=1.10; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
 Requires-Dist: pytest>=8.0; extra == 'dev'
 Requires-Dist: ruff>=0.4; extra == 'dev'
+Provides-Extra: jobs
+Requires-Dist: openpyxl>=3.1; extra == 'jobs'
+Requires-Dist: pyyaml>=6.0; extra == 'jobs'
+Requires-Dist: requests>=2.31; extra == 'jobs'
+Requires-Dist: yt-dlp>=2024.1; extra == 'jobs'
 Description-Content-Type: text/markdown
 
 # kryten-webqueue

{kryten_webqueue-0.8.2 → kryten_webqueue-0.9.0}/config.example.json

@@ -14,6 +14,11 @@
   "tmdb_api_key": "",
   "omdb_api_key": "",
 
+  "fetch_cookies_path": "",
+  "fetchurls": {
+    "workbook_path": ""
+  },
+
   "db_path": "/var/lib/kryten-webqueue/webqueue.db",
 
   "image_dir": "/var/lib/kryten-webqueue/images",

{kryten_webqueue-0.8.2 → kryten_webqueue-0.9.0}/kryten_webqueue/app.py

@@ -28,6 +28,7 @@ from .routes.admin_playlists import router as admin_playlists_router
 from .routes.admin_schedules import router as admin_schedules_router
 from .routes.admin_queue import router as admin_queue_router
 from .routes.admin_jobs import router as admin_jobs_router
+from .routes.admin_catalog import router as admin_catalog_router
 from .routes.pages import router as pages_router
 from .ws.handler import router as ws_router
 
@@ -42,6 +43,11 @@ async def lifespan(app: FastAPI):
     db = Database(config.db_path)
     await db.connect()
     await db.run_migrations()
+    # Any job run still marked 'running' is an orphan from a prior crash/restart
+    # (the running flag is in-memory only). Reconcile before registering jobs.
+    orphaned = await db.reconcile_orphaned_job_runs()
+    if orphaned:
+        logger.warning("Reconciled %d orphaned job run(s) to 'interrupted'", orphaned)
     app.state.db = db
 
     # API Gate client
@@ -67,12 +73,38 @@ async def lifespan(app: FastAPI):
     app.state.catalog_sync = catalog_sync
 
     # Generic background job runner (records run history to job_runs)
-    job_manager = JobManager(db)
+    job_manager = JobManager(db, api_gate=api_gate, config=config)
+
+    async def _catalog_sync_job(params, ctx):
+        # catalog_sync registers with no schema; params/ctx are ignored. The
+        # adapter keeps the zero-arg sync compatible with the params/ctx job API.
+        return await catalog_sync.sync()
+
     job_manager.register(
         "catalog_sync",
-        catalog_sync.sync,
+        _catalog_sync_job,
         label="Catalog Sync",
     )
+
+    # Reimplemented cmsutils enrichment jobs (vendored, run off-loop). These
+    # register regardless of optional deps; a missing dep fails the run fast
+    # with a clear message rather than crashing startup.
+    from .jobs.tasks import (
+        enrichtitles_job, enrichmeta_job, enrichtv_job,
+        fetch_job, fetchurls_job,
+        ENRICHTITLES_SCHEMA, ENRICHMETA_SCHEMA, ENRICHTV_SCHEMA,
+        FETCH_SCHEMA, FETCHURLS_SCHEMA,
+    )
+    job_manager.register("enrichtitles", enrichtitles_job,
+                         label="Enrich Titles", schema=ENRICHTITLES_SCHEMA)
+    job_manager.register("enrichmeta", enrichmeta_job,
+                         label="Enrich Movie Metadata", schema=ENRICHMETA_SCHEMA)
+    job_manager.register("enrichtv", enrichtv_job,
+                         label="Enrich TV Metadata", schema=ENRICHTV_SCHEMA)
+    job_manager.register("fetch", fetch_job,
+                         label="Fetch (download → MediaCMS)", schema=FETCH_SCHEMA)
+    job_manager.register("fetchurls", fetchurls_job,
+                         label="Fetch URLs (weekend workbook)", schema=FETCHURLS_SCHEMA)
     app.state.job_manager = job_manager
 
     # WebSocket manager
@@ -184,6 +216,7 @@ def create_app(config: Config) -> FastAPI:
     app.include_router(admin_schedules_router)
     app.include_router(admin_queue_router)
     app.include_router(admin_jobs_router)
+    app.include_router(admin_catalog_router)
     app.include_router(ws_router)
 
     # Health check

{kryten_webqueue-0.8.2 → kryten_webqueue-0.9.0}/kryten_webqueue/catalog/db.py

@@ -27,8 +27,14 @@ HIDDEN_TAG_NAMES = [
     "grindhousetrailer",
     "publicaccess",
     "religioustv",
+    "kryten-hidden",
 ]
 
+# Tag applied by the admin "Hide Item" action. Source of truth is MediaCMS;
+# this is mirrored into the local catalog_tags join so the hidden-tag filter
+# applies immediately (before the next sync confirms it).
+HIDDEN_ITEM_TAG = "kryten-hidden"
+
 
 def _hidden_exclusion(alias: str = "c") -> tuple[str, list]:
     """SQL fragment (+ params) excluding items in hidden categories/tags.
@@ -53,6 +59,29 @@ def _hidden_exclusion(alias: str = "c") -> tuple[str, list]:
     return sql, [*HIDDEN_CATEGORY_NAMES, *HIDDEN_TAG_NAMES]
 
 
+# Default quality-weighted ordering (see browse() for rationale).
+_DEFAULT_ORDER = """
+    ORDER BY
+        (c.cover_art_source IN ('tmdb', 'omdb')) DESC,
+        (CASE WHEN c.title GLOB '[A-Za-z]*' THEN 0 ELSE 1 END) ASC,
+        c.title ASC
+"""
+
+# Map a user-facing sort key to an ORDER BY clause referencing the catalog row
+# under alias ``c``. Unknown keys fall back to the default quality ordering.
+_SORT_CLAUSES = {
+    "default": _DEFAULT_ORDER,
+    "title_asc": " ORDER BY c.title ASC ",
+    "title_desc": " ORDER BY c.title DESC ",
+    "newest": " ORDER BY c.added_at DESC, c.synced_at DESC ",
+    "oldest": " ORDER BY c.added_at ASC, c.synced_at ASC ",
+}
+
+
+def _browse_order_clause(sort: str | None) -> str:
+    return _SORT_CLAUSES.get(sort or "default", _DEFAULT_ORDER)
+
+
 MIGRATIONS = [
     # v1: Migration tracking table
     """
@@ -232,6 +261,16 @@ MIGRATIONS = [
     );
     CREATE INDEX IF NOT EXISTS idx_job_runs_name ON job_runs(job_name, started_at);
     """,
+    # v5: Record the parameters a job run was started with.
+    """
+    ALTER TABLE job_runs ADD COLUMN params TEXT;
+    """,
+    # v6: Stopgap backfill of catalog.added_at (previously never populated on
+    # insert). Lets "Newest first" browse ordering work before the next full
+    # sync overwrites these with the true MediaCMS add_date.
+    """
+    UPDATE catalog SET added_at = synced_at WHERE added_at IS NULL;
+    """,
 ]
 
 
@@ -286,9 +325,9 @@ class Database:
 
     # --- Catalog ---
 
-    async def browse(self, *, category: str | None = None, tag: str | None = None, page: int = 1, per_page: int = 24, show_hidden: bool = False) -> list[dict]:
+    async def browse(self, *, category: str | None = None, tag: str | None = None, page: int = 1, per_page: int = 24, show_hidden: bool = False, sort: str = "default") -> list[dict]:
         query = """
-            SELECT c.friendly_token, c.title, c.duration_sec, c.cover_art_path, c.thumbnail_url, c.manifest_url
+            SELECT c.friendly_token, c.title, c.duration_sec, c.cover_art_path, c.cover_art_source, c.thumbnail_url, c.manifest_url
             FROM catalog c
             WHERE c.friendly_token NOT IN (
                 SELECT spi.media_id FROM saved_playlist_items spi
@@ -331,13 +370,8 @@ class Database:
         #   2. Titles beginning with a letter before number/symbol-prefixed
         #      "02 - Episode" style entries.
         #   3. Finally alphabetical for a stable, predictable tail.
-        query += """
-            ORDER BY
-                (c.cover_art_source IN ('tmdb', 'omdb')) DESC,
-                (CASE WHEN c.title GLOB '[A-Za-z]*' THEN 0 ELSE 1 END) ASC,
-                c.title ASC
-            LIMIT ? OFFSET ?
-        """
+        query += _browse_order_clause(sort)
+        query += " LIMIT ? OFFSET ?"
         params.extend([per_page, (page - 1) * per_page])
         return await self._fetch_all(query, params)
 
@@ -376,9 +410,9 @@ class Database:
         row = await self._fetch_one(query, params)
         return row["cnt"] if row else 0
 
-    async def search(self, query_text: str, *, page: int = 1, per_page: int = 24, show_hidden: bool = False) -> list[dict]:
+    async def search(self, query_text: str, *, page: int = 1, per_page: int = 24, show_hidden: bool = False, sort: str = "default") -> list[dict]:
         sql = """
-            SELECT c.friendly_token, c.title, c.duration_sec, c.cover_art_path, c.thumbnail_url, c.manifest_url,
+            SELECT c.friendly_token, c.title, c.duration_sec, c.cover_art_path, c.cover_art_source, c.thumbnail_url, c.manifest_url,
                    rank AS relevance
             FROM catalog_fts fts
             JOIN catalog c ON c.rowid = fts.rowid
@@ -394,10 +428,10 @@ class Database:
             excl_sql, excl_params = _hidden_exclusion("c")
             sql += excl_sql
             params.extend(excl_params)
-        sql += """
-            ORDER BY rank
-            LIMIT ? OFFSET ?
-        """
+        # Relevance is the natural default for a text query; other sort keys let
+        # the user reorder the matched set explicitly.
+        sql += " ORDER BY rank " if (sort or "default") == "default" else _browse_order_clause(sort)
+        sql += " LIMIT ? OFFSET ? "
         params.extend([per_page, (page - 1) * per_page])
         return await self._fetch_all(sql, params)
 
@@ -587,13 +621,32 @@ class Database:
             )
         await self._db.commit()
 
+    async def add_catalog_tag(self, friendly_token: str, tag_name: str):
+        """Add a single tag to a catalog item (idempotent), creating it if new."""
+        tag_id = await self.upsert_tag(tag_name)
+        await self._db.execute(
+            "INSERT OR IGNORE INTO catalog_tags (friendly_token, tag_id) VALUES (?, ?)",
+            [friendly_token, tag_id],
+        )
+        await self._db.commit()
+
+    async def remove_catalog_tag(self, friendly_token: str, tag_name: str):
+        """Remove a single tag from a catalog item (no-op if absent)."""
+        await self._db.execute(
+            "DELETE FROM catalog_tags WHERE friendly_token = ? AND tag_id IN "
+            "(SELECT id FROM tags WHERE name = ?)",
+            [friendly_token, tag_name],
+        )
+        await self._db.commit()
+
     async def insert_catalog(self, row: dict):
         sql = """
             INSERT INTO catalog (friendly_token, title, description, duration_sec,
-                                 manifest_url, thumbnail_url, synced_at)
+                                 manifest_url, thumbnail_url, added_at, synced_at)
             VALUES (:friendly_token, :title, :description, :duration_sec,
-                    :manifest_url, :thumbnail_url, :synced_at)
+                    :manifest_url, :thumbnail_url, :added_at, :synced_at)
         """
+        row = {"added_at": row.get("synced_at"), **row}
         await self._db.execute(sql, row)
         # Update FTS index
         await self._db.execute(
@@ -607,9 +660,12 @@ class Database:
         sql = """
             UPDATE catalog SET title=:title, description=:description,
                    duration_sec=:duration_sec, manifest_url=:manifest_url,
-                   thumbnail_url=:thumbnail_url, synced_at=:synced_at, updated_at=:synced_at
+                   thumbnail_url=:thumbnail_url,
+                   added_at=COALESCE(:added_at, added_at),
+                   synced_at=:synced_at, updated_at=:synced_at
             WHERE friendly_token=:friendly_token
         """
+        row = {"added_at": None, **row}
         await self._db.execute(sql, row)
         # Rebuild FTS for this row
         await self._db.execute(
@@ -651,11 +707,12 @@ class Database:
 
     # --- Generic job runs ---
 
-    async def start_job_run(self, job_name: str, triggered_by: str | None = None) -> int:
+    async def start_job_run(self, job_name: str, triggered_by: str | None = None,
+                            params: str | None = None) -> int:
         cursor = await self._db.execute(
-            "INSERT INTO job_runs (job_name, started_at, status, triggered_by) "
-            "VALUES (?, ?, 'running', ?)",
-            [job_name, datetime.now(UTC).isoformat(), triggered_by],
+            "INSERT INTO job_runs (job_name, started_at, status, triggered_by, params) "
+            "VALUES (?, ?, 'running', ?, ?)",
+            [job_name, datetime.now(UTC).isoformat(), triggered_by, params],
         )
         await self._db.commit()
         return cursor.lastrowid
@@ -666,6 +723,12 @@ class Database:
             [datetime.now(UTC).isoformat(), status, detail, run_id],
         )
 
+    async def update_job_run_detail(self, run_id: int, detail: str | None):
+        """Update only a running job's detail column (used for live progress)."""
+        await self._execute(
+            "UPDATE job_runs SET detail=? WHERE id=?", [detail, run_id]
+        )
+
     async def get_job_runs(self, job_name: str | None = None, limit: int = 10) -> list[dict]:
         if job_name:
             return await self._fetch_all(
@@ -676,6 +739,22 @@ class Database:
             "SELECT * FROM job_runs ORDER BY id DESC LIMIT ?", [limit]
         )
 
+    async def reconcile_orphaned_job_runs(self) -> int:
+        """Mark any job run still flagged ``running`` as ``interrupted``.
+
+        The ``running`` flag lives only in memory on the JobManager, so a
+        service restart (or a killed worker) mid-run leaves the row stuck at
+        ``running`` forever. Called once on startup to clean up such orphans.
+        Returns the number of rows reconciled.
+        """
+        cursor = await self._db.execute(
+            "UPDATE job_runs SET status='interrupted', "
+            "ended_at = COALESCE(ended_at, ?) WHERE status='running'",
+            [datetime.now(UTC).isoformat()],
+        )
+        await self._db.commit()
+        return cursor.rowcount or 0
+
     # --- OTP ---
 
     async def store_otp(self, username: str, code: str, expires_at: str):
@@ -820,6 +899,44 @@ class Database:
             )
         await self._db.commit()
 
+    async def append_playlist_item(self, playlist_id: int, item: dict) -> int:
+        """Append a single item to the end of a playlist. Returns new item count."""
+        row = await self._fetch_one(
+            "SELECT COALESCE(MAX(position), -1) AS pos, COUNT(*) AS cnt "
+            "FROM saved_playlist_items WHERE playlist_id=?",
+            [playlist_id],
+        )
+        next_pos = (row["pos"] + 1) if row else 0
+        count = (row["cnt"] if row else 0) + 1
+        await self._db.execute(
+            "INSERT INTO saved_playlist_items (playlist_id, position, media_type, media_id, title, duration_sec) "
+            "VALUES (?, ?, ?, ?, ?, ?)",
+            [playlist_id, next_pos, item["media_type"], item["media_id"], item.get("title"), item.get("duration_sec")],
+        )
+        await self._db.execute(
+            "UPDATE saved_playlists SET updated_at=datetime('now') WHERE id=?", [playlist_id]
+        )
+        await self._db.commit()
+        return count
+
+    async def get_most_recent_playlist(self, created_by: str) -> dict | None:
+        """The given admin's most recently *created* saved playlist, if any."""
+        return await self._fetch_one(
+            "SELECT * FROM saved_playlists WHERE created_by=? ORDER BY created_at DESC, id DESC LIMIT 1",
+            [created_by],
+        )
+
+    async def get_playlist_by_name(self, name: str, created_by: str) -> dict | None:
+        """Match an existing saved playlist by exact name + creator.
+
+        Used for idempotent re-imports (e.g. the fetchurls job replacing a
+        section playlist's items rather than creating a duplicate).
+        """
+        return await self._fetch_one(
+            "SELECT * FROM saved_playlists WHERE name=? AND created_by=? ORDER BY id LIMIT 1",
+            [name, created_by],
+        )
+
     # --- Schedules ---
 
     async def get_schedules(self) -> list[dict]:

{kryten_webqueue-0.8.2 → kryten_webqueue-0.9.0}/kryten_webqueue/catalog/images.py

@@ -40,10 +40,47 @@ class CoverArtResolver:
         self._client = httpx.AsyncClient(timeout=15.0)
         self._image_dir.mkdir(parents=True, exist_ok=True)
         self._placeholder_dir.mkdir(parents=True, exist_ok=True)
+        # Cached list of branded placeholder image URLs (served under /images).
+        self._placeholder_urls: list[str] = []
+        self._placeholder_cache_at: float = 0.0
 
     async def close(self):
         await self._client.aclose()
 
+    def list_placeholder_urls(self, *, ttl: float = 300.0) -> list[str]:
+        """Return web URLs for branded placeholder images, cached in memory.
+
+        The directory is rescanned at most once per ``ttl`` seconds to avoid a
+        disk scan on every browse request. URLs are resolved relative to the
+        ``/images`` static mount when the placeholder dir lives under the image
+        dir (the default layout); otherwise the bare filename is used.
+        """
+        import time
+
+        now = time.monotonic()
+        if self._placeholder_urls and (now - self._placeholder_cache_at) < ttl:
+            return self._placeholder_urls
+
+        exts = {".webp", ".jpg", ".jpeg", ".png", ".gif", ".avif"}
+        try:
+            files = sorted(
+                p.name for p in self._placeholder_dir.iterdir()
+                if p.is_file() and p.suffix.lower() in exts
+            )
+        except OSError:
+            files = []
+
+        try:
+            rel = self._placeholder_dir.resolve().relative_to(self._image_dir.resolve())
+            prefix = "/images/" + rel.as_posix().strip("/") + "/"
+        except ValueError:
+            prefix = "/images/placeholders/"
+
+        self._placeholder_urls = [prefix + f for f in files]
+        self._placeholder_cache_at = now
+        return self._placeholder_urls
+
+
     async def resolve(self, friendly_token: str, title: str, db) -> str | None:
         """Try to fetch cover art; return relative path or None."""
         # Check if already cached

kryten_webqueue-0.9.0/kryten_webqueue/catalog/mediacms.py

@@ -0,0 +1,112 @@
+"""Minimal MediaCMS edit client for the admin Hide/Unhide action (B6).
+
+This is the Phase 1 standalone helper called for by the spec ("write a minimal
+standalone MediaCMS tag-write helper now and fold it into ``_common.py`` later").
+It performs a read-modify-write of an item's tags so existing tags are
+preserved, using the same edit path the enrich tools use:
+
+    PUT /api/v1/media/{friendly_token}   (form field ``tags``)
+
+MediaCMS has a known quirk where a PUT silently reassigns the owner to whoever
+holds the API token, so we restore the original owner afterwards via
+``/api/v1/media/user/bulk_actions``.
+
+NOTE: the exact tag field/verb should be confirmed against the live instance
+(see spec OQ-6 / residual risks). The local catalog mirror is updated
+independently by the caller, so the admin UI hides items immediately even if
+this remote write needs adjustment.
+"""
+
+import logging
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+_TIMEOUT = 30.0
+
+
+def _normalize_base(mediacms_url: str) -> str:
+    url = (mediacms_url or "").rstrip("/")
+    for suffix in ("/api/v1", "/api"):
+        if url.endswith(suffix):
+            url = url[: -len(suffix)]
+            break
+    return url
+
+
+class MediaCMSClient:
+    """Tiny async wrapper for the MediaCMS media-edit endpoints."""
+
+    def __init__(self, *, mediacms_url: str, token: str):
+        self._base = _normalize_base(mediacms_url)
+        self._headers = {"Authorization": f"Token {token}"}
+
+    async def _get_media(self, client: httpx.AsyncClient, friendly_token: str) -> dict | None:
+        resp = await client.get(f"{self._base}/api/v1/media/{friendly_token}")
+        if resp.status_code != 200:
+            logger.warning(
+                "MediaCMS GET media %s failed: HTTP %s", friendly_token, resp.status_code
+            )
+            return None
+        return resp.json()
+
+    @staticmethod
+    def _current_tags(media: dict) -> list[str]:
+        tags: list[str] = []
+        for t in (media.get("tags_info") or []):
+            name = t.get("title") if isinstance(t, dict) else t
+            if name:
+                tags.append(str(name))
+        # Fall back to a flat ``tags`` list if present.
+        if not tags:
+            for t in (media.get("tags") or []):
+                if t:
+                    tags.append(str(t))
+        return tags
+
+    async def _restore_owner(self, client: httpx.AsyncClient, friendly_token: str, owner: str | None):
+        if not owner:
+            return
+        try:
+            await client.post(
+                f"{self._base}/api/v1/media/user/bulk_actions",
+                json={"action": "change_owner", "media_ids": [friendly_token], "owner": owner},
+            )
+        except httpx.HTTPError:
+            pass  # best-effort; never fail the hide over ownership restoration
+
+    async def set_tag(self, friendly_token: str, tag: str, *, present: bool) -> bool:
+        """Add or remove ``tag`` on an item, preserving existing tags.
+
+        Returns True if the remote write reported success.
+        """
+        async with httpx.AsyncClient(headers=self._headers, timeout=_TIMEOUT) as client:
+            media = await self._get_media(client, friendly_token)
+            if media is None:
+                return False
+
+            current = self._current_tags(media)
+            has = tag in current
+            if present and has:
+                return True
+            if not present and not has:
+                return True
+
+            new_tags = [t for t in current if t != tag]
+            if present:
+                new_tags.append(tag)
+
+            owner = media.get("user")
+            resp = await client.put(
+                f"{self._base}/api/v1/media/{friendly_token}",
+                data={"tags": ",".join(new_tags)},
+            )
+            ok = resp.status_code in (200, 201)
+            if not ok:
+                logger.warning(
+                    "MediaCMS tag write for %s failed: HTTP %s — %s",
+                    friendly_token, resp.status_code, resp.text[:200],
+                )
+            await self._restore_owner(client, friendly_token, owner)
+            return ok

{kryten_webqueue-0.8.2 → kryten_webqueue-0.9.0}/kryten_webqueue/catalog/sync.py

@@ -118,6 +118,9 @@ class CatalogSync:
             "duration_sec": media.get("duration") or 0,
             "manifest_url": self._build_manifest_url(media),
             "thumbnail_url": media.get("thumbnail_url", ""),
+            # True MediaCMS publish time so "Newest first" browse ordering is
+            # accurate; falls back to now when the field is absent.
+            "added_at": media.get("add_date") or now,
             "synced_at": now,
         }
 

{kryten_webqueue-0.8.2 → kryten_webqueue-0.9.0}/kryten_webqueue/config.py

@@ -3,6 +3,12 @@ from pydantic import BaseModel
 import json
 
 
+class FetchUrlsConfig(BaseModel):
+    """Settings for the fetchurls job (v1 = local file only, OQ-1)."""
+
+    workbook_path: str = ""  # absolute path to a synced Channel Z Playlist .xlsx
+
+
 class Config(BaseModel):
     """Application configuration loaded from JSON file."""
 
@@ -25,6 +31,10 @@ class Config(BaseModel):
     tmdb_api_key: str = ""
     omdb_api_key: str = ""
 
+    # Jobs (optional; jobs whose config/deps are absent fail fast at run time)
+    fetch_cookies_path: str = ""          # optional yt-dlp cookies for gated sources
+    fetchurls: FetchUrlsConfig = FetchUrlsConfig()
+
     # Database
     db_path: str = "/var/lib/kryten-webqueue/webqueue.db"
 

kryten_webqueue-0.9.0/kryten_webqueue/integrations/__init__.py

@@ -0,0 +1,8 @@
+"""Vendored third-party tooling adapted for in-process use by webqueue jobs.
+
+Subpackages here are copied (and lightly adapted) from external repositories
+so their battle-tested logic can run inside the webqueue service without
+shelling out. Each vendored module carries a header noting its upstream source
+and the date it was vendored; adapters are kept thin so re-vendoring stays
+mechanical.
+"""

kryten_webqueue-0.9.0/kryten_webqueue/integrations/cmsutils/__init__.py

@@ -0,0 +1,7 @@
+"""Vendored from d:\\Devel\\cmsutils (enrichtitles / enrichmeta / enrichtv /
+fetchurls), vendored 2026-06-09. See each module header for its upstream file.
+
+Adapters expose a headless ``run(params, *, config, progress)`` entry point on
+top of the original CLI logic; the original ``main()``/argparse paths are left
+intact but unused by the service.
+"""

kryten_webqueue-0.9.0/kryten_webqueue/integrations/cmsutils/_common.py

@@ -0,0 +1,15 @@
+"""Shared MediaCMS helpers for the vendored cmsutils tools and the Hide action.
+
+Per the spec (OQ-6), the admin Hide/Unhide tag write should ultimately share
+one MediaCMS edit client with the enrich tools. This module re-exports the
+async ``MediaCMSClient`` (used by the Hide UI) so future refactors can route
+the enrich tools' read-modify-write tag edits through the same place.
+
+The enrich tools (``enrichtitles``/``enrichmeta``/``enrichtv``) currently use
+their own synchronous ``requests``-based update helpers; those remain in their
+respective modules to keep re-vendoring mechanical.
+"""
+
+from ...catalog.mediacms import MediaCMSClient
+
+__all__ = ["MediaCMSClient"]