peertube-plugin-sponsorblock 0.1.0

package/client/video-watch.js

@@ -0,0 +1,383 @@
+/**
+ * Client-side code for video watch page
+ * Implements automatic segment skipping
+ */
+
+function register({ registerHook, peertubeHelpers }) {
+  console.log('[SponsorBlock] Video watch script loaded')
+
+  let segments = []
+  let skippedSegments = new Set()
+  let currentVideo = null
+  let skippingActive = false
+  let playerRef = null
+
+  // Hook: When video is loaded
+  registerHook({
+    target: 'action:video-watch.video.loaded',
+    handler: async ({ video, videojs }) => {
+      console.log('[SponsorBlock] Video loaded:', video.uuid)
+
+      currentVideo = video
+      segments = []
+      skippedSegments.clear()
+      skippingActive = false
+      playerRef = videojs
+
+      try {
+        // Fetch segments for this video
+        segments = await fetchSegments(video.uuid)
+
+        if (segments.length > 0) {
+          console.log(`[SponsorBlock] Found ${segments.length} segments to skip`)
+          setupSegmentSkipping(videojs)
+        } else {
+          console.log('[SponsorBlock] No segments found for this video')
+        }
+      } catch (error) {
+        console.error('[SponsorBlock] Failed to fetch segments:', error)
+      }
+
+      // Show mapping widget for admins/moderators
+      try {
+        const user = await peertubeHelpers.getUser()
+        if (user && (user.role === 0 || user.role === 1)) {
+          renderMappingWidget(video.uuid)
+        }
+      } catch (e) {
+        // Not logged in or can't get user — skip widget
+      }
+    }
+  })
+
+  /**
+   * Fetch segments from server
+   */
+  async function fetchSegments(videoUuid) {
+    try {
+      const baseUrl = window.location.origin
+      const response = await fetch(
+        `${baseUrl}/plugins/sponsorblock/router/segments/${videoUuid}`,
+        {
+          method: 'GET',
+          headers: peertubeHelpers.getAuthHeader()
+        }
+      )
+
+      if (!response.ok) {
+        if (response.status === 404) {
+          return [] // No segments found
+        }
+        throw new Error(`Failed to fetch segments: ${response.status}`)
+      }
+
+      const data = await response.json()
+      return data.segments || []
+    } catch (error) {
+      console.error('[SponsorBlock] Error fetching segments:', error)
+      return []
+    }
+  }
+
+  /**
+   * Setup segment skipping on the video player
+   */
+  function setupSegmentSkipping(player) {
+    if (!player) return
+
+    // Avoid doubling listeners if skipping was already set up
+    if (skippingActive) return
+    skippingActive = true
+
+    // Access the native HTML5 <video> element (PeerTube v8 wraps Video.js)
+    const videoEl = player.el
+      ? player.el().querySelector('video')
+      : document.querySelector('.vjs-tech')
+
+    if (!videoEl) {
+      console.error('[SponsorBlock] Could not find video element')
+      return
+    }
+
+    let lastCheckTime = 0
+
+    videoEl.addEventListener('timeupdate', () => {
+      const currentTime = videoEl.currentTime
+
+      // Throttle checks to avoid performance issues
+      if (Math.abs(currentTime - lastCheckTime) < 0.5) {
+        return
+      }
+      lastCheckTime = currentTime
+
+      // Check if we're in a segment to skip
+      for (const segment of segments) {
+        const segmentKey = `${segment.start_time}-${segment.end_time}`
+
+        if (currentTime >= segment.start_time && currentTime < segment.end_time) {
+          // Skip this segment if not already skipped
+          if (!skippedSegments.has(segmentKey)) {
+            console.log(`[SponsorBlock] Skipping ${segment.category} segment: ${segment.start_time}s - ${segment.end_time}s`)
+
+            videoEl.currentTime = segment.end_time
+            skippedSegments.add(segmentKey)
+
+            // Show notification
+            showSkipNotification(segment)
+          }
+          break
+        }
+      }
+    })
+
+    // Add visual indicators to the progress bar
+    addProgressBarMarkers(player)
+  }
+
+  /**
+   * Show notification when a segment is skipped
+   */
+  function showSkipNotification(segment) {
+    const categoryLabels = {
+      sponsor: 'Sponsor',
+      selfpromo: 'Self-promotion',
+      interaction: 'Interaction reminder',
+      intro: 'Intro',
+      outro: 'Outro',
+      preview: 'Preview',
+      music_offtopic: 'Off-topic music',
+      filler: 'Filler'
+    }
+
+    const label = categoryLabels[segment.category] || segment.category
+    const duration = (segment.end_time - segment.start_time).toFixed(1)
+
+    peertubeHelpers.notifier.info(
+      `Skipped ${label} (${duration}s)`,
+      'SponsorBlock',
+      3000
+    )
+  }
+
+  /**
+   * Render the mapping widget for admins/moderators
+   */
+  async function renderMappingWidget(videoUuid) {
+    // Remove any existing widget
+    const existing = document.querySelector('.sponsorblock-widget')
+    if (existing) existing.remove()
+
+    // Find the container below the player
+    const container = document.querySelector('.video-info')
+    if (!container) return
+
+    const widget = document.createElement('div')
+    widget.className = 'sponsorblock-widget'
+
+    // Check for existing mapping
+    let currentMapping = null
+    try {
+      const baseUrl = window.location.origin
+      const resp = await fetch(
+        `${baseUrl}/plugins/sponsorblock/router/mapping/${videoUuid}`,
+        { headers: peertubeHelpers.getAuthHeader() }
+      )
+      if (resp.ok) {
+        currentMapping = await resp.json()
+      }
+    } catch (e) {
+      // No mapping yet
+    }
+
+    const translate = (key) => peertubeHelpers.translate(key)
+
+    const label = await translate('mapping-label') || 'SponsorBlock'
+    const placeholder = await translate('mapping-placeholder') || 'YouTube ID or URL'
+    const linkBtn = await translate('mapping-link-btn') || 'Link'
+    const currentLabel = await translate('mapping-current') || 'Linked to:'
+
+    // Build toggle label
+    const toggle = document.createElement('span')
+    toggle.className = 'sponsorblock-widget-toggle'
+    toggle.textContent = `▶ ${label}`
+    widget.appendChild(toggle)
+
+    // Collapsible content
+    const content = document.createElement('div')
+    content.style.display = 'none'
+
+    // Show current mapping if any
+    const currentDiv = document.createElement('div')
+    currentDiv.className = 'sponsorblock-widget-current'
+    if (currentMapping) {
+      currentDiv.innerHTML = `${currentLabel} <code>${currentMapping.youtube_id}</code>`
+    }
+    content.appendChild(currentDiv)
+
+    // Form row
+    const form = document.createElement('div')
+    form.className = 'sponsorblock-widget-form'
+
+    const input = document.createElement('input')
+    input.type = 'text'
+    input.className = 'sponsorblock-widget-input'
+    input.placeholder = placeholder
+    form.appendChild(input)
+
+    const btn = document.createElement('button')
+    btn.className = 'sponsorblock-widget-btn'
+    btn.textContent = linkBtn
+    form.appendChild(btn)
+
+    content.appendChild(form)
+
+    // Status message
+    const status = document.createElement('div')
+    status.className = 'sponsorblock-widget-status'
+    content.appendChild(status)
+
+    widget.appendChild(content)
+
+    // Toggle open/close
+    toggle.addEventListener('click', () => {
+      const open = content.style.display !== 'none'
+      content.style.display = open ? 'none' : 'block'
+      toggle.textContent = `${open ? '▶' : '▼'} ${label}`
+    })
+
+    // Submit mapping
+    btn.addEventListener('click', async () => {
+      const value = input.value.trim()
+      if (!value) return
+
+      btn.disabled = true
+      status.textContent = ''
+      status.className = 'sponsorblock-widget-status'
+
+      try {
+        const baseUrl = window.location.origin
+        const resp = await fetch(
+          `${baseUrl}/plugins/sponsorblock/router/mapping/${videoUuid}`,
+          {
+            method: 'POST',
+            headers: {
+              'Content-Type': 'application/json',
+              ...peertubeHelpers.getAuthHeader()
+            },
+            body: JSON.stringify({ youtubeId: value })
+          }
+        )
+
+        const data = await resp.json()
+
+        if (!resp.ok) {
+          const errorMsg = data.error === 'Invalid YouTube ID format'
+            ? (await translate('mapping-invalid-id') || 'Invalid YouTube ID.')
+            : (await translate('mapping-error') || 'Error linking video.')
+          status.textContent = errorMsg
+          status.classList.add('error')
+          return
+        }
+
+        // Update segments and activate skipping
+        segments = data.segments || []
+        skippedSegments.clear()
+
+        if (segments.length > 0) {
+          const successMsg = (await translate('mapping-success') || 'Linked! {count} segment(s) found.')
+            .replace('{count}', segments.length)
+          status.textContent = successMsg
+          status.classList.add('success')
+
+          if (playerRef) {
+            setupSegmentSkipping(playerRef)
+            addProgressBarMarkers(playerRef)
+          }
+        } else {
+          status.textContent = await translate('mapping-no-segments') || 'Linked, but no segments found on SponsorBlock.'
+          status.classList.add('success')
+        }
+
+        // Update current mapping display
+        currentDiv.innerHTML = `${currentLabel} <code>${data.youtubeId}</code>`
+        input.value = ''
+
+      } catch (e) {
+        status.textContent = await translate('mapping-error') || 'Error linking video.'
+        status.classList.add('error')
+      } finally {
+        btn.disabled = false
+      }
+    })
+
+    // Allow Enter key to submit
+    input.addEventListener('keydown', (e) => {
+      if (e.key === 'Enter') btn.click()
+    })
+
+    container.prepend(widget)
+  }
+
+  /**
+   * Add visual markers to the progress bar
+   */
+  function addProgressBarMarkers(player) {
+    if (!player || segments.length === 0) return
+
+    try {
+      // Access seek bar element with fallback for PeerTube v8 wrapper
+      let seekBarEl
+      try {
+        seekBarEl = player.controlBar.progressControl.seekBar.el()
+      } catch {
+        seekBarEl = document.querySelector('.vjs-progress-holder')
+      }
+      if (!seekBarEl) return
+
+      // Access the native HTML5 <video> element for duration
+      const videoEl = player.el
+        ? player.el().querySelector('video')
+        : document.querySelector('.vjs-tech')
+      if (!videoEl) return
+
+      const duration = videoEl.duration
+      if (!duration || duration === Infinity || isNaN(duration)) {
+        // Wait for duration to be available
+        videoEl.addEventListener('durationchange', () => addProgressBarMarkers(player), { once: true })
+        return
+      }
+
+      // Remove existing markers
+      const existingMarkers = seekBarEl.querySelectorAll('.sponsorblock-marker')
+      existingMarkers.forEach(marker => marker.remove())
+
+      // Add markers for each segment
+      segments.forEach(segment => {
+        const startPercent = (segment.start_time / duration) * 100
+        const widthPercent = ((segment.end_time - segment.start_time) / duration) * 100
+
+        const marker = document.createElement('div')
+        marker.className = 'sponsorblock-marker'
+        marker.dataset.category = segment.category
+        marker.style.cssText = `
+          position: absolute;
+          top: 0;
+          bottom: 0;
+          left: ${startPercent}%;
+          width: ${widthPercent}%;
+          pointer-events: none;
+          z-index: 30;
+        `
+        marker.title = `${segment.category}: ${segment.start_time}s - ${segment.end_time}s`
+
+        seekBarEl.appendChild(marker)
+      })
+
+      console.log(`[SponsorBlock] Added ${segments.length} progress bar markers`)
+    } catch (error) {
+      console.error('[SponsorBlock] Failed to add progress bar markers:', error)
+    }
+  }
+}
+
+export { register }

