diff --git a/VERSION b/VERSION index a3df0a6..ac39a10 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -0.8.0 +0.9.0 diff --git a/backend/alembic/versions/0016_video_maintenance.py b/backend/alembic/versions/0016_video_maintenance.py new file mode 100644 index 0000000..7eff8ca --- /dev/null +++ b/backend/alembic/versions/0016_video_maintenance.py @@ -0,0 +1,43 @@ +"""video maintenance / validation columns + +Revision ID: 0016_video_maintenance +Revises: 0015_scheduler_settings +Create Date: 2026-06-18 + +Adds the columns the maintenance/validation job needs to detect and retire unplayable +videos: videos.list?part=status fields (embeddable / privacy_status / upload_status) plus +the validation lifecycle (last_checked_at for rolling re-validation; unavailable_since + +unavailable_reason to flag a video as currently unplayable — hidden from the feed +immediately, hard-deleted after a grace period). Purely additive; all columns nullable. +""" +from typing import Sequence, Union + +import sqlalchemy as sa +from alembic import op + +revision: str = "0016_video_maintenance" +down_revision: Union[str, None] = "0015_scheduler_settings" +branch_labels: Union[str, Sequence[str], None] = None +depends_on: Union[str, Sequence[str], None] = None + + +def upgrade() -> None: + op.add_column("videos", sa.Column("embeddable", sa.Boolean(), nullable=True)) + op.add_column("videos", sa.Column("privacy_status", sa.String(length=16), nullable=True)) + op.add_column("videos", sa.Column("upload_status", sa.String(length=16), nullable=True)) + op.add_column("videos", sa.Column("last_checked_at", sa.DateTime(timezone=True), nullable=True)) + op.add_column("videos", sa.Column("unavailable_since", sa.DateTime(timezone=True), nullable=True)) + op.add_column("videos", sa.Column("unavailable_reason", sa.String(length=24), nullable=True)) + op.create_index("ix_videos_last_checked_at", "videos", ["last_checked_at"]) + op.create_index("ix_videos_unavailable_since", "videos", ["unavailable_since"]) + + +def downgrade() -> None: + op.drop_index("ix_videos_unavailable_since", table_name="videos") + op.drop_index("ix_videos_last_checked_at", table_name="videos") + op.drop_column("videos", "unavailable_reason") + op.drop_column("videos", "unavailable_since") + op.drop_column("videos", "last_checked_at") + op.drop_column("videos", "upload_status") + op.drop_column("videos", "privacy_status") + op.drop_column("videos", "embeddable") diff --git a/backend/alembic/versions/0017_notifications.py b/backend/alembic/versions/0017_notifications.py new file mode 100644 index 0000000..057544e --- /dev/null +++ b/backend/alembic/versions/0017_notifications.py @@ -0,0 +1,59 @@ +"""per-user notification inbox (phase 1) + +Revision ID: 0017_notifications +Revises: 0016_video_maintenance +Create Date: 2026-06-18 + +Adds the durable, server-backed per-user notification table behind the inbox module. The +JSON payload column is named `data` (SQLAlchemy's declarative Base reserves `metadata`). +First producer is the maintenance job's batched "videos removed" notice. Coexists with the +existing client-side transient bell. +""" +from typing import Sequence, Union + +import sqlalchemy as sa +from alembic import op + +revision: str = "0017_notifications" +down_revision: Union[str, None] = "0016_video_maintenance" +branch_labels: Union[str, Sequence[str], None] = None +depends_on: Union[str, Sequence[str], None] = None + + +def upgrade() -> None: + op.create_table( + "notifications", + sa.Column("id", sa.Integer(), primary_key=True), + sa.Column( + "user_id", + sa.Integer(), + sa.ForeignKey("users.id", ondelete="CASCADE"), + nullable=False, + ), + sa.Column("type", sa.String(length=32), nullable=False), + sa.Column("title", sa.String(length=255), nullable=False), + sa.Column("body", sa.Text(), nullable=True), + sa.Column("data", sa.JSON(), nullable=True), + sa.Column("read", sa.Boolean(), nullable=False, server_default="false"), + sa.Column("dismissed", sa.Boolean(), nullable=False, server_default="false"), + sa.Column( + "created_at", sa.DateTime(timezone=True), server_default=sa.func.now() + ), + ) + op.create_index("ix_notifications_user_id", "notifications", ["user_id"]) + op.create_index("ix_notifications_type", "notifications", ["type"]) + op.create_index("ix_notifications_read", "notifications", ["read"]) + op.create_index("ix_notifications_created_at", "notifications", ["created_at"]) + # Fast unread-badge count + inbox listing per user. + op.create_index( + "ix_notifications_user_read", "notifications", ["user_id", "read"] + ) + + +def downgrade() -> None: + op.drop_index("ix_notifications_user_read", table_name="notifications") + op.drop_index("ix_notifications_created_at", table_name="notifications") + op.drop_index("ix_notifications_read", table_name="notifications") + op.drop_index("ix_notifications_type", table_name="notifications") + op.drop_index("ix_notifications_user_id", table_name="notifications") + op.drop_table("notifications") diff --git a/backend/alembic/versions/0018_maintenance_batch_setting.py b/backend/alembic/versions/0018_maintenance_batch_setting.py new file mode 100644 index 0000000..07b9f9e --- /dev/null +++ b/backend/alembic/versions/0018_maintenance_batch_setting.py @@ -0,0 +1,30 @@ +"""admin override for the maintenance re-validation batch size + +Revision ID: 0018_maintenance_batch_setting +Revises: 0017_notifications +Create Date: 2026-06-18 + +Adds app_state.maintenance_revalidate_batch: an admin-tunable override (from the Scheduler +dashboard) for how many videos the maintenance job re-validates per run. NULL = use the +env/config default. Purely additive. +""" +from typing import Sequence, Union + +import sqlalchemy as sa +from alembic import op + +revision: str = "0018_maintenance_batch_setting" +down_revision: Union[str, None] = "0017_notifications" +branch_labels: Union[str, Sequence[str], None] = None +depends_on: Union[str, Sequence[str], None] = None + + +def upgrade() -> None: + op.add_column( + "app_state", + sa.Column("maintenance_revalidate_batch", sa.Integer(), nullable=True), + ) + + +def downgrade() -> None: + op.drop_column("app_state", "maintenance_revalidate_batch") diff --git a/backend/app/config.py b/backend/app/config.py index 52bbd8a..af60b2b 100644 --- a/backend/app/config.py +++ b/backend/app/config.py @@ -90,6 +90,17 @@ class Settings(BaseSettings): autotag_interval_minutes: int = 30 subscriptions_resync_minutes: int = 360 playlist_sync_minutes: int = 360 + # --- Maintenance / validation job --- + # Runs once a day by default (admin-tunable via the Scheduler dashboard). Grace periods + # are in days because that's the granularity that matters; the rolling re-validation + # re-checks the least-recently-checked N videos per run (1 unit / 50 videos), so on a + # ~233k catalog ~15000/day ≈ a 15-day full cycle for ~300 quota units. + maintenance_interval_minutes: int = 1440 + maintenance_revalidate_batch: int = 15000 + # Grace before a flagged-unavailable video is hard-deleted (cascades to states/playlist + # items). Deleted/private/paywalled get a recovery window; abandoned upcoming and + # confirmed-dead stuck-live have no age grace (deleted on the sweep that confirms them). + maintenance_grace_days: int = 7 # live_status values hidden from the feed by default. Completed-stream VODs # ("was_live") are real watchable content and stay visible. feed_default_hidden_live: str = "live,upcoming" diff --git a/backend/app/main.py b/backend/app/main.py index ca0b01d..d134beb 100644 --- a/backend/app/main.py +++ b/backend/app/main.py @@ -32,6 +32,7 @@ from app.routes import ( feed, health, me, + notifications, playlists, quota, scheduler as scheduler_routes, @@ -77,6 +78,7 @@ app.include_router(sync.router) app.include_router(tags.router) app.include_router(feed.router) app.include_router(me.router) +app.include_router(notifications.router) app.include_router(channels.router) app.include_router(playlists.router) app.include_router(admin.router) diff --git a/backend/app/models.py b/backend/app/models.py index f99e8ec..fca20f3 100644 --- a/backend/app/models.py +++ b/backend/app/models.py @@ -203,6 +203,22 @@ class Video(Base): String(16), default="none", server_default="none", index=True ) enriched_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True)) + # videos.list?part=status fields (populated during enrichment); used by the + # maintenance/validation job to decide whether a video is playable anywhere. + embeddable: Mapped[bool | None] = mapped_column(Boolean) + privacy_status: Mapped[str | None] = mapped_column(String(16)) # public|unlisted|private + upload_status: Mapped[str | None] = mapped_column(String(16)) # processed|failed|rejected|deleted + # Maintenance/validation lifecycle. last_checked_at drives the rolling re-validation + # (least-recently-checked first); unavailable_since marks a video as currently + # unplayable (hidden from the feed immediately, hard-deleted after a grace period); + # unavailable_reason records why (deleted|private|paywalled|abandoned|stuck_live). + last_checked_at: Mapped[datetime | None] = mapped_column( + DateTime(timezone=True), index=True + ) + unavailable_since: Mapped[datetime | None] = mapped_column( + DateTime(timezone=True), index=True + ) + unavailable_reason: Mapped[str | None] = mapped_column(String(24)) created_at: Mapped[datetime] = mapped_column( DateTime(timezone=True), server_default=func.now() ) @@ -323,6 +339,9 @@ class AppState(Base): sync_paused: Mapped[bool] = mapped_column( Boolean, default=False, server_default="false" ) + # Admin override for the maintenance job's rolling re-validation batch (videos re-checked + # per run). NULL = use the config/env default (settings.maintenance_revalidate_batch). + maintenance_revalidate_batch: Mapped[int | None] = mapped_column(Integer) class SchedulerSetting(Base): @@ -399,3 +418,36 @@ class PlaylistItem(Base): ) playlist: Mapped["Playlist"] = relationship(back_populates="items") + + +class Notification(Base): + """A durable, server-backed per-user notification (the inbox center, phase 1). + + Distinct from the client-side transient "bell" (toasts kept only in localStorage): + these survive reloads and devices, and are produced server-side (first producer = the + maintenance/validation job's batched "N saved/playlisted videos removed" notice). The + column is named `data` (not `metadata`, which SQLAlchemy's declarative Base reserves): + a free-form JSON payload (e.g. the list of removed videos) the UI can render. `read` + and `dismissed` are separate: read clears the unread badge but keeps the row in the + inbox; dismissed removes it from the default view. Unread rows never auto-expire; read + ones are trimmed past a soft per-user cap (see app.notifications.trim_read).""" + + __tablename__ = "notifications" + + id: Mapped[int] = mapped_column(primary_key=True) + user_id: Mapped[int] = mapped_column( + ForeignKey("users.id", ondelete="CASCADE"), index=True + ) + type: Mapped[str] = mapped_column(String(32), index=True) # e.g. "maintenance" + title: Mapped[str] = mapped_column(String(255)) + body: Mapped[str | None] = mapped_column(Text) + data: Mapped[dict | None] = mapped_column(JSON) + read: Mapped[bool] = mapped_column( + Boolean, default=False, server_default="false", index=True + ) + dismissed: Mapped[bool] = mapped_column( + Boolean, default=False, server_default="false" + ) + created_at: Mapped[datetime] = mapped_column( + DateTime(timezone=True), server_default=func.now(), index=True + ) diff --git a/backend/app/notifications.py b/backend/app/notifications.py new file mode 100644 index 0000000..c4ce120 --- /dev/null +++ b/backend/app/notifications.py @@ -0,0 +1,58 @@ +"""Helpers for the durable, server-backed per-user notification inbox (phase 1). + +The inbox COEXISTS with the client-side transient "bell" (localStorage toasts): these rows +survive reloads/devices and are produced server-side. First producer is the maintenance +job. Unread rows never auto-expire; read rows are trimmed past a soft per-user cap so the +table can't grow without bound for a heavy user. +""" +from sqlalchemy import select +from sqlalchemy.orm import Session + +from app.models import Notification + +# Keep at most this many READ notifications per user; older read ones are pruned. Unread +# rows are never pruned (the user hasn't seen them yet). +READ_SOFT_CAP = 200 + + +def create_notification( + db: Session, + user_id: int, + type: str, + title: str, + body: str | None = None, + data: dict | None = None, + *, + commit: bool = True, +) -> Notification: + """Insert one notification for a user. Callers that batch many inserts in a single + transaction can pass commit=False and commit once themselves.""" + notif = Notification( + user_id=user_id, type=type, title=title, body=body, data=data + ) + db.add(notif) + if commit: + db.commit() + db.refresh(notif) + return notif + + +def trim_read(db: Session, user_id: int, cap: int = READ_SOFT_CAP) -> int: + """Delete a user's oldest READ notifications beyond `cap`. Returns the number removed. + Idempotent and cheap; safe to call after marking things read.""" + ids = ( + db.execute( + select(Notification.id) + .where(Notification.user_id == user_id, Notification.read.is_(True)) + .order_by(Notification.created_at.desc()) + .offset(cap) + ) + .scalars() + .all() + ) + if not ids: + return 0 + for nid in ids: + db.delete(db.get(Notification, nid)) + db.commit() + return len(ids) diff --git a/backend/app/progress.py b/backend/app/progress.py new file mode 100644 index 0000000..79db2f2 --- /dev/null +++ b/backend/app/progress.py @@ -0,0 +1,40 @@ +"""Lightweight, decoupled progress reporting for long-running scheduler jobs. + +A job's work function calls `report(current, total, phase)`; the scheduler binds a sink (via +`bind()`) that forwards it into the in-memory activity the admin dashboard polls. A contextvar +holds the sink, so the sync code stays unaware of the scheduler and concurrent jobs (each in +its own thread/context) never cross wires. When no sink is bound (e.g. a manual sync endpoint), +`report` is a cheap no-op. +""" +import contextvars +from typing import Callable, Optional + +Sink = Callable[[int, Optional[int], Optional[str]], None] + +_sink: contextvars.ContextVar[Optional[Sink]] = contextvars.ContextVar( + "progress_sink", default=None +) + + +def report(current: int, total: int | None = None, phase: str | None = None) -> None: + """Report job progress to the bound sink, if any. `total=None` means indeterminate.""" + sink = _sink.get() + if sink is not None: + sink(current, total, phase) + + +class bind: + """Context manager that binds a progress sink for the duration of a job run.""" + + def __init__(self, sink: Sink): + self._sink = sink + self._token = None + + def __enter__(self) -> "bind": + self._token = _sink.set(self._sink) + return self + + def __exit__(self, *exc) -> bool: + if self._token is not None: + _sink.reset(self._token) + return False diff --git a/backend/app/routes/feed.py b/backend/app/routes/feed.py index 04ef3be..8afa915 100644 --- a/backend/app/routes/feed.py +++ b/backend/app/routes/feed.py @@ -154,6 +154,11 @@ def _filtered_query( state, and_(state.video_id == Video.id, state.user_id == user.id) ) + # Hide videos the maintenance job has flagged as currently unplayable (deleted/private/ + # abandoned). They're either deleted after a grace period or unhidden if they recover; + # either way they shouldn't show in any feed view meanwhile. + query = query.where(Video.unavailable_since.is_(None)) + if channel_id: query = query.where(Video.channel_id == channel_id) if min_duration is not None: diff --git a/backend/app/routes/notifications.py b/backend/app/routes/notifications.py new file mode 100644 index 0000000..224a7f7 --- /dev/null +++ b/backend/app/routes/notifications.py @@ -0,0 +1,136 @@ +"""Per-user notification inbox (phase 1): the durable, server-backed center that coexists +with the client-side transient bell. Read-only listing plus read/dismiss/clear mutations. + +All endpoints use `current_user` (not `require_human`): notifications and their read/dismiss +state are personal UI state with no quota or YouTube involvement, so the shared demo account +manages its own inbox normally.""" +from fastapi import APIRouter, Depends, HTTPException, Query +from sqlalchemy import func, select, update +from sqlalchemy.orm import Session + +from app.auth import current_user +from app.db import get_db +from app.models import Notification, User +from app.notifications import trim_read + +router = APIRouter(prefix="/api/me/notifications", tags=["notifications"]) + + +def _serialize(n: Notification) -> dict: + return { + "id": n.id, + "type": n.type, + "title": n.title, + "body": n.body, + "data": n.data, + "read": n.read, + "dismissed": n.dismissed, + "created_at": n.created_at.isoformat() if n.created_at else None, + } + + +@router.get("") +def list_notifications( + include_dismissed: bool = False, + limit: int = Query(default=100, le=500), + offset: int = 0, + user: User = Depends(current_user), + db: Session = Depends(get_db), +) -> dict: + where = [Notification.user_id == user.id] + if not include_dismissed: + where.append(Notification.dismissed.is_(False)) + total = db.scalar( + select(func.count()).select_from(Notification).where(*where) + ) or 0 + rows = ( + db.execute( + select(Notification) + .where(*where) + .order_by(Notification.created_at.desc()) + .offset(offset) + .limit(limit) + ) + .scalars() + .all() + ) + return {"items": [_serialize(n) for n in rows], "total": total} + + +@router.get("/unread_count") +def unread_count( + user: User = Depends(current_user), db: Session = Depends(get_db) +) -> dict: + """Cheap poll target for the nav badge (uses the (user_id, read) index).""" + count = db.scalar( + select(func.count()) + .select_from(Notification) + .where( + Notification.user_id == user.id, + Notification.read.is_(False), + Notification.dismissed.is_(False), + ) + ) + return {"count": count or 0} + + +def _owned(db: Session, notification_id: int, user: User) -> Notification: + n = db.get(Notification, notification_id) + if n is None or n.user_id != user.id: + raise HTTPException(status_code=404, detail="Notification not found") + return n + + +@router.post("/{notification_id}/read") +def mark_read( + notification_id: int, + user: User = Depends(current_user), + db: Session = Depends(get_db), +) -> dict: + n = _owned(db, notification_id, user) + n.read = True + db.commit() + trim_read(db, user.id) + return {"ok": True} + + +@router.post("/read_all") +def mark_all_read( + user: User = Depends(current_user), db: Session = Depends(get_db) +) -> dict: + db.execute( + update(Notification) + .where(Notification.user_id == user.id, Notification.read.is_(False)) + .values(read=True) + ) + db.commit() + trim_read(db, user.id) + return {"ok": True} + + +@router.post("/{notification_id}/dismiss") +def dismiss( + notification_id: int, + user: User = Depends(current_user), + db: Session = Depends(get_db), +) -> dict: + n = _owned(db, notification_id, user) + # Dismiss implies read (it no longer counts toward the unread badge). + n.dismissed = True + n.read = True + db.commit() + return {"ok": True} + + +@router.post("/clear") +def clear_all( + user: User = Depends(current_user), db: Session = Depends(get_db) +) -> dict: + """Dismiss every (still-visible) notification for this user.""" + db.execute( + update(Notification) + .where(Notification.user_id == user.id, Notification.dismissed.is_(False)) + .values(dismissed=True, read=True) + ) + db.commit() + return {"ok": True} diff --git a/backend/app/routes/scheduler.py b/backend/app/routes/scheduler.py index 11eeeea..66e4f8f 100644 --- a/backend/app/routes/scheduler.py +++ b/backend/app/routes/scheduler.py @@ -10,7 +10,15 @@ from app.config import settings from app.db import get_db from app.models import Channel, Subscription, User, Video from app.routes.admin import admin_user -from app.scheduler import JOB_INTERVALS, MAX_INTERVAL, MIN_INTERVAL, apply_interval, scheduler_snapshot +from app.scheduler import ( + JOB_INTERVALS, + MAX_INTERVAL, + MIN_INTERVAL, + apply_interval, + scheduler_snapshot, + trigger_all, + trigger_job, +) from app.sync.runner import estimate_deep_backfill router = APIRouter(prefix="/api/admin/scheduler", tags=["admin"]) @@ -40,6 +48,52 @@ def set_job_interval( return {"id": job_id, "interval_minutes": applied} +@router.post("/jobs/{job_id}/run") +def run_job_now( + job_id: str, + user: User = Depends(admin_user), +) -> dict: + """Trigger a job to run immediately (in a background thread), independent of its + interval. 409 if it's already running, 404 for an unknown job. On completion the + triggering admin gets an inbox notification with the result.""" + try: + result = trigger_job(job_id, actor_id=user.id) + except KeyError: + raise HTTPException(status_code=404, detail="Unknown job") + if result == "already_running": + raise HTTPException(status_code=409, detail="Job is already running") + return {"id": job_id, "started": True} + + +@router.post("/run-all") +def run_all_now(user: User = Depends(admin_user)) -> dict: + """Trigger every job that isn't already running. Returns the ids actually started.""" + return {"started": trigger_all(actor_id=user.id)} + + +@router.patch("/maintenance") +def set_maintenance_settings( + payload: dict, + _: User = Depends(admin_user), + db: Session = Depends(get_db), +) -> dict: + """Admin-tune the maintenance job's rolling re-validation batch (videos re-checked per + run). Persisted to app_state; the job reads it each run.""" + try: + value = int(payload.get("revalidate_batch")) + except (TypeError, ValueError): + raise HTTPException(status_code=400, detail="revalidate_batch must be a number") + if not (state.MAINTENANCE_BATCH_MIN <= value <= state.MAINTENANCE_BATCH_MAX): + raise HTTPException( + status_code=400, + detail=( + f"revalidate_batch must be between {state.MAINTENANCE_BATCH_MIN} and " + f"{state.MAINTENANCE_BATCH_MAX}" + ), + ) + return {"revalidate_batch": state.set_maintenance_batch(db, value)} + + @router.get("") def get_scheduler( _: User = Depends(admin_user), db: Session = Depends(get_db) @@ -107,4 +161,10 @@ def get_scheduler( "paused": state.is_sync_paused(db), "queue": queue, "quota": quota_info, + "maintenance": { + "revalidate_batch": state.get_maintenance_batch(db), + "revalidate_batch_default": settings.maintenance_revalidate_batch, + "min": state.MAINTENANCE_BATCH_MIN, + "max": state.MAINTENANCE_BATCH_MAX, + }, } diff --git a/backend/app/scheduler.py b/backend/app/scheduler.py index 656db73..7541b0d 100644 --- a/backend/app/scheduler.py +++ b/backend/app/scheduler.py @@ -1,18 +1,22 @@ """Background scheduler: free RSS detection, enrichment of new videos, and quota-aware recent-first / deep backfill. Runs inside the API process (single worker).""" +import contextvars import logging import threading from datetime import datetime, timezone +from typing import Callable from apscheduler.schedulers.background import BackgroundScheduler from sqlalchemy import select -from app import quota +from app import progress, quota from app.config import settings from app.db import SessionLocal from app.models import SchedulerSetting +from app.notifications import create_notification from app.state import is_sync_paused from app.sync.autotag import run_autotag_all +from app.sync.maintenance import run_maintenance from app.sync.playlists import sync_all_playlists from app.sync.runner import ( run_deep_backfill, @@ -34,6 +38,13 @@ _scheduler: BackgroundScheduler | None = None _activity: dict[str, dict] = {} _activity_lock = threading.Lock() +# Set (per-thread) by a manual "run now" trigger to the id of the admin who clicked, so that +# run — and only that run, not the recurring scheduled ones — posts a completion notification +# to their inbox. Unset (None) for scheduled runs. +_manual_actor: contextvars.ContextVar[int | None] = contextvars.ContextVar( + "manual_actor", default=None +) + # Each interval job's env/config default period (minutes). The admin can override any of # these at runtime (stored in scheduler_settings, applied live); see load_intervals. JOB_INTERVALS: dict[str, int] = { @@ -44,6 +55,7 @@ JOB_INTERVALS: dict[str, int] = { "shorts": settings.shorts_probe_interval_minutes, "subscriptions": settings.subscriptions_resync_minutes, "playlist_sync": settings.playlist_sync_minutes, + "maintenance": settings.maintenance_interval_minutes, } # Sane bounds for an admin-set interval (minutes). @@ -88,24 +100,55 @@ def _record(name: str, **fields) -> None: _activity.setdefault(name, {}).update(fields) +def _notify_done(db, actor_id: int, job_id: str, status: str, summary: str | None) -> None: + """Post a completion notice to the triggering admin's inbox (manual runs only). Best + effort — a notification failure must never mask the job's own outcome.""" + try: + create_notification( + db, + user_id=actor_id, + type="scheduler", + title=f"{job_id}: {status}", # English fallback; UI renders translated from data + body=summary, + data={"job_id": job_id, "status": status, "summary": summary}, + ) + except Exception: + db.rollback() + logger.exception("failed to write completion notification for job %s", job_id) + + def _job(name: str, fn) -> None: db = SessionLocal() - _record(name, running=True, last_started=_now_iso(), last_error=None) + actor_id = _manual_actor.get() # set only for a manual "run now" trigger + _record(name, running=True, last_started=_now_iso(), last_error=None, progress=None) + + def sink(current, total, phase): + _record(name, progress={"current": current, "total": total, "phase": phase}) + try: if is_sync_paused(db): logger.info("job %s skipped (sync paused)", name) _record(name, running=False, status="skipped", last_finished=_now_iso(), - last_result="paused") + last_result="paused", progress=None) + if actor_id is not None: + _notify_done(db, actor_id, name, "skipped", "sync paused") return - result = fn(db) + with progress.bind(sink): + result = fn(db) + summary = _summarize(result) logger.info("job %s -> %s", name, result) _record(name, running=False, status="ok", last_finished=_now_iso(), - last_result=_summarize(result)) + last_result=summary, progress=None) + if actor_id is not None: + _notify_done(db, actor_id, name, "ok", summary) except Exception as exc: db.rollback() logger.exception("job %s failed", name) + err = str(exc) or exc.__class__.__name__ _record(name, running=False, status="error", last_finished=_now_iso(), - last_error=str(exc) or exc.__class__.__name__) + last_error=err, progress=None) + if actor_id is not None: + _notify_done(db, actor_id, name, "error", err) finally: db.close() @@ -149,6 +192,7 @@ def scheduler_snapshot() -> dict: "last_finished": a.get("last_finished"), "last_result": a.get("last_result"), "last_error": a.get("last_error"), + "progress": a.get("progress"), } ) return {"running_here": running_here, "enabled": settings.scheduler_enabled, "jobs": jobs} @@ -201,6 +245,66 @@ def _playlist_sync_job() -> None: _job("playlist_sync", sync_all_playlists) +def _maintenance_job() -> None: + def work(db): + with quota.attribute(None, "maintenance"): + return run_maintenance(db) + + _job("maintenance", work) + + +# job_id -> wrapper. The single source of truth for which jobs exist and how to run one, +# shared by start_scheduler (recurring registration) and trigger_job (manual "run now"). +JOB_FUNCS: dict[str, Callable[[], None]] = { + "rss_poll": _rss_job, + "enrich": _enrich_job, + "backfill": _backfill_job, + "autotag": _autotag_job, + "shorts": _shorts_job, + "subscriptions": _subscriptions_job, + "playlist_sync": _playlist_sync_job, + "maintenance": _maintenance_job, +} + + +def _is_running(job_id: str) -> bool: + with _activity_lock: + return bool(_activity.get(job_id, {}).get("running")) + + +def trigger_job(job_id: str, actor_id: int | None = None) -> str: + """Run a job immediately in a background thread, independent of its interval schedule. + The wrapper handles its own DB session, activity tracking and pause-skip, so the live + dashboard reflects the run. Returns "started", "already_running", or raises KeyError for + an unknown job. Refusing a concurrent run keeps a manual trigger from overlapping a + scheduled run (APScheduler enforces max_instances=1 for the scheduled side). + + `actor_id` (the admin who clicked "run now") is stashed in a contextvar inside the new + thread so the run posts a completion notification to that admin's inbox.""" + fn = JOB_FUNCS.get(job_id) + if fn is None: + raise KeyError(job_id) + if _is_running(job_id): + return "already_running" + + def run() -> None: + if actor_id is not None: + _manual_actor.set(actor_id) + fn() + + threading.Thread(target=run, name=f"trigger-{job_id}", daemon=True).start() + return "started" + + +def trigger_all(actor_id: int | None = None) -> list[str]: + """Trigger every job that isn't already running; returns the ids actually started.""" + started = [] + for job_id in JOB_FUNCS: + if trigger_job(job_id, actor_id) == "started": + started.append(job_id) + return started + + def start_scheduler() -> None: global _scheduler if not settings.scheduler_enabled or _scheduler is not None: @@ -211,17 +315,8 @@ def start_scheduler() -> None: iv = load_intervals(db) finally: db.close() - fns = { - "rss_poll": _rss_job, - "enrich": _enrich_job, - "backfill": _backfill_job, - "autotag": _autotag_job, - "shorts": _shorts_job, - "subscriptions": _subscriptions_job, - "playlist_sync": _playlist_sync_job, - } scheduler = BackgroundScheduler(timezone="UTC") - for job_id, fn in fns.items(): + for job_id, fn in JOB_FUNCS.items(): scheduler.add_job(fn, "interval", minutes=iv[job_id], id=job_id) scheduler.start() _scheduler = scheduler diff --git a/backend/app/state.py b/backend/app/state.py index ad85e19..34f56fa 100644 --- a/backend/app/state.py +++ b/backend/app/state.py @@ -3,10 +3,15 @@ import logging from sqlalchemy.orm import Session +from app.config import settings from app.models import AppState log = logging.getLogger("subfeed.state") +# Bounds for the admin-set maintenance re-validation batch (videos re-checked per run). +MAINTENANCE_BATCH_MIN = 100 +MAINTENANCE_BATCH_MAX = 100_000 + def _row(db: Session) -> AppState: row = db.get(AppState, 1) @@ -27,3 +32,20 @@ def set_sync_paused(db: Session, paused: bool) -> None: db.add(row) db.commit() log.info("Background sync %s", "paused" if paused else "resumed") + + +def get_maintenance_batch(db: Session) -> int: + """Effective maintenance re-validation batch: the admin override if set, else the + env/config default.""" + return _row(db).maintenance_revalidate_batch or settings.maintenance_revalidate_batch + + +def set_maintenance_batch(db: Session, value: int) -> int: + """Clamp and persist the maintenance batch override. Returns the applied value.""" + value = max(MAINTENANCE_BATCH_MIN, min(MAINTENANCE_BATCH_MAX, int(value))) + row = _row(db) + row.maintenance_revalidate_batch = value + db.add(row) + db.commit() + log.info("Maintenance re-validation batch set to %s", value) + return value diff --git a/backend/app/sync/maintenance.py b/backend/app/sync/maintenance.py new file mode 100644 index 0000000..47e3569 --- /dev/null +++ b/backend/app/sync/maintenance.py @@ -0,0 +1,249 @@ +"""Maintenance / validation job: detect videos that can't be played anywhere and retire +them safely. + +Lifecycle (no permanent soft-delete state — just a grace timer before a hard delete): + + 1. Re-check flagged videos (those with unavailable_since set). If a video has recovered + (e.g. a private video made public again), clear the flag. Otherwise, if its grace + period has elapsed, HARD DELETE it (cascades to video_states / playlist_items). Before + deleting, gather which users had it saved or in a playlist so we can tell them. + 2. Rolling re-validation: re-fetch the least-recently-checked N currently-available + videos. Newly-unplayable ones get flagged (hidden from the feed immediately via + unavailable_since); the grace timer starts now and they're deleted in a later run if + they don't recover. + +Detection is ~free: a video missing from the videos.list response is deleted-or-private. +We never delete a live broadcast that still reports viewers (a legit 24/7 stream); we only +flag an `upcoming` premiere that blew past its scheduled start and never went live. + +Quota: phase 1 costs ~(flagged / 50) units, phase 2 ~(batch / 50). Both respect the same +backfill reserve as the other jobs so interactive syncs never starve. +""" +import logging +from datetime import datetime, timedelta, timezone + +from sqlalchemy import or_, select +from sqlalchemy.orm import Session + +from app import progress, quota +from app.config import settings +from app.models import Playlist, PlaylistItem, Video, VideoState +from app.notifications import create_notification +from app.state import get_maintenance_batch +from app.sync.runner import get_service_user +from app.sync.videos import apply_video_details, parse_dt +from app.youtube.client import YouTubeClient + +log = logging.getLogger("subfeed.maintenance") + +# Reasons recorded on Video.unavailable_reason. "removed" = absent from videos.list +# (deleted or made private); "abandoned" = an upcoming premiere that never went live. +GRACE_DAYS_BY_REASON = { + "removed": settings.maintenance_grace_days, + "abandoned": 0, # already past-due when detected; deleted on the confirming sweep +} +DEFAULT_GRACE_DAYS = settings.maintenance_grace_days + + +def _now() -> datetime: + return datetime.now(timezone.utc) + + +def _grace_days(reason: str | None) -> int: + return GRACE_DAYS_BY_REASON.get(reason or "", DEFAULT_GRACE_DAYS) + + +def _is_abandoned_upcoming(item: dict) -> bool: + """True for an `upcoming` broadcast whose scheduled start is >2 days past and which + never actually went live (no actualStartTime).""" + snippet = item.get("snippet", {}) + if snippet.get("liveBroadcastContent") != "upcoming": + return False + live = item.get("liveStreamingDetails") or {} + if live.get("actualStartTime"): + return False # it did go live at some point — not abandoned + scheduled = parse_dt(live.get("scheduledStartTime")) + if scheduled is None: + return False + return _now() - scheduled > timedelta(days=2) + + +def _evaluate(video: Video, item: dict | None) -> str | None: + """Given a fresh videos.list item (or None if absent), return an unavailable reason, + or None if the video is fine. Applies fresh metadata as a side effect when present.""" + if item is None: + return "removed" + apply_video_details(video, item) + if _is_abandoned_upcoming(item): + return "abandoned" + # A still-"live" broadcast is kept (a legit 24/7 stream); ended streams have already + # settled to was_live via apply_video_details. Nothing else here is a delete trigger — + # embeddable=false only blocks our in-app embed, not playback on youtube.com. + return None + + +def _collect_user_impact(db: Session, videos: list[Video]) -> dict[int, list[dict]]: + """For videos about to be deleted, map user_id -> list of {id, title, reason} for the + videos that user had saved or in one of their playlists. Must run BEFORE the delete, + while the video_states / playlist_items rows still exist.""" + by_id = {v.id: v for v in videos} + ids = list(by_id) + impact: dict[int, set[str]] = {} + if not ids: + return {} + # Saved (VideoState.status == "saved"). + for user_id, video_id in db.execute( + select(VideoState.user_id, VideoState.video_id).where( + VideoState.video_id.in_(ids), VideoState.status == "saved" + ) + ): + impact.setdefault(user_id, set()).add(video_id) + # In any of the user's playlists (covers watch-later, which is a playlist). + for user_id, video_id in db.execute( + select(Playlist.user_id, PlaylistItem.video_id) + .join(PlaylistItem, PlaylistItem.playlist_id == Playlist.id) + .where(PlaylistItem.video_id.in_(ids)) + ): + impact.setdefault(user_id, set()).add(video_id) + return { + user_id: [ + { + "id": vid, + "title": by_id[vid].title, + "reason": by_id[vid].unavailable_reason, + } + for vid in vids + ] + for user_id, vids in impact.items() + } + + +def _notify_removed(db: Session, impact: dict[int, list[dict]]) -> int: + """One batched notification per affected user (never per-video).""" + for user_id, videos in impact.items(): + n = len(videos) + create_notification( + db, + user_id=user_id, + type="maintenance", + title="Videos removed", + body=( + f"{n} saved or playlisted " + f"{'video was' if n == 1 else 'videos were'} removed because " + "they are no longer available on YouTube." + ), + data={"count": n, "videos": videos}, + commit=False, + ) + db.commit() + return len(impact) + + +def _recheck_flagged(db: Session, yt: YouTubeClient) -> dict: + """Phase 1: recover or hard-delete videos already flagged unavailable.""" + flagged = ( + db.execute(select(Video).where(Video.unavailable_since.is_not(None))) + .scalars() + .all() + ) + if not flagged: + return {"checked": 0, "recovered": 0, "deleted": 0, "notified": 0} + progress.report(0, len(flagged), "recheck") + items = {it["id"]: it for it in yt.get_videos([v.id for v in flagged])} + now = _now() + recovered = 0 + to_delete: list[Video] = [] + for video in flagged: + reason = _evaluate(video, items.get(video.id)) + video.last_checked_at = now + if reason is None: + # Recovered: unhide. + video.unavailable_since = None + video.unavailable_reason = None + recovered += 1 + continue + # Still unavailable; keep the original reason/timer unless it changed. + if reason != video.unavailable_reason: + video.unavailable_reason = reason + deadline = video.unavailable_since + timedelta(days=_grace_days(reason)) + if now >= deadline: + to_delete.append(video) + db.commit() # persist recoveries / reason updates / last_checked_at + + notified = 0 + deleted = 0 + if to_delete: + impact = _collect_user_impact(db, to_delete) + for video in to_delete: + db.delete(video) + db.commit() # cascades to video_states / playlist_items + deleted = len(to_delete) + notified = _notify_removed(db, impact) + return { + "checked": len(flagged), + "recovered": recovered, + "deleted": deleted, + "notified": notified, + } + + +def _revalidate_rolling(db: Session, yt: YouTubeClient) -> dict: + """Phase 2: re-check the least-recently-checked currently-available videos and flag any + that have become unplayable (hidden immediately; deleted later if they don't recover).""" + batch = get_maintenance_batch(db) # admin override, else config default + flagged_new = 0 + checked = 0 + now = _now() + # Process in videos.list-sized pages so we commit incrementally and stop on low quota. + while checked < batch: + if quota.remaining_today(db) <= settings.backfill_quota_reserve: + break + page = ( + db.execute( + select(Video) + .where(Video.unavailable_since.is_(None)) + .order_by( + Video.last_checked_at.is_(None).desc(), # never-checked first + Video.last_checked_at.asc(), + ) + .limit(min(50, batch - checked)) + ) + .scalars() + .all() + ) + if not page: + break + items = {it["id"]: it for it in yt.get_videos([v.id for v in page])} + for video in page: + reason = _evaluate(video, items.get(video.id)) + video.last_checked_at = now + if reason is not None: + video.unavailable_since = now + video.unavailable_reason = reason + flagged_new += 1 + db.commit() + checked += len(page) + progress.report(checked, batch, "revalidate") + return {"checked": checked, "flagged": flagged_new} + + +def run_maintenance(db: Session) -> dict: + """Entry point invoked by the scheduler. Quota-attributed to the system (no actor).""" + user = get_service_user(db) + if user is None: + return {"reason": "no service user"} + with YouTubeClient(db, user) as yt: + phase1 = _recheck_flagged(db, yt) + phase2 = ( + _revalidate_rolling(db, yt) + if quota.remaining_today(db) > settings.backfill_quota_reserve + else {"checked": 0, "flagged": 0, "skipped": "low quota"} + ) + return { + "rechecked": phase1["checked"], + "recovered": phase1["recovered"], + "deleted": phase1["deleted"], + "notified": phase1["notified"], + "revalidated": phase2["checked"], + "flagged": phase2["flagged"], + } diff --git a/backend/app/sync/runner.py b/backend/app/sync/runner.py index 2cdd79b..2a1a239 100644 --- a/backend/app/sync/runner.py +++ b/backend/app/sync/runner.py @@ -9,7 +9,7 @@ import logging from sqlalchemy import select from sqlalchemy.orm import Session -from app import quota +from app import progress, quota from app.config import settings log = logging.getLogger("subfeed.sync") @@ -64,6 +64,7 @@ def run_enrich(db: Session, max_batches: int = 200, floor: int = 200) -> int: break n = enrich_pending(db, yt) total += n + progress.report(total, None, "enrich") # total unknown (drains until empty) if n == 0: break # Revisit transient live/upcoming videos (enrich_pending is one-shot) so an ended @@ -121,6 +122,7 @@ def run_recent_backfill( try: videos_added += backfill_channel_recent(db, yt, channel) processed += 1 + progress.report(processed, len(channels), "backfill_recent") except Exception: db.rollback() log.exception("Recent backfill failed for channel %s", channel.id) @@ -166,6 +168,7 @@ def run_deep_backfill(db: Session, max_channels: int = 10, max_pages: int = 5) - try: videos_added += backfill_channel_deep(db, yt, channel, max_pages) processed += 1 + progress.report(processed, len(channels), "backfill_deep") except Exception: db.rollback() log.exception("Deep backfill failed for channel %s", channel.id) diff --git a/backend/app/sync/videos.py b/backend/app/sync/videos.py index c4f002d..0292390 100644 --- a/backend/app/sync/videos.py +++ b/backend/app/sync/videos.py @@ -9,6 +9,7 @@ from sqlalchemy import and_, func, or_, select, update from sqlalchemy.dialects.postgresql import insert as pg_insert from sqlalchemy.orm import Session +from app import progress from app.config import settings from app.models import Channel, Video from app.youtube.client import YouTubeClient, best_thumbnail @@ -217,6 +218,7 @@ def apply_video_details(video: Video, item: dict) -> None: stats = item.get("statistics", {}) topics = item.get("topicDetails", {}) live = item.get("liveStreamingDetails") + status = item.get("status", {}) video.title = snippet.get("title") or video.title video.description = snippet.get("description") @@ -232,6 +234,11 @@ def apply_video_details(video: Video, item: dict) -> None: "defaultAudioLanguage" ) video.live_status = _live_status(snippet, live) + # status part: used by the maintenance/validation job to judge playability. + if status: + video.embeddable = status.get("embeddable") + video.privacy_status = status.get("privacyStatus") + video.upload_status = status.get("uploadStatus") # is_short is decided separately by the youtube.com/shorts probe (run_shorts_classification). @@ -359,5 +366,6 @@ def run_shorts_classification(db: Session, limit: int | None = None) -> dict: probed += 1 if result: shorts += 1 + progress.report(probed, len(candidates), "probe") db.commit() return {"probed": probed, "shorts": shorts} diff --git a/backend/app/youtube/client.py b/backend/app/youtube/client.py index f0d0da4..c65c333 100644 --- a/backend/app/youtube/client.py +++ b/backend/app/youtube/client.py @@ -327,7 +327,7 @@ class YouTubeClient: data = self._get( "videos", { - "part": "snippet,contentDetails,statistics,topicDetails,liveStreamingDetails", + "part": "snippet,contentDetails,statistics,topicDetails,liveStreamingDetails,status", "id": ",".join(batch), "maxResults": 50, }, diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx index 4bf2686..037cc89 100644 --- a/frontend/src/App.tsx +++ b/frontend/src/App.tsx @@ -10,7 +10,7 @@ import { saveLocalTheme, type ThemePrefs, } from "./lib/theme"; -import { hasFilterParams, paramsToFilters, readPage, stripUrlParams, type Page } from "./lib/urlState"; +import { hasFilterParams, isPage, paramsToFilters, readPage, stripUrlParams, type Page } from "./lib/urlState"; import { loadLayout, normalizeLayout, @@ -29,6 +29,7 @@ import Playlists from "./components/Playlists"; import Stats from "./components/Stats"; import Scheduler from "./components/Scheduler"; import SettingsPanel from "./components/SettingsPanel"; +import NotificationsPanel from "./components/NotificationsPanel"; import OnboardingWizard from "./components/OnboardingWizard"; import { shouldAutoOpenOnboarding } from "./lib/onboarding"; import Toaster from "./components/Toaster"; @@ -60,15 +61,7 @@ function loadInitialPage(): Page { const params = new URLSearchParams(window.location.search); if (params.has("page")) return readPage(); const stored = localStorage.getItem(PAGE_KEY); - if ( - stored === "channels" || - stored === "stats" || - stored === "playlists" || - stored === "settings" || - stored === "scheduler" - ) - return stored; - return "feed"; + return isPage(stored) ? stored : "feed"; } function loadStoredFilters(): FeedFilters { @@ -259,8 +252,6 @@ export default function App() { onOpenAbout={() => setAboutOpen(true)} onChangeLanguage={changeLanguage} language={i18n.language as LangCode} - filters={filters} - setFilters={setFilters} />
) : page === "playlists" ? ( + ) : page === "notifications" ? ( + ) : page === "settings" ? ( onState(id, "new") }, meta: { kind: "video-watched", videoId: id, title: v?.title ?? "this video" }, }); + } else if (status === "new") { + // Unhide / unwatch (from a card, the toast's Undo, or the center): quietly resolve any + // stale hide/watch notice for this video so it doesn't linger with a dead action. + resolveVideo(id); } }, [qc] diff --git a/frontend/src/components/NavSidebar.tsx b/frontend/src/components/NavSidebar.tsx index d9ce0fe..cef12ec 100644 --- a/frontend/src/components/NavSidebar.tsx +++ b/frontend/src/components/NavSidebar.tsx @@ -1,10 +1,11 @@ -import { useEffect, useRef, useState } from "react"; +import { useEffect, useRef, useState, useSyncExternalStore } from "react"; import { createPortal } from "react-dom"; import { useTranslation } from "react-i18next"; import { useQuery } from "@tanstack/react-query"; import { Activity, BarChart3, + Bell, ChevronLeft, ChevronRight, Home, @@ -16,12 +17,13 @@ import { Tv, UserPlus, } from "lucide-react"; -import { api, type FeedFilters, type Me } from "../lib/api"; +import { api, type Me } from "../lib/api"; +import { useLiveQuery } from "../lib/useLiveQuery"; +import { getUnreadCount, subscribe } from "../lib/notifications"; import type { Page } from "../lib/urlState"; import { type LangCode } from "../i18n"; import AvatarImg from "./Avatar"; import LanguageSwitcher from "./LanguageSwitcher"; -import NotificationCenter from "./NotificationCenter"; // Primary app navigation: a collapsible left rail with icon+label entries (Design C). The // modules used to hide under the avatar dropdown; they now live here. Collapsed, it becomes @@ -33,8 +35,6 @@ export default function NavSidebar({ onOpenAbout, onChangeLanguage, language, - filters, - setFilters, }: { me: Me; page: Page; @@ -42,8 +42,6 @@ export default function NavSidebar({ onOpenAbout: () => void; onChangeLanguage: (code: LangCode) => void; language: LangCode; - filters: FeedFilters; - setFilters: (f: FeedFilters) => void; }) { const { t } = useTranslation(); const [collapsed, setCollapsed] = useState( @@ -116,12 +114,25 @@ export default function NavSidebar({ } } - type NavItem = { page: Page; icon: typeof Home; label: string }; + // Durable, server-backed unread count for the inbox badge. Polled live (pauses when the + // tab is hidden); coexists with the client-side transient bell at the bottom of the rail. + const unreadQuery = useLiveQuery( + ["notif-unread"], + api.notificationUnreadCount, + { intervalMs: 30000 } + ); + // One indicator for both layers: durable server notifications + the client-side transient + // events (the former separate bell is now folded into the inbox page). + const clientUnread = useSyncExternalStore(subscribe, getUnreadCount, getUnreadCount); + const unread = (unreadQuery.data?.count ?? 0) + clientUnread; + + type NavItem = { page: Page; icon: typeof Home; label: string; badge?: number }; // User-facing content modules vs. admin/system modules, separated by a divider in the rail. const userItems: NavItem[] = [ { page: "feed", icon: Home, label: t("header.account.feed") }, { page: "channels", icon: Tv, label: t("header.account.channels") }, { page: "playlists", icon: ListVideo, label: t("header.account.playlists") }, + { page: "notifications", icon: Bell, label: t("inbox.navLabel"), badge: unread }, ]; const systemItems: NavItem[] = me.role === "admin" @@ -135,20 +146,47 @@ export default function NavSidebar({ "w-full flex items-center gap-3 rounded-lg px-2.5 py-2 text-sm transition"; const name = me.display_name ?? me.email.split("@")[0]; - const renderItem = ({ page: p, icon: Icon, label }: NavItem) => ( - - ); + const renderItem = ({ page: p, icon: Icon, label, badge }: NavItem) => { + const active = page === p; + // On the active row the background is the accent colour, so a same-accent badge would be + // red-on-red. Invert it there (light pill, accent-coloured number) for clean contrast. + const badgeColor = active ? "bg-accent-fg text-accent" : "bg-accent text-accent-fg"; + const show = !!badge && badge > 0; + return ( + + ); + }; return (
- - {open && - renderPanel( -
-
-
{t("notifications.title")}
- {notifications.length > 0 && ( - - )} -
- -
- {notifications.length === 0 ? ( -
{t("notifications.empty")}
- ) : ( - notifications.map((n) => { - const { icon: Icon, color } = LEVEL_STYLE[n.level]; - const needsAction = n.requiresInteraction && !n.dismissed; - const hidden = n.meta?.kind === "video-hidden" ? n.meta : null; - const watched = n.meta?.kind === "video-watched" ? n.meta : null; - return ( -
- -
- {n.title &&
{n.title}
} -
{n.message}
-
- {relTime(n.ts, t)} - {needsAction && ( - - {t("notifications.actionNeeded")} - - )} -
- - {hidden ? ( -
- - -
- ) : watched ? ( -
- -
- ) : ( - n.action && - !n.dismissed && ( - - ) - )} -
-
- ); - }) - )} -
-
- )} - - ); -} diff --git a/frontend/src/components/NotificationsPanel.tsx b/frontend/src/components/NotificationsPanel.tsx new file mode 100644 index 0000000..1fcadab --- /dev/null +++ b/frontend/src/components/NotificationsPanel.tsx @@ -0,0 +1,371 @@ +import { useEffect, useSyncExternalStore } from "react"; +import { useTranslation } from "react-i18next"; +import { useMutation, useQueryClient } from "@tanstack/react-query"; +import { Bell, Check, CheckCheck, Eye, RotateCcw, Search, Trash2, X } from "lucide-react"; +import { api, type AppNotification, type FeedFilters } from "../lib/api"; +import { useLiveQuery } from "../lib/useLiveQuery"; +import { + clearAll as clearClient, + dismiss as dismissClient, + getNotifications, + getUnreadCount, + markAllRead as markAllClientRead, + remove as removeClient, + resolveVideo, + subscribe, + type Notification as ClientNotif, + type VideoHiddenMeta, + type VideoWatchedMeta, +} from "../lib/notifications"; +import type { Page } from "../lib/urlState"; +import { LEVEL_STYLE } from "./Toaster"; + +// The single notification center. "System" = durable, server-backed notifications (inbox +// phase 1). "Activity" = the client-side transient events (action confirmations, errors, with +// their inline undo/find actions) that used to live behind a separate bell — folded in here so +// there's one indicator and one place to look. Transient toasts still pop via the Toaster. +const POLL_MS = 8000; + +function relativeTime(iso: string | null, t: (k: string, o?: any) => string): string { + if (!iso) return ""; + return relativeFromMs(new Date(iso).getTime(), t); +} + +function relativeFromMs(ms: number, t: (k: string, o?: any) => string): string { + const secs = Math.max(0, Math.round((Date.now() - ms) / 1000)); + // Reuse the bell's relative-time strings (notifications.time.*) — same format, no dupes. + if (secs < 60) return t("notifications.time.justNow"); + const mins = Math.round(secs / 60); + if (mins < 60) return t("notifications.time.minutes", { count: mins }); + const hours = Math.round(mins / 60); + if (hours < 24) return t("notifications.time.hours", { count: hours }); + return t("notifications.time.days", { count: Math.round(hours / 24) }); +} + +export default function NotificationsPanel({ + filters, + setFilters, + setPage, +}: { + filters: FeedFilters; + setFilters: (f: FeedFilters) => void; + setPage: (p: Page) => void; +}) { + const { t } = useTranslation(); + const qc = useQueryClient(); + const q = useLiveQuery<{ items: AppNotification[]; total: number }>( + ["notifications"], + () => api.notifications(), + { intervalMs: POLL_MS } + ); + const serverItems = q.data?.items ?? []; + const clientItems = useSyncExternalStore(subscribe, getNotifications, getNotifications); + const clientUnread = useSyncExternalStore(subscribe, getUnreadCount, getUnreadCount); + + // Opening the center marks the (ephemeral) client items read, matching the old bell. Server + // items stay unread until acted on individually. + useEffect(() => { + markAllClientRead(); + }, []); + + const refresh = () => { + qc.invalidateQueries({ queryKey: ["notifications"] }); + qc.invalidateQueries({ queryKey: ["notif-unread"] }); + }; + const readMut = useMutation({ mutationFn: api.markNotificationRead, onSuccess: refresh }); + const readAllMut = useMutation({ mutationFn: api.markAllNotificationsRead, onSuccess: refresh }); + const dismissMut = useMutation({ mutationFn: api.dismissNotification, onSuccess: refresh }); + const clearMut = useMutation({ mutationFn: api.clearNotifications, onSuccess: refresh }); + + const serverUnread = serverItems.some((n) => !n.read); + const hasAny = serverItems.length > 0 || clientItems.length > 0; + const hasUnread = serverUnread || clientUnread > 0; + + function markAll() { + markAllClientRead(); + if (serverUnread) readAllMut.mutate(); + else refresh(); + } + function clearEverything() { + clearClient(); + clearMut.mutate(); + } + + // "Find in feed" / undo, ported from the old bell. + function locateHidden(meta: VideoHiddenMeta) { + setFilters({ + ...filters, + show: "hidden", + channelId: meta.channelId || undefined, + channelName: meta.channelName || undefined, + }); + setPage("feed"); + } + function revertState(meta: VideoHiddenMeta | VideoWatchedMeta) { + api + .setState(meta.videoId, "new") + .then(() => { + qc.invalidateQueries({ queryKey: ["feed"] }); + qc.invalidateQueries({ queryKey: ["feed-count"] }); + // Quietly resolve the now-stale notice (no confirmation toast — the change is visible). + resolveVideo(meta.videoId); + }) + .catch(() => {}); + } + + return ( +
+
+ +
+
{t("inbox.title")}
+
{t("inbox.subtitle")}
+
+ {hasAny && ( +
+ + +
+ )} +
+ + {q.isLoading && !q.data && clientItems.length === 0 ? ( +
{t("common.loading")}
+ ) : !hasAny ? ( +
+ + {t("inbox.empty")} +
+ ) : ( +
+ {serverItems.length > 0 && ( +
+
+ {t("inbox.sectionSystem")} +
+
+ {serverItems.map((n) => ( + readMut.mutate(n.id)} + onDismiss={() => dismissMut.mutate(n.id)} + /> + ))} +
+
+ )} + {clientItems.length > 0 && ( +
+
+ {t("inbox.sectionActivity")} +
+
+ {clientItems.map((n) => ( + removeClient(n.id)} + /> + ))} +
+
+ )} +
+ )} +
+ ); +} + +function NotificationRow({ + n, + t, + onRead, + onDismiss, +}: { + n: AppNotification; + t: (k: string, o?: any) => string; + onRead: () => void; + onDismiss: () => void; +}) { + // The maintenance producer ships the affected videos in `data.videos`; list a few titles. + const videos: { id: string; title: string | null }[] = Array.isArray(n.data?.videos) + ? n.data!.videos + : []; + // Known notification types are rendered from i18n (so they're trilingual) using the typed + // payload; the server-stored title/body are an English fallback for any unknown type. + const isMaintenance = n.type === "maintenance" && typeof n.data?.count === "number"; + const isScheduler = n.type === "scheduler" && typeof n.data?.job_id === "string"; + let title = n.title; + let body = n.body; + if (isMaintenance) { + title = t("inbox.maintenance.title"); + body = t("inbox.maintenance.body", { count: n.data!.count }); + } else if (isScheduler) { + // " finished/failed", with the raw result summary as the (technical) body. + const job = t(`scheduler.jobs.${n.data!.job_id}`, n.data!.job_id); + title = t( + n.data!.status === "error" ? "inbox.jobDone.titleError" : "inbox.jobDone.titleOk", + { job } + ); + body = n.data!.summary || n.body; + } + return ( +
+ {!n.read && } +
+
+ {title} + + {relativeTime(n.created_at, t)} + +
+ {body &&
{body}
} + {videos.length > 0 && ( +
    + {videos.slice(0, 8).map((v) => ( +
  • + {v.title || v.id} +
    • + ))} + {videos.length > 8 && ( +
  • + {t("inbox.andMore", { count: videos.length - 8 })} +
    • + )} +
+ )} +
+
+ {!n.read && ( + + )} + +
+
+ ); +} + +function ClientActivityRow({ + n, + t, + onFind, + onRevert, + onRemove, +}: { + n: ClientNotif; + t: (k: string, o?: any) => string; + onFind: (meta: VideoHiddenMeta) => void; + onRevert: (meta: VideoHiddenMeta | VideoWatchedMeta) => void; + onRemove: () => void; +}) { + const { icon: Icon, color } = LEVEL_STYLE[n.level]; + const needsAction = n.requiresInteraction && !n.dismissed; + const hidden = n.meta?.kind === "video-hidden" ? n.meta : null; + const watched = n.meta?.kind === "video-watched" ? n.meta : null; + return ( +
+ +
+ {n.title &&
{n.title}
} +
{n.message}
+
+ {relativeFromMs(n.ts, t)} + {needsAction && ( + + {t("notifications.actionNeeded")} + + )} +
+ {hidden ? ( +
+ + +
+ ) : watched ? ( +
+ +
+ ) : ( + + n.action && + !n.dismissed && ( + + ) + )} +
+ +
+ ); +} diff --git a/frontend/src/components/Scheduler.tsx b/frontend/src/components/Scheduler.tsx index 8ac9928..549916e 100644 --- a/frontend/src/components/Scheduler.tsx +++ b/frontend/src/components/Scheduler.tsx @@ -73,14 +73,45 @@ function StatusLegend() { ); } +function JobProgress({ p }: { p: NonNullable }) { + const { t } = useTranslation(); + const phase = p.phase ? t(`scheduler.phase.${p.phase}`, p.phase) : null; + const pct = + p.total && p.total > 0 ? Math.min(100, Math.round((p.current / p.total) * 100)) : null; + return ( +
+
+ {phase} + + {p.total != null + ? `${p.current.toLocaleString()} / ${p.total.toLocaleString()}` + : p.current.toLocaleString()} + +
+
+ {pct != null ? ( +
+ ) : ( + // Indeterminate: total unknown, so a slim moving sliver instead of a fill. +
+ )} +
+
+ ); +} + function JobRow({ job, onSave, saving, + onRun, + runDisabled, }: { job: SchedulerJob; onSave: (minutes: number) => void; saving: boolean; + onRun: () => void; + runDisabled: boolean; }) { const { t } = useTranslation(); const [editing, setEditing] = useState(false); @@ -153,6 +184,7 @@ function JobRow({ · {job.last_result} ) : null}
+ {job.running && job.progress && }
{job.running ? ( @@ -166,6 +198,70 @@ function JobRow({ "—" )}
+ + + + + ); +} + +function MaintenanceSettings({ + m, + onSave, + saving, +}: { + m: SchedulerStatus["maintenance"]; + onSave: (batch: number) => void; + saving: boolean; +}) { + const { t } = useTranslation(); + const [val, setVal] = useState(String(m.revalidate_batch)); + useEffect(() => setVal(String(m.revalidate_batch)), [m.revalidate_batch]); + + function save() { + const n = parseInt(val, 10); + if (Number.isFinite(n) && n >= m.min && n <= m.max && n !== m.revalidate_batch) onSave(n); + } + const dirty = String(m.revalidate_batch) !== val; + + return ( +
+
+ + + + {t("scheduler.maintenance.batchLabel")} + + + + setVal(e.target.value)} + onKeyDown={(e) => e.key === "Enter" && save()} + className="w-28 bg-card border border-border rounded px-2 py-1 text-sm tabular-nums outline-none focus:border-accent" + /> + +
+
+ {t("scheduler.maintenance.batchNote", { default: m.revalidate_batch_default.toLocaleString() })} +
); } @@ -227,6 +323,27 @@ export default function Scheduler() { onError: () => notify({ level: "error", message: t("scheduler.intervalFailed") }), }); + // Manual "run now" triggers. The wrapper runs in a background thread server-side; the + // live poll surfaces the "running" state within a tick, so we just nudge a refetch. + const runMut = useMutation({ + mutationFn: (jobId: string) => api.runSchedulerJob(jobId), + onSuccess: (_d, jobId) => { + notify({ level: "success", message: t("scheduler.triggered", { job: t(`scheduler.jobs.${jobId}`, jobId) }) }); + qc.invalidateQueries({ queryKey: ["scheduler"] }); + }, + }); + const runAllMut = useMutation({ + mutationFn: () => api.runAllSchedulerJobs(), + onSuccess: (res) => { + notify({ level: "success", message: t("scheduler.triggeredAll", { count: res.started.length }) }); + qc.invalidateQueries({ queryKey: ["scheduler"] }); + }, + }); + const batchMut = useMutation({ + mutationFn: (v: number) => api.updateMaintenanceBatch(v), + onSuccess: () => qc.invalidateQueries({ queryKey: ["scheduler"] }), + }); + if (q.isLoading && !data) return
{t("scheduler.loading")}
; if (!data) @@ -260,6 +377,16 @@ export default function Scheduler() {
+ + +
@@ -361,6 +490,16 @@ export default function Scheduler() {
{t("scheduler.quotaNote")}
+ + {/* Maintenance settings */} +
+
{t("scheduler.maintenance.title")}
+ batchMut.mutate(batch)} + saving={batchMut.isPending} + /> +
); } diff --git a/frontend/src/i18n/locales/de/inbox.json b/frontend/src/i18n/locales/de/inbox.json new file mode 100644 index 0000000..734869f --- /dev/null +++ b/frontend/src/i18n/locales/de/inbox.json @@ -0,0 +1,22 @@ +{ + "navLabel": "Benachrichtigungen", + "title": "Benachrichtigungen", + "subtitle": "Neuigkeiten aus deiner Bibliothek und vom System.", + "empty": "Alles erledigt.", + "markAllRead": "Alle als gelesen markieren", + "clearAll": "Alle löschen", + "markRead": "Als gelesen markieren", + "dismiss": "Verwerfen", + "sectionSystem": "System", + "sectionActivity": "Aktivität", + "andMore": "und {{count}} weitere", + "maintenance": { + "title": "Videos entfernt", + "body_one": "{{count}} gespeichertes oder in einer Playlist befindliches Video wurde entfernt, weil es auf YouTube nicht mehr verfügbar ist.", + "body_other": "{{count}} gespeicherte oder in Playlists befindliche Videos wurden entfernt, weil sie auf YouTube nicht mehr verfügbar sind." + }, + "jobDone": { + "titleOk": "{{job}} abgeschlossen", + "titleError": "{{job}} fehlgeschlagen" + } +} diff --git a/frontend/src/i18n/locales/de/scheduler.json b/frontend/src/i18n/locales/de/scheduler.json index 293c752..8c30032 100644 --- a/frontend/src/i18n/locales/de/scheduler.json +++ b/frontend/src/i18n/locales/de/scheduler.json @@ -25,6 +25,27 @@ "minutes": "Min", "editInterval": "Klicken, um das Intervall zu ändern", "intervalFailed": "Intervall konnte nicht geändert werden", + "runNow": "Jetzt ausführen", + "runAll": "Alle jetzt starten", + "runAllHint": "Alle Jobs jetzt ausführen, zusätzlich zu ihren Zeitplänen.", + "runAllPausedHint": "Setze den Planer fort, um Jobs auszuführen (pausiert werden sie übersprungen).", + "triggered": "{{job}} gestartet", + "triggeredAll_one": "{{count}} Job gestartet", + "triggeredAll_other": "{{count}} Jobs gestartet", + "phase": { + "recheck": "Markierte Videos erneut prüfen", + "revalidate": "Videos erneut validieren", + "enrich": "Videos anreichern", + "backfill_recent": "Neue Uploads nachladen", + "backfill_deep": "Ganze Historie nachladen", + "probe": "Shorts klassifizieren" + }, + "maintenance": { + "title": "Wartung", + "batchLabel": "Pro Lauf erneut geprüfte Videos", + "batchHint": "Wie viele am längsten nicht geprüfte Videos der Wartungs-Job pro Lauf erneut validiert. Höher = schnellerer Gesamtzyklus, aber mehr API-Kontingent (1 Einheit je 50 Videos).", + "batchNote": "Standard: {{default}}. ~233k Videos ÷ dieser Wert = Tage für einen vollen Prüfzyklus." + }, "dot": { "running": "läuft gerade", "ok": "letzter Lauf OK", @@ -39,7 +60,8 @@ "autotag": "Erkennt Sprache/Themen jedes Kanals und vergibt automatische Tags. Fällt er aus, bekommen neue Kanäle keine Auto-Tags, sodass Sprach-/Themenfilter sie verfehlen.", "shorts": "Prüft youtube.com/shorts, um Shorts zu markieren. Fällt er aus, werden Shorts im Feed nicht von normalen Videos getrennt.", "subscriptions": "Importiert die YouTube-Abos jedes Nutzers neu. Fällt er aus, werden auf YouTube hinzugefügte oder entfernte Abos hier nicht übernommen.", - "playlist_sync": "Spiegelt die YouTube-Wiedergabelisten jedes Nutzers in die App. Fällt er aus, erscheinen Änderungen an deinen YouTube-Listen lokal nicht." + "playlist_sync": "Spiegelt die YouTube-Wiedergabelisten jedes Nutzers in die App. Fällt er aus, erscheinen Änderungen an deinen YouTube-Listen lokal nicht.", + "maintenance": "Findet Videos, die nicht mehr abspielbar sind (gelöscht, auf privat gesetzt, abgebrochene Premieren), blendet sie aus dem Feed aus und entfernt sie nach einer Schonfrist; prüft die am längsten nicht geprüften Videos erneut. Fällt er aus, bleiben tote Videos im Katalog." }, "jobs": { "rss_poll": "RSS-Abfrage (neue Uploads)", @@ -48,7 +70,8 @@ "autotag": "Automatisches Tagging", "shorts": "Shorts-Klassifizierung", "subscriptions": "Abo-Resync", - "playlist_sync": "YouTube-Wiedergabelisten-Sync" + "playlist_sync": "YouTube-Wiedergabelisten-Sync", + "maintenance": "Wartung + Validierung" }, "queue": { "recentPending": "Zu synchronisierende Kanäle", diff --git a/frontend/src/i18n/locales/en/inbox.json b/frontend/src/i18n/locales/en/inbox.json new file mode 100644 index 0000000..8d7c7a6 --- /dev/null +++ b/frontend/src/i18n/locales/en/inbox.json @@ -0,0 +1,22 @@ +{ + "navLabel": "Notifications", + "title": "Notifications", + "subtitle": "Updates from your library and the system.", + "empty": "You're all caught up.", + "markAllRead": "Mark all read", + "clearAll": "Clear all", + "markRead": "Mark read", + "dismiss": "Dismiss", + "sectionSystem": "System", + "sectionActivity": "Activity", + "andMore": "and {{count}} more", + "maintenance": { + "title": "Videos removed", + "body_one": "{{count}} saved or playlisted video was removed because it's no longer available on YouTube.", + "body_other": "{{count}} saved or playlisted videos were removed because they're no longer available on YouTube." + }, + "jobDone": { + "titleOk": "{{job}} finished", + "titleError": "{{job}} failed" + } +} diff --git a/frontend/src/i18n/locales/en/scheduler.json b/frontend/src/i18n/locales/en/scheduler.json index e0db313..b33bcf5 100644 --- a/frontend/src/i18n/locales/en/scheduler.json +++ b/frontend/src/i18n/locales/en/scheduler.json @@ -25,6 +25,27 @@ "minutes": "min", "editInterval": "Click to change how often this runs", "intervalFailed": "Couldn't change the interval", + "runNow": "Run now", + "runAll": "Start all now", + "runAllHint": "Run every job now, in addition to their schedules.", + "runAllPausedHint": "Resume the scheduler to run jobs (they're skipped while paused).", + "triggered": "Started {{job}}", + "triggeredAll_one": "Started {{count}} job", + "triggeredAll_other": "Started {{count}} jobs", + "phase": { + "recheck": "Re-checking flagged videos", + "revalidate": "Re-validating videos", + "enrich": "Enriching videos", + "backfill_recent": "Backfilling recent uploads", + "backfill_deep": "Backfilling full history", + "probe": "Classifying Shorts" + }, + "maintenance": { + "title": "Maintenance", + "batchLabel": "Videos re-checked per run", + "batchHint": "How many least-recently-checked videos the maintenance job re-validates each run. Higher = faster full cycle but more API quota (1 unit per 50 videos).", + "batchNote": "Default: {{default}}. ~233k videos ÷ this = days for a full re-check cycle." + }, "dot": { "running": "running now", "ok": "last run OK", @@ -39,7 +60,8 @@ "autotag": "Detects each channel's language/topics and applies automatic tags. If it stops, new channels get no auto tags, so language/topic filters miss them.", "shorts": "Probes youtube.com/shorts to mark which videos are Shorts. If it stops, Shorts aren't separated from normal videos in the feed.", "subscriptions": "Re-imports every user's YouTube subscriptions. If it stops, channels subscribed to or dropped on YouTube aren't reflected here.", - "playlist_sync": "Mirrors each user's YouTube playlists into the app. If it stops, changes to your YouTube playlists don't show up locally." + "playlist_sync": "Mirrors each user's YouTube playlists into the app. If it stops, changes to your YouTube playlists don't show up locally.", + "maintenance": "Finds videos that can no longer be played (deleted, made private, abandoned premieres), hides them from the feed and removes them after a grace period; re-checks the least-recently-checked videos. If it stops, dead videos linger in the catalogue." }, "jobs": { "rss_poll": "RSS poll (new uploads)", @@ -48,7 +70,8 @@ "autotag": "Auto-tagging", "shorts": "Shorts classification", "subscriptions": "Subscription resync", - "playlist_sync": "YouTube playlist sync" + "playlist_sync": "YouTube playlist sync", + "maintenance": "Maintenance + validation" }, "queue": { "recentPending": "Channels to sync", diff --git a/frontend/src/i18n/locales/hu/inbox.json b/frontend/src/i18n/locales/hu/inbox.json new file mode 100644 index 0000000..3f6e6d8 --- /dev/null +++ b/frontend/src/i18n/locales/hu/inbox.json @@ -0,0 +1,22 @@ +{ + "navLabel": "Értesítések", + "title": "Értesítések", + "subtitle": "Frissítések a könyvtáradból és a rendszertől.", + "empty": "Nincs új értesítés.", + "markAllRead": "Összes olvasott", + "clearAll": "Összes törlése", + "markRead": "Olvasottnak jelöl", + "dismiss": "Elvetés", + "sectionSystem": "Rendszer", + "sectionActivity": "Tevékenység", + "andMore": "és még {{count}}", + "maintenance": { + "title": "Videók eltávolítva", + "body_one": "{{count}} mentett vagy lejátszási listás videó eltávolítva, mert már nem elérhető a YouTube-on.", + "body_other": "{{count}} mentett vagy lejátszási listás videó eltávolítva, mert már nem elérhetők a YouTube-on." + }, + "jobDone": { + "titleOk": "{{job}} kész", + "titleError": "{{job}} hibázott" + } +} diff --git a/frontend/src/i18n/locales/hu/scheduler.json b/frontend/src/i18n/locales/hu/scheduler.json index bfedaf9..a3a1b9a 100644 --- a/frontend/src/i18n/locales/hu/scheduler.json +++ b/frontend/src/i18n/locales/hu/scheduler.json @@ -25,6 +25,27 @@ "minutes": "perc", "editInterval": "Kattints a gyakoriság módosításához", "intervalFailed": "Nem sikerült módosítani a gyakoriságot", + "runNow": "Futtatás most", + "runAll": "Mind indítása most", + "runAllHint": "Minden feladat azonnali futtatása, az ütemezésükön felül.", + "runAllPausedHint": "Folytasd az ütemezőt a futtatáshoz (szüneteltetve a feladatok kimaradnak).", + "triggered": "Elindítva: {{job}}", + "triggeredAll_one": "{{count}} feladat elindítva", + "triggeredAll_other": "{{count}} feladat elindítva", + "phase": { + "recheck": "Megjelölt videók újraellenőrzése", + "revalidate": "Videók újraellenőrzése", + "enrich": "Videók dúsítása", + "backfill_recent": "Friss feltöltések behúzása", + "backfill_deep": "Teljes előzmény behúzása", + "probe": "Shorts besorolás" + }, + "maintenance": { + "title": "Karbantartás", + "batchLabel": "Futásonként újraellenőrzött videók", + "batchHint": "Hány, legrégebben ellenőrzött videót ellenőriz újra a karbantartó job futásonként. Magasabb = gyorsabb teljes ciklus, de több API-kvóta (50 videónként 1 egység).", + "batchNote": "Alapérték: {{default}}. ~233k videó ÷ ez = a teljes újraellenőrzési ciklus napokban." + }, "dot": { "running": "most fut", "ok": "utolsó futás OK", @@ -39,7 +60,8 @@ "autotag": "Felismeri a csatornák nyelvét/témáit, és automatikus címkéket ad. Ha leáll, az új csatornák címke nélkül maradnak, így a nyelv/téma szűrők kihagyják őket.", "shorts": "A youtube.com/shorts próbával jelöli, mely videók Shorts-ok. Ha leáll, a Shorts-ok nem különülnek el a normál videóktól a hírfolyamban.", "subscriptions": "Újraimportálja minden felhasználó YouTube-feliratkozásait. Ha leáll, a YouTube-on felvett vagy törölt feliratkozások nem tükröződnek itt.", - "playlist_sync": "Tükrözi a felhasználók YouTube lejátszási listáit az appba. Ha leáll, a YouTube-listák változásai nem jelennek meg lokálisan." + "playlist_sync": "Tükrözi a felhasználók YouTube lejátszási listáit az appba. Ha leáll, a YouTube-listák változásai nem jelennek meg lokálisan.", + "maintenance": "Megkeresi a már sehol le nem játszható videókat (törölt, priváttá tett, elhagyott premier), elrejti őket a hírfolyamból, és türelmi idő után eltávolítja; újraellenőrzi a legrégebben ellenőrzött videókat. Ha leáll, a halott videók a katalógusban maradnak." }, "jobs": { "rss_poll": "RSS-lekérdezés (új feltöltések)", @@ -48,7 +70,8 @@ "autotag": "Automatikus címkézés", "shorts": "Shorts-besorolás", "subscriptions": "Feliratkozások újraszinkronja", - "playlist_sync": "YouTube lejátszási listák szinkronja" + "playlist_sync": "YouTube lejátszási listák szinkronja", + "maintenance": "Karbantartás + ellenőrzés" }, "queue": { "recentPending": "Szinkronra váró csatorna", diff --git a/frontend/src/lib/api.ts b/frontend/src/lib/api.ts index 12d4d82..c316c70 100644 --- a/frontend/src/lib/api.ts +++ b/frontend/src/lib/api.ts @@ -325,6 +325,9 @@ export interface SchedulerJob { last_finished: string | null; last_result: string | null; last_error: string | null; + // Live progress while running (null when idle or for jobs that don't report it). + // total is null for indeterminate progress (e.g. enrichment drains an unknown queue). + progress: { current: number; total: number | null; phase: string | null } | null; } export interface SchedulerStatus { @@ -346,6 +349,12 @@ export interface SchedulerStatus { daily_budget: number; backfill_reserve: number; }; + maintenance: { + revalidate_batch: number; + revalidate_batch_default: number; + min: number; + max: number; + }; } export interface Account { @@ -356,6 +365,19 @@ export interface Account { active: boolean; } +// A durable, server-backed notification (the inbox center). Distinct from the client-side +// transient toast/bell, which lives only in localStorage. +export interface AppNotification { + id: number; + type: string; + title: string; + body: string | null; + data: Record | null; + read: boolean; + dismissed: boolean; + created_at: string | null; +} + export const api = { me: (): Promise => req("/api/me"), accounts: (): Promise => req("/api/me/accounts"), @@ -454,6 +476,15 @@ export const api = { method: "PATCH", body: JSON.stringify({ interval_minutes: intervalMinutes }), }), + runSchedulerJob: (jobId: string): Promise<{ id: string; started: boolean }> => + req(`/api/admin/scheduler/jobs/${jobId}/run`, { method: "POST" }), + runAllSchedulerJobs: (): Promise<{ started: string[] }> => + req("/api/admin/scheduler/run-all", { method: "POST" }), + updateMaintenanceBatch: (revalidateBatch: number): Promise<{ revalidate_batch: number }> => + req("/api/admin/scheduler/maintenance", { + method: "PATCH", + body: JSON.stringify({ revalidate_batch: revalidateBatch }), + }), // --- onboarding / admin --- requestAccess: (email: string): Promise<{ status: string }> => @@ -478,6 +509,19 @@ export const api = { addInvite: (email: string) => req("/api/admin/invites", { method: "POST", body: JSON.stringify({ email }) }), + // --- notification inbox (durable, server-backed) --- + notifications: (includeDismissed = false): Promise<{ items: AppNotification[]; total: number }> => + req(`/api/me/notifications?include_dismissed=${includeDismissed}`), + notificationUnreadCount: (): Promise<{ count: number }> => + req("/api/me/notifications/unread_count"), + markNotificationRead: (id: number) => + req(`/api/me/notifications/${id}/read`, { method: "POST" }), + markAllNotificationsRead: () => + req("/api/me/notifications/read_all", { method: "POST" }), + dismissNotification: (id: number) => + req(`/api/me/notifications/${id}/dismiss`, { method: "POST" }), + clearNotifications: () => req("/api/me/notifications/clear", { method: "POST" }), + // --- user tags --- createTag: (t: { name: string; color?: string; category?: string }) => req("/api/tags", { method: "POST", body: JSON.stringify(t) }), diff --git a/frontend/src/lib/notifications.ts b/frontend/src/lib/notifications.ts index 530ce68..184d708 100644 --- a/frontend/src/lib/notifications.ts +++ b/frontend/src/lib/notifications.ts @@ -218,6 +218,21 @@ export function clearAll(): void { emit(); } +/** Remove a single history entry entirely (per-item clear in the notification center). */ +export function remove(id: number): void { + const before = items.length; + items = items.filter((n) => n.id !== id); + if (items.length !== before) emit(); +} + +/** Resolve any history entries tied to a video — called when it's unhidden/unwatched so the + * now-stale "Hidden/Watched X" notice disappears instead of lingering with a dead action. */ +export function resolveVideo(videoId: string): void { + const before = items.length; + items = items.filter((n) => n.meta?.videoId !== videoId); + if (items.length !== before) emit(); +} + export const getActiveToasts = (): Notification[] => cachedActive; export const getNotifications = (): Notification[] => cachedReversed; export const getUnreadCount = (): number => cachedUnread; diff --git a/frontend/src/lib/releaseNotes.ts b/frontend/src/lib/releaseNotes.ts index 84b1f85..5265d71 100644 --- a/frontend/src/lib/releaseNotes.ts +++ b/frontend/src/lib/releaseNotes.ts @@ -14,6 +14,17 @@ export interface ReleaseEntry { } export const RELEASE_NOTES: ReleaseEntry[] = [ + { + version: "0.9.0", + date: "2026-06-18", + summary: "A notifications inbox, and automatic clean-up of videos that can no longer be played.", + features: [ + "New Notifications center in the left sidebar, with an unread badge: one place for both durable system updates (about your library and background jobs) and your recent activity (with quick Unhide / Unwatch / Find-in-feed actions). Mark items read, dismiss them individually, or clear everything. Pop-up toasts still appear as before.", + "Automatic library maintenance: a background job spots videos that can no longer be played anywhere — deleted, made private, or premieres that never went live — hides them from your feed right away, and removes them after a grace period. Genuine 24/7 livestreams are left alone.", + "If a video you'd saved or added to a playlist gets removed this way, you get a single summary notification listing them — never one message per video.", + "Admin Scheduler: run any background job on demand with a “Run now” button (or “Start all now”), watch a live progress bar while long jobs run, and get an inbox notification with the result when a job you started finishes.", + ], + }, { version: "0.8.0", date: "2026-06-18", diff --git a/frontend/src/lib/urlState.ts b/frontend/src/lib/urlState.ts index ab2a38b..8483ee7 100644 --- a/frontend/src/lib/urlState.ts +++ b/frontend/src/lib/urlState.ts @@ -78,17 +78,29 @@ export function hasFilterParams(params: URLSearchParams): boolean { return KEYS.some((k) => params.has(k)); } -export type Page = "feed" | "channels" | "stats" | "playlists" | "settings" | "scheduler"; +// The single source of truth for valid page ids; `Page` and the runtime validator both +// derive from it, so adding a page is a one-line change (no parallel allowlists to keep in +// sync). "feed" is the default/fallback. +export const PAGES = [ + "feed", + "channels", + "stats", + "playlists", + "settings", + "scheduler", + "notifications", +] as const; + +export type Page = (typeof PAGES)[number]; + +/** Narrow an arbitrary string to a known Page (else null). */ +export function isPage(p: string | null | undefined): p is Page { + return !!p && (PAGES as readonly string[]).includes(p); +} export function readPage(): Page { const p = new URLSearchParams(window.location.search).get("page"); - return p === "channels" || - p === "stats" || - p === "playlists" || - p === "settings" || - p === "scheduler" - ? p - : "feed"; + return isPage(p) ? p : "feed"; } /** Build a shareable absolute URL that reproduces the current filters (+ page). Used by the