Initial Commit

fetch_podcasts.rb

@@ -0,0 +1,482 @@
+#!/usr/bin/env jruby
+# frozen_string_literal: true
+#
+# fetch_podcasts.rb - Fetch podcast episodes from RSS feeds, manage subscriptions,
+# and download audio. JRuby-compatible (Ruby 3.1+ baseline).
+
+require "nokogiri"
+require "net/http"
+require "uri"
+require "json"
+require "sqlite3"
+require "fileutils"
+require "time"
+
+AUDIO_ROOT    = Pathname.new(File.expand_path(__dir__))
+DB_PATH       = AUDIO_ROOT.join("state/subscriptions.db")
+DOWNLOAD_DIR  = AUDIO_ROOT.join("podcasts")
+CONFIG_PATH   = AUDIO_ROOT.join("config.json")
+
+module Radio
+  class Fetcher
+    def initialize
+      @db = get_db
+    end
+
+    attr_reader :db
+
+    def load_config
+      JSON.parse(File.read(CONFIG_PATH))
+    end
+
+    def get_db
+      FileUtils.mkdir_p(DB_PATH.dirname)
+      conn = SQLite3::Database.new(DB_PATH.to_s)
+      conn.execute(<<~SQL)
+        CREATE TABLE IF NOT EXISTS shows (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          name TEXT UNIQUE NOT NULL,
+          feed_url TEXT UNIQUE NOT NULL,
+          slug TEXT UNIQUE NOT NULL,
+          opml_import INTEGER DEFAULT 0
+        );
+      SQL
+      conn.execute(<<~SQL)
+        CREATE TABLE IF NOT EXISTS seen (
+          url TEXT PRIMARY KEY,
+          title TEXT,
+          show_slug TEXT,
+          duration_sec INTEGER DEFAULT 0,
+          downloaded_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        );
+      SQL
+      # Migrate older databases lacking the new column
+      cols = conn.execute("PRAGMA table_info(shows)").map { |r| r[1] }
+      unless cols.include?("opml_import")
+        conn.execute("ALTER TABLE shows ADD COLUMN opml_import INTEGER DEFAULT 0")
+      end
+      conn.commit rescue nil
+      conn
+    end
+
+    def sanitize_slug(name)
+      slug = name.downcase.strip
+      slug = slug.gsub(/[^a-z0-9\-_]/, "_")
+      slug = slug.split("_").reject(&:empty?).join("_")
+      slug[0, 80]
+    end
+
+    # ---- Registration from OPML --------------------------------------------
+    def register_shows_from_opml_xml(xml_bytes, opml_import: false)
+      doc = Nokogiri::XML(xml_bytes)
+      added = updated_flag = skipped = 0
+
+      doc.xpath("//outline").each do |node|
+        xml_url = node["xmlUrl"].to_s
+        next if xml_url.empty?
+        otype = node["type"].to_s
+        next unless otype.empty? || otype == "rss"
+
+        show_name = node["text"] || node["title"] || "Unknown Show"
+        slug = sanitize_slug(show_name)
+        flag = opml_import ? 1 : 0
+
+        existing = db.get_first_row("SELECT id, opml_import FROM shows WHERE feed_url=?", xml_url)
+        if existing
+          existing_id, existing_flag = existing
+          if flag == 1 && existing_flag.to_i == 0
+            db.execute("UPDATE shows SET opml_import=1 WHERE id=?", existing_id)
+            updated_flag += 1
+            puts "  Protected existing: #{show_name} (#{slug})"
+          else
+            skipped += 1
+          end
+        else
+          db.execute(
+            "INSERT INTO shows (name, feed_url, slug, opml_import) VALUES (?, ?, ?, ?)",
+            [show_name, xml_url, slug, flag]
+          )
+          added += 1
+          puts "  Registered: #{show_name} -> #{slug}"
+        end
+      end
+
+      db.commit
+      puts "  Added #{added} new show(s)." if added.positive?
+      puts "  Upgraded #{updated_flag} show(s) to protected." if updated_flag.positive?
+      puts "  Skipped #{skipped} duplicate(s)." if skipped.positive?
+      added
+    end
+
+    def import_opml_file(filepath)
+      unless File.exist?(filepath)
+        puts "ERROR: File not found: #{filepath}"
+        exit 1
+      end
+      xml_data = File.binread(filepath)
+      count = register_shows_from_opml_xml(xml_data, opml_import: true)
+      total = db.get_first_row("SELECT COUNT(*) FROM shows")[0]
+      puts "\nImport complete. #{count} new show(s) added. Total registered: #{total}"
+    ensure
+      db&.close
+    end
+
+    # ---- gPodder.net sync ----------------------------------------------------
+    def sync_gpoddernet
+      cfg = load_config
+      gp = cfg.fetch("gpodder", {})
+
+      unless gp.fetch("enable", false)
+        puts "gpodder.net sync is disabled in config.json."
+        return
+      end
+
+      unless gp["username"] && gp["password"]
+        puts "ERROR: gpodder.username/gpodder.password not set in config.json"
+        exit 1
+      end
+
+      url = "#{gp['host']}/subscriptions/#{gp['username']}.opml"
+      puts "Fetching subscriptions from #{gp['host']} for '#{gp['username']}'..."
+
+      uri = URI(url)
+      resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
+        req = Net::HTTP::Get.new(uri)
+        req.basic_auth(gp["username"], gp["password"])
+        http.request(req)
+      end
+
+      if resp.code == "401"
+        puts "ERROR: Authentication failed. Check username/password in config.json."
+        exit 1
+      elsif resp.code != "200"
+        puts "ERROR: Unexpected response #{resp.code}: #{resp.body[0, 200]}"
+        exit 1
+      end
+
+      # Collect all feed URLs from the current subscription list
+      root_doc = Nokogiri::XML(resp.body)
+      gp_feed_urls = Set.new
+      root_doc.xpath("//outline").each do |node|
+        fu = node["xmlUrl"].to_s
+        gp_feed_urls.add(fu) unless fu.empty?
+      end
+
+      count = register_shows_from_opml_xml(resp.body, opml_import: false)
+      total = db.get_first_row("SELECT COUNT(*) FROM shows")[0]
+
+      prune_removed_shows(gp_feed_urls)
+
+      puts "\nSync complete. #{count} new, total registered: #{total}"
+    end
+
+    def prune_removed_shows(gp_feed_urls)
+      rows = db.execute("SELECT slug, feed_url, name FROM shows WHERE opml_import = 0")
+      to_remove = rows.select { |_slug, feed_url, _name| !gp_feed_urls.include?(feed_url) }
+      return if to_remove.empty?
+
+      to_remove.each do |slug, _feed_url, name|
+        puts "  Removing unsubscribed show: #{name} (#{slug})"
+        db.execute("DELETE FROM seen WHERE show_slug=?", slug)
+        db.execute("DELETE FROM shows WHERE slug=?", slug)
+        show_dir = DOWNLOAD_DIR.join(slug)
+        if Dir.exist?(show_dir)
+          FileUtils.rm_rf(show_dir)
+          puts "  Deleted directory: #{show_dir}"
+        end
+      end
+
+      db.commit
+      puts "  Pruned #{to_remove.size} removed show(s)."
+    end
+
+    # ---- Manual management ---------------------------------------------------
+    def delete_show(slug)
+      row = db.get_first_row("SELECT name FROM shows WHERE slug=?", slug)
+      if row.nil?
+        puts "No show found with slug '#{slug}'."
+        return
+      end
+      name = row[0]
+      puts "Deleting show: #{name} (#{slug})"
+      db.execute("DELETE FROM seen WHERE show_slug=?", slug)
+      db.execute("DELETE FROM shows WHERE slug=?", slug)
+      db.commit
+
+      show_dir = DOWNLOAD_DIR.join(slug)
+      if Dir.exist?(show_dir)
+        FileUtils.rm_rf(show_dir)
+        puts "Deleted directory: #{show_dir}"
+      end
+
+      pls_file = AUDIO_ROOT.join("playlists", "#{slug}.pls")
+      if File.exist?(pls_file)
+        File.delete(pls_file)
+        puts "Deleted playlist: #{pls_file}"
+      end
+
+      puts "Done."
+    end
+
+    def add_show(feed_url)
+      puts "Fetching feed: #{feed_url}"
+      parsed = parse_feed(feed_url)
+      if parsed.nil?
+        puts "ERROR: Invalid or unreachable feed."
+        exit 1
+      end
+
+      show_name, entries = parsed
+      slug = sanitize_slug(show_name)
+      puts "  Title: #{show_name}"
+      puts "  Slug:  #{slug}"
+      puts "  Entries found: #{entries.size}"
+
+      existing = db.get_first_row("SELECT name FROM shows WHERE feed_url=?", feed_url)
+      if existing
+        puts "NOTE: Feed already registered as '#{existing[0]}'. Nothing to do."
+        return
+      end
+
+      db.execute(
+        "INSERT INTO shows (name, feed_url, slug, opml_import) VALUES (?, ?, ?, 1)",
+        [show_name, feed_url, slug]
+      )
+      db.commit
+      puts "  Registered: #{show_name} -> #{slug}"
+
+      puts "\n--- Fetching episodes ---"
+      fetch_feed(show_name, feed_url, slug)
+
+      puts "\nDone. Episodes saved to: #{DOWNLOAD_DIR.join(slug)}/"
+    end
+
+    # ---- Core fetching ---------------------------------------------------------
+    def parse_feed(feed_url)
+      body = http_get(feed_url)
+      return nil if body.nil?
+
+      doc = Nokogiri::XML(body)
+      doc.remove_namespaces!
+
+      # Support both RSS (<channel>) and Atom (<feed>)
+      channel = doc.at_xpath("//channel") || doc.at_xpath("//feed")
+      return nil if channel.nil?
+
+      title = (channel.at_xpath("./title")&.text.presence || "Unknown Show")
+
+      entries = []
+      if doc.root.name == "rss"
+        doc.xpath("//item").each do |item|
+          enc = item.at_xpath(".//enclosure")
+          next if enc.nil?
+          entries << {
+            url: enc["url"].to_s,
+            type: enc["type"].to_s,
+            length: enc["length"].to_s,
+            title: (item.at_xpath("./title")&.text.presence || "untitled")
+          }
+        end
+      else
+        doc.xpath("//entry").each do |entry|
+          link = entry.at_xpath("./link[@rel='enclosure']") ||
+                 entry.at_xpath("./link")
+          next if link.nil?
+          dur = entry.at_xpath(".//media:duration")
+          entries << {
+            url: link["href"].to_s,
+            type: link["type"].to_s,
+            length: dur ? dur.text : "",
+            title: (entry.at_xpath("./title")&.text.presence || "untitled")
+          }
+        end
+      end
+
+      [title, entries]
+    rescue StandardError => e
+      warn "Feed parse error for #{feed_url}: #{e.message}"
+      nil
+    end
+
+    def http_get(url, timeout: 120)
+      uri = URI(url)
+      Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https",
+                       open_timeout: 30, read_timeout: timeout) do |http|
+        res = http.request(Net::HTTP::Get.new(uri))
+        res.code == "200" ? res.body : nil
+      end
+    end
+
+    def fetch_feed(show_name, feed_url, slug)
+      parsed = parse_feed(feed_url)
+      if parsed.nil?
+        puts "[#{show_name}] ERROR: Could not parse feed."
+        return
+      end
+
+      _title, entries = parsed
+      show_dir = DOWNLOAD_DIR.join(slug)
+      FileUtils.mkdir_p(show_dir)
+
+      new_count = 0
+      entries.each do |ep|
+        ep_url = ep[:url]
+        title = ep[:title]
+        next if ep_url.empty?
+
+        row = db.get_first_row("SELECT 1 FROM seen WHERE url=?", ep_url)
+        next if row
+
+        duration_sec = parse_duration(ep[:length])
+
+        safe_title = title.gsub(/[^\w\- ]/, "_").strip[0, 120]
+        ext = extension_for_type(ep[:type])
+        filepath = show_dir.join("#{safe_title}#{ext}")
+
+        if File.exist?(filepath)
+          db.execute(
+            "INSERT OR IGNORE INTO seen (url, title, show_slug, duration_sec) VALUES (?, ?, ?, ?)",
+            [ep_url, title, slug, duration_sec]
+          )
+          db.commit
+          next
+        end
+
+        begin
+          puts "[#{show_name}] Downloading: #{title}"
+          data = http_get(ep_url)
+          if data.nil?
+            raise "download returned non-200"
+          end
+          File.binwrite(filepath, data)
+
+          db.execute(
+            "INSERT OR IGNORE INTO seen (url, title, show_slug, duration_sec) VALUES (?, ?, ?, ?)",
+            [ep_url, title, slug, duration_sec]
+          )
+          db.commit
+          new_count += 1
+        rescue StandardError => e
+          puts "[#{show_name}] FAILED to download '#{title}': #{e.message}"
+        end
+      end
+
+      if new_count.positive?
+        puts "[#{show_name}] Downloaded #{new_count} new episode(s)."
+      else
+        puts "[#{show_name}] No new episodes."
+      end
+    end
+
+    def parse_duration(raw)
+      raw = raw.to_s.strip
+      return 0 if raw.empty?
+      if raw.include?(":")
+        raw.split(":").last.to_i
+      else
+        raw.to_i
+      end
+    rescue StandardError
+      0
+    end
+
+    def extension_for_type(type_str)
+      t = type_str.to_s.downcase
+      ".ogg" if t.include?("ogg")
+      ".m4a" if t.include?("m4a") || t.include?("aac")
+      ".mp3"
+    end
+
+    def list_shows(detail: false)
+      rows = db.execute("SELECT name, slug, feed_url, opml_import FROM shows ORDER BY name")
+      if rows.empty?
+        puts "No shows registered."
+        return
+      end
+
+      puts format("%-40s %-30s %-10s", "Show Name", "Slug", "Protected")
+      puts "-" * 80
+      rows.each do |name, slug, _feed_url, prot|
+        puts format("%-40s %-30s %-10s", name, slug, prot.to_i == 1 ? "yes" : "no")
+      end
+
+      if detail
+        puts "\nFeed URLs:"
+        rows.each do |_name, slug, feed_url, _prot|
+          puts "  #{slug}: #{feed_url}"
+        end
+      end
+    end
+
+    def close
+      db&.close
+    end
+  end
+end
+
+require "set"
+
+def main
+  args = ARGV.dup
+  f = Radio::Fetcher.new
+
+  if args.include?("--delete-show")
+    idx = args.index("--delete-show")
+    val = args[idx + 1]
+    if val.nil?
+      puts "Usage: fetch_podcasts.rb --delete-show <slug>"
+      exit 1
+    end
+    f.delete_show(val)
+  elsif args.include?("--add-show")
+    idx = args.index("--add-show")
+    val = args[idx + 1]
+    if val.nil?
+      puts "Usage: fetch_podcasts.rb --add-show <feed-url>"
+      exit 1
+    end
+    f.add_show(val)
+  elsif args.include?("--import-opml")
+    idx = args.index("--import-opml")
+    val = args[idx + 1]
+    if val.nil?
+      puts "Usage: fetch_podcasts.rb --import-opml <path-to-file.opml>"
+      exit 1
+    end
+    f.import_opml_file(val)
+  elsif args.include?("--list-shows")
+    f.list_shows(detail: args.include?("--detail"))
+  else
+    cfg = f.load_config
+    gp = cfg.fetch("gpodder", {})
+
+    if gp.fetch("enable", false)
+      puts "--- Syncing subscriptions from gpodder.net ---"
+      begin
+        f.sync_gpoddernet
+      rescue SystemExit
+        raise
+      rescue StandardError => e
+        puts "! gpodder sync failed (continuing with existing shows): #{e.message}"
+      end
+    end
+
+    shows = f.db.execute("SELECT name, feed_url, slug FROM shows")
+    if shows.empty?
+      puts "No shows registered. Import an OPML file, add a show, or enable gpodder sync."
+    else
+      puts "--- Fetching episodes for #{shows.size} show(s) ---"
+      shows.each do |show_name, feed_url, slug|
+        begin
+          f.fetch_feed(show_name, feed_url, slug)
+        rescue StandardError => e
+          puts "[#{show_name}] FAILED: #{e.message}"
+        end
+      end
+    end
+  end
+ensure
+  f&.close
+end
+
+main