package/languages/en.json

@@ -0,0 +1,77 @@
+{
+  "operation-mode": "Operation mode",
+  "skip-segments": "Skip segments (client-side)",
+  "remove-segments": "Remove segments permanently (experimental)",
+  "mode-description": "Skip mode: Segments are skipped during playback. Remove mode: Segments are permanently deleted from video files (requires FFmpeg).",
+  "category-sponsor": "Sponsors",
+  "category-selfpromo": "Self-promotion",
+  "category-interaction": "Interaction reminders",
+  "category-intro": "Intros",
+  "category-outro": "Outros",
+  "category-preview": "Previews/Recaps",
+  "category-music": "Off-topic music",
+  "category-filler": "Filler content",
+  "api-url": "SponsorBlock API URL",
+  "cache-duration": "Cache duration (hours)",
+  "cache-description": "How long to cache SponsorBlock segments before refreshing",
+  "show-notifications": "Show skip notifications",
+  "notifications-description": "Display a notification when a segment is skipped",
+  "skipped-segment": "Skipped {category} ({duration}s)",
+  "no-segments": "No sponsor segments found for this video",
+  "mapping-label": "SponsorBlock",
+  "mapping-placeholder": "YouTube ID or URL",
+  "mapping-link-btn": "Link",
+  "mapping-success": "Linked! {count} segment(s) found.",
+  "mapping-error": "Error linking video.",
+  "mapping-invalid-id": "Invalid YouTube ID.",
+  "mapping-current": "Linked to:",
+  "mapping-no-segments": "Linked, but no segments found on SponsorBlock.",
+  "storage-path": "PeerTube storage path",
+  "storage-path-description": "Absolute path to the PeerTube storage directory. Required for remove mode.",
+  "process-queued": "Video queued for processing ({count} segments).",
+  "process-already-queued": "This video is already queued or being processed.",
+  "process-no-segments": "No segments found to process for this video.",
+  "process-no-mapping": "No YouTube mapping found for this video.",
+  "process-all-queued": "{count} video(s) queued for processing.",
+  "process-error": "An error occurred while queuing video for processing.",
+
+  "sync-interval": "Periodic sync interval (hours)",
+  "sync-interval-description": "Automatically re-fetch segments for all mapped videos at this interval. Set to 0 to disable.",
+
+  "admin-stats-mapped": "Mapped Videos",
+  "admin-stats-segments": "Total Segments",
+  "admin-stats-time-saved": "Time Saved",
+  "admin-stats-queue": "Queue Pending",
+
+  "admin-btn-scan": "Scan Imports",
+  "admin-btn-sync-all": "Sync All",
+  "admin-btn-process-all": "Process All",
+
+  "admin-table-uuid": "Video UUID",
+  "admin-table-youtube": "YouTube ID",
+  "admin-table-segments": "Segments",
+  "admin-table-saved": "Time Saved",
+  "admin-table-synced": "Last Sync",
+  "admin-table-queue": "Queue",
+  "admin-table-actions": "Actions",
+
+  "admin-action-sync": "Sync",
+  "admin-action-process": "Process",
+  "admin-action-delete": "Delete",
+
+  "admin-scan-started": "Scanning imports…",
+  "admin-scan-result": "Scanned {scanned}, mapped {mapped} new video(s).",
+  "admin-sync-started": "Syncing all mappings ({total})…",
+  "admin-process-result": "Queued {queued} video(s) for processing.",
+  "admin-delete-confirm": "Delete mapping for this video?",
+  "admin-delete-success": "Mapping deleted.",
+  "admin-no-mappings": "No mappings yet. Use Scan Imports or link videos manually.",
+
+  "admin-queue-pending": "Pending",
+  "admin-queue-processing": "Processing",
+  "admin-queue-done": "Done",
+  "admin-queue-error": "Error",
+
+  "admin-last-sync-never": "Never",
+  "admin-last-sync-ago": "{time} ago"
+}

package/languages/fr.json

@@ -0,0 +1,77 @@
+{
+  "operation-mode": "Mode d'opération",
+  "skip-segments": "Sauter les segments (côté client)",
+  "remove-segments": "Supprimer les segments définitivement (expérimental)",
+  "mode-description": "Mode saut : Les segments sont sautés pendant la lecture. Mode suppression : Les segments sont définitivement supprimés des fichiers vidéo (nécessite FFmpeg).",
+  "category-sponsor": "Sponsors",
+  "category-selfpromo": "Auto-promotion",
+  "category-interaction": "Rappels d'interaction",
+  "category-intro": "Intros",
+  "category-outro": "Outros",
+  "category-preview": "Aperçus/Récapitulatifs",
+  "category-music": "Musique hors-sujet",
+  "category-filler": "Contenu de remplissage",
+  "api-url": "URL de l'API SponsorBlock",
+  "cache-duration": "Durée du cache (heures)",
+  "cache-description": "Durée de conservation des segments SponsorBlock en cache avant actualisation",
+  "show-notifications": "Afficher les notifications de saut",
+  "notifications-description": "Afficher une notification lorsqu'un segment est sauté",
+  "skipped-segment": "{category} sauté ({duration}s)",
+  "no-segments": "Aucun segment sponsor trouvé pour cette vidéo",
+  "mapping-label": "SponsorBlock",
+  "mapping-placeholder": "ID YouTube ou URL",
+  "mapping-link-btn": "Lier",
+  "mapping-success": "Lié ! {count} segment(s) trouvé(s).",
+  "mapping-error": "Erreur lors de la liaison.",
+  "mapping-invalid-id": "ID YouTube invalide.",
+  "mapping-current": "Lié à :",
+  "mapping-no-segments": "Lié, mais aucun segment trouvé sur SponsorBlock.",
+  "storage-path": "Chemin du stockage PeerTube",
+  "storage-path-description": "Chemin absolu vers le répertoire de stockage PeerTube. Requis pour le mode suppression.",
+  "process-queued": "Vidéo mise en file d'attente ({count} segments).",
+  "process-already-queued": "Cette vidéo est déjà en file d'attente ou en cours de traitement.",
+  "process-no-segments": "Aucun segment à traiter pour cette vidéo.",
+  "process-no-mapping": "Aucune correspondance YouTube trouvée pour cette vidéo.",
+  "process-all-queued": "{count} vidéo(s) mise(s) en file d'attente.",
+  "process-error": "Une erreur est survenue lors de la mise en file d'attente.",
+
+  "sync-interval": "Intervalle de synchronisation périodique (heures)",
+  "sync-interval-description": "Re-télécharger automatiquement les segments pour toutes les vidéos liées à cet intervalle. 0 pour désactiver.",
+
+  "admin-stats-mapped": "Vidéos liées",
+  "admin-stats-segments": "Segments totaux",
+  "admin-stats-time-saved": "Temps économisé",
+  "admin-stats-queue": "File d'attente",
+
+  "admin-btn-scan": "Scanner les imports",
+  "admin-btn-sync-all": "Tout synchroniser",
+  "admin-btn-process-all": "Tout traiter",
+
+  "admin-table-uuid": "UUID vidéo",
+  "admin-table-youtube": "ID YouTube",
+  "admin-table-segments": "Segments",
+  "admin-table-saved": "Temps économisé",
+  "admin-table-synced": "Dernière sync",
+  "admin-table-queue": "File",
+  "admin-table-actions": "Actions",
+
+  "admin-action-sync": "Sync",
+  "admin-action-process": "Traiter",
+  "admin-action-delete": "Supprimer",
+
+  "admin-scan-started": "Scan des imports en cours…",
+  "admin-scan-result": "{scanned} scannés, {mapped} nouvelle(s) vidéo(s) liée(s).",
+  "admin-sync-started": "Synchronisation de toutes les liaisons ({total})…",
+  "admin-process-result": "{queued} vidéo(s) mise(s) en file de traitement.",
+  "admin-delete-confirm": "Supprimer la liaison pour cette vidéo ?",
+  "admin-delete-success": "Liaison supprimée.",
+  "admin-no-mappings": "Aucune liaison. Utilisez Scanner les imports ou liez des vidéos manuellement.",
+
+  "admin-queue-pending": "En attente",
+  "admin-queue-processing": "En cours",
+  "admin-queue-done": "Terminé",
+  "admin-queue-error": "Erreur",
+
+  "admin-last-sync-never": "Jamais",
+  "admin-last-sync-ago": "Il y a {time}"
+}