helios-videos 0.1.0 → 0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 29b809949f048f47c75bea77d368ef5c74e106abcd02ef2255e4552cba30bcdb
-  data.tar.gz: 4bd1f685e4e2b80772edc90e5e9ff4a64f1c17e4aa28cad0936540bfd3be7d27
+  metadata.gz: 5e3128ca8453dd9d7bb22e3cc19315474a4dd398d3ba228a212ed54e9c8e2818
+  data.tar.gz: f7ad28e93d4fb7eaebd2965cdee27d26e5f01d0a48aadf0821234a770f1380bc
 SHA512:
-  metadata.gz: aa5eff29b5557d5403002db4aaf971eb4d8181b4283346f07944daaa5bfefb42d9c6f7e8095949a726829c4093979b61ed431bdb977144d5f74cdba4519bae7b
-  data.tar.gz: d6ca7b0c69d316b7e71356830832561e602dab3622161453a86a38bfd878fdf80d6e0dd9380a9607209b17e0c179927b35ca4d5e81e333a9426d2465ad9755ba
+  metadata.gz: 7960c948c478d4fcc24dff6ab49254628727836ba32f7c0d2a5b1a897da932d0f8b143d651466df0c53ce51e32cb16cf439ae248296ae9859d5f8691da3b9c03
+  data.tar.gz: 19238d28e62666f25a1165fe1272d3922ed479b5203a9d52dcac93cdccbee604b33b78fc151a7f572b26728ba5533ba4b4abbc0ff2cc523ac0cce4133f0c24e9

data/README.md

@@ -29,24 +29,90 @@ Helios::Videos.configure do |config|
   # Choose your video processor
   config.processor = :cloudflare  # or :mux
 
+  # Parent controller for admin views (must provide authentication)
+  config.admin_parent_controller = "Admin::BaseController"
+
+  # Use an existing model instead of Helios::Videos::Video (optional)
+  # Your model must include Helios::Videos::VideoConcern
+  # and have the required columns: key, playback_urls (jsonb),
+  # requires_signed_urls (boolean), provider (string)
+  config.video_model = "Video"  # default: "Helios::Videos::Video"
+
   # Cloudflare Stream settings
   config.cloudflare_account_id = ENV["CLOUDFLARE_ACCOUNT_ID"]
   config.cloudflare_api_token  = ENV["CLOUDFLARE_API_TOKEN"]
+  config.cloudflare_customer_subdomain = ENV["CLOUDFLARE_CUSTOMER_SUBDOMAIN"]
   config.require_signed_urls   = true
 
   # OR Mux settings
-  # config.processor       = :mux
-  # config.mux_token_id    = ENV["MUX_TOKEN_ID"]
+  # config.processor        = :mux
+  # config.mux_token_id     = ENV["MUX_TOKEN_ID"]
   # config.mux_token_secret = ENV["MUX_TOKEN_SECRET"]
 end
 ```
 
+## Using an existing model
+
+If your app already has a Video model, you can include the gem's functionality via a concern instead of using `Helios::Videos::Video`:
+
+1. Add the required columns to your existing table:
+
+```ruby
+add_column :videos, :key, :string           # service identifier (Mux asset ID or Cloudflare UID)
+add_column :videos, :playback_urls, :jsonb
+add_column :videos, :requires_signed_urls, :boolean, default: false, null: false
+add_column :videos, :provider, :string       # "cloudflare" or "mux"
+```
+
+2. Include the concern in your model:
+
+```ruby
+class Video < ApplicationRecord
+  include Helios::Videos::VideoConcern
+end
+```
+
+3. Set the model name in the initializer:
+
+```ruby
+config.video_model = "Video"
+```
+
+The concern adds: `video_file` and `thumbnail_image` ActiveStorage attachments, `provider` enum, automatic ingestion via background job on create, per-video processor routing, signed URL support, and thumbnail downloads.
+
+### Upgrading from pre-0.2.0 (adding the provider column)
+
+If you installed helios-videos before the `provider` column was added, you need to add it to your existing table. For apps using the gem's own table:
+
+```bash
+bin/rails helios_videos:install:migrations
+bin/rails db:migrate
+```
+
+For apps using a custom video model with their own table, create a migration:
+
+```ruby
+class AddProviderToVideos < ActiveRecord::Migration[8.0]
+  def change
+    add_column :videos, :provider, :string
+    add_index :videos, :provider
+
+    # Backfill existing videos with their current provider
+    reversible do |dir|
+      dir.up do
+        Video.where(provider: nil).update_all(provider: 'cloudflare') # or 'mux'
+      end
+    end
+  end
+end
+```
+
 ## Routes
 
 Mount the engine:
 
 ```ruby
-mount Helios::Videos::Engine, at: "/helios_videos"
+mount Helios::Videos::Engine, at: "/videos"
 ```
 
 ## Usage
@@ -54,7 +120,7 @@ mount Helios::Videos::Engine, at: "/helios_videos"
 ### Creating a video
 
 ```ruby
-video = Helios::Videos::Video.new(name: "My Video")
+video = Helios::Videos.video_class.new(name: "My Video")
 video.video_file.attach(params[:video_file])
 video.save!
 # CheckVideoJob will automatically ingest the video into your configured processor
@@ -66,19 +132,91 @@ video.save!
 <%= video.player_component %>
 ```
 
+Each video renders using the correct player for its `provider` — Cloudflare videos use video.js with HLS, Mux videos use the mux-player element. This means both providers can coexist in the same app during and after a migration.
+
+### Programmatic access
+
+```ruby
+video.playback_url                      # unsigned HLS URL
+video.playback_url(signed: true)        # signed URL (Cloudflare)
+video.signed_url(expiration: 2.hours)   # shorthand
+video.download_url                      # downloadable MP4 URL
+video.download_and_store_thumbnail!     # fetch and attach thumbnail
+video.check_for_processing!             # manually trigger ingestion
+video.effective_processor               # the processor for this video's provider
+```
+
 ### With helios-press
 
 When both gems are loaded, video blocks are automatically available in the block editor. Videos can be dragged into block placeholders for direct upload and processing.
 
+## Migrating between providers
+
+helios-videos includes built-in tooling for migrating videos between Cloudflare Stream and Mux. Migration happens record-by-record in background jobs so long ingestions don't block each other.
+
+### How it works
+
+The migration pipeline has three stages:
+
+1. **MigrateVideosJob** (orchestrator) — finds all videos on the source provider, enqueues a conversion job for each one.
+2. **ConvertVideoJob** (per-video) — gets a download URL from the source, submits it to the destination for ingestion.
+   - For **Mux destinations**: playback IDs come back immediately, so the provider is flipped right away.
+   - For **Cloudflare destinations**: processing takes time, so a check job is enqueued.
+3. **CheckIngestionJob** (Cloudflare destination only) — polls Cloudflare every 30 seconds until the video is ready, then flips the provider.
+
+### Running a migration
+
+Make sure both providers are configured in your initializer (you need credentials for both), then enqueue the orchestrator:
+
+```ruby
+# Migrate all Cloudflare videos to Mux
+Helios::Videos::Migration::MigrateVideosJob.perform_later(
+  from: "cloudflare",
+  to: "mux"
+)
+
+# Or migrate in batches
+Helios::Videos::Migration::MigrateVideosJob.perform_later(
+  from: "cloudflare",
+  to: "mux",
+  batch_size: 10
+)
+```
+
+During migration, both providers are served concurrently — each video's `provider` column determines which processor handles playback. Videos that haven't been migrated yet continue to work on the original provider.
+
+### Migrate a single video
+
+```ruby
+Helios::Videos::Migration::ConvertVideoJob.perform_later(
+  video_id: 42,
+  from: "cloudflare",
+  to: "mux"
+)
+```
+
 ## JavaScript
 
-Register the Stimulus controllers in your host app:
+If your host app needs the video block Stimulus controller:
 
 ```javascript
-import { HeliosVideoBlockController } from "helios-videos"
+import { HeliosVideoBlockController } from "helios/videos"
 application.register("video-block", HeliosVideoBlockController)
 ```
 
+### Vite
+
+If your host app uses Vite, add an alias so Vite can resolve the gem's JavaScript:
+
+```typescript
+// vite.config.mts
+resolve: {
+  alias: {
+    'helios/videos': resolve(__dirname, '/path/to/helios-videos/app/javascript/helios/videos'),
+  },
+},
+```
+
 ## License
 
 Proprietary. All rights reserved.

data/app/controllers/helios/videos/admin/base_controller.rb

@@ -1,7 +1,7 @@
 module Helios
   module Videos
     module Admin
-      class BaseController < ::ApplicationController
+      class BaseController < Helios::Videos.configuration.admin_parent_controller.constantize
       end
     end
   end

data/app/controllers/helios/videos/admin/videos_controller.rb

@@ -4,6 +4,14 @@ module Helios
       class VideosController < Helios::Videos::Admin::BaseController
         before_action :set_video
 
+        def show
+          render json: {
+            id: @video.id,
+            ready: @video.key.present? && @video.playback_urls.present?,
+            player_html: @video.key.present? ? @video.player_component : nil
+          }
+        end
+
         def update
           if @video.update(video_params)
             head :ok
@@ -15,7 +23,7 @@ module Helios
         private
 
         def set_video
-          @video = Video.find(params[:id])
+          @video = Helios::Videos.video_class.find(params[:id])
         end
 
         def video_params

data/app/jobs/helios/videos/migration/check_ingestion_job.rb

@@ -0,0 +1,40 @@
+module Helios
+  module Videos
+    module Migration
+      # Polls the destination provider (Cloudflare) to check if a migrated video
+      # has finished processing. Once ready, flips the provider column.
+      #
+      # Only needed for Cloudflare as a destination — Mux returns playback IDs
+      # immediately so no polling is required.
+      class CheckIngestionJob < Helios::Videos::ApplicationJob
+        queue_as :default
+
+        MAX_ATTEMPTS = 60 # ~30 minutes with 30s intervals
+
+        # @param video_id [Integer]
+        # @param to [String] destination provider
+        # @param attempt [Integer] current attempt number
+        def perform(video_id:, to:, attempt: 1)
+          video = Helios::Videos.video_class.find(video_id)
+          dest_processor = Helios::Videos.processor_for(to.to_sym)
+
+          if dest_processor.ready?(video)
+            video.update!(provider: to)
+            Rails.logger.info("[helios-videos] Migration: video #{video_id} is ready on #{to}, provider flipped (attempt #{attempt})")
+
+            dest_processor.download_thumbnail!(video)
+          elsif attempt >= MAX_ATTEMPTS
+            Rails.logger.error("[helios-videos] Migration: video #{video_id} still not ready after #{MAX_ATTEMPTS} attempts, giving up")
+          else
+            Rails.logger.info("[helios-videos] Migration: video #{video_id} not yet ready on #{to}, retrying (attempt #{attempt})")
+            CheckIngestionJob.set(wait: 30.seconds).perform_later(
+              video_id: video_id,
+              to: to,
+              attempt: attempt + 1
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/app/jobs/helios/videos/migration/convert_video_job.rb

@@ -0,0 +1,61 @@
+module Helios
+  module Videos
+    module Migration
+      # Per-video conversion job: gets a download URL from the source provider,
+      # submits it to the destination provider for ingestion, and updates the
+      # video record.
+      #
+      # For Mux destinations, the playback ID comes back immediately so the
+      # provider is flipped right away.
+      #
+      # For Cloudflare destinations, a CheckIngestionJob is enqueued to poll
+      # for readiness before flipping the provider.
+      class ConvertVideoJob < Helios::Videos::ApplicationJob
+        queue_as :default
+
+        # @param video_id [Integer]
+        # @param from [String] source provider
+        # @param to [String] destination provider
+        def perform(video_id:, from:, to:)
+          video = Helios::Videos.video_class.find(video_id)
+
+          unless video.provider == from
+            Rails.logger.info("[helios-videos] Migration: video #{video_id} is already on #{video.provider}, skipping")
+            return
+          end
+
+          source_processor = Helios::Videos.processor_for(from.to_sym)
+          dest_processor = Helios::Videos.processor_for(to.to_sym)
+
+          # Get download URL from source
+          source_url = source_processor.download_url(video, expiration: 12.hours)
+          unless source_url.present?
+            Rails.logger.error("[helios-videos] Migration: could not get download URL for video #{video_id} from #{from}")
+            return
+          end
+
+          Rails.logger.info("[helios-videos] Migration: ingesting video #{video_id} from #{from} -> #{to}")
+
+          # Submit to destination processor
+          dest_processor.ingest_from_url!(video, source_url, provider: to)
+
+          if to.to_sym == :mux
+            # Mux returns playback IDs immediately — flip provider now
+            video.update!(provider: to)
+            Rails.logger.info("[helios-videos] Migration: video #{video_id} migrated to #{to}")
+
+            # Download new thumbnail from the new provider
+            dest_processor.download_thumbnail!(video)
+          else
+            # Cloudflare needs processing time — enqueue a check
+            CheckIngestionJob.set(wait: 30.seconds).perform_later(
+              video_id: video_id,
+              to: to,
+              attempt: 1
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/app/jobs/helios/videos/migration/migrate_videos_job.rb

@@ -0,0 +1,31 @@
+module Helios
+  module Videos
+    module Migration
+      # Orchestrator job: finds all videos on the source provider and enqueues
+      # a ConvertVideoJob for each one. Processes record-by-record so long
+      # ingestions don't block each other.
+      class MigrateVideosJob < Helios::Videos::ApplicationJob
+        queue_as :default
+
+        # @param from [String] source provider ("cloudflare" or "mux")
+        # @param to [String] destination provider ("cloudflare" or "mux")
+        # @param batch_size [Integer] how many to enqueue per run (default: all)
+        def perform(from:, to:, batch_size: nil)
+          video_class = Helios::Videos.video_class
+
+          videos = video_class.where(provider: from).where.not(key: [nil, ""])
+          videos = videos.limit(batch_size) if batch_size.present?
+
+          total = videos.count
+          Rails.logger.info("[helios-videos] Migration: enqueuing #{total} videos from #{from} -> #{to}")
+
+          videos.find_each do |video|
+            ConvertVideoJob.perform_later(video_id: video.id, from: from, to: to)
+          end
+
+          Rails.logger.info("[helios-videos] Migration: all #{total} conversion jobs enqueued")
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/helios/videos/video_concern.rb

@@ -0,0 +1,81 @@
+module Helios
+  module Videos
+    module VideoConcern
+      extend ActiveSupport::Concern
+
+      included do
+        has_one_attached :video_file
+        has_one_attached :thumbnail_image
+
+        enum :provider, { cloudflare: 'cloudflare', mux: 'mux' }
+
+        if defined?(Helios::Press::Block)
+          belongs_to :block, class_name: "Helios::Press::Block", optional: true
+        end
+
+        before_validation :set_default_provider, on: :create
+        after_create :enqueue_check_for_video
+        before_destroy :delete_from_service
+      end
+
+      # Returns the processor for this specific video based on its provider column,
+      # falling back to the globally configured processor.
+      def effective_processor
+        if respond_to?(:provider) && provider.present?
+          Helios::Videos.processor_for(provider.to_sym)
+        else
+          Helios::Videos.processor
+        end
+      end
+
+      def player_component(muted: false, expiration: 4.hours)
+        effective_processor.player_component(self, muted: muted, expiration: expiration)
+      end
+
+      def playback_url(signed: false, expiration: 4.hours)
+        effective_processor.playback_url(self, signed: signed, expiration: expiration)
+      end
+
+      def signed_url(expiration: 4.hours)
+        playback_url(signed: true, expiration: expiration)
+      end
+
+      def download_url(expiration: 4.hours)
+        effective_processor.download_url(self, expiration: expiration)
+      end
+
+      def download_and_store_thumbnail!(time: "3s")
+        effective_processor.download_thumbnail!(self, time: time)
+      end
+
+      def thumbnail_url(time: "4s")
+        thumbnail_image.attached? ? thumbnail_image : nil
+      end
+
+      def requires_signed_urls?
+        respond_to?(:requires_signed_urls) ? super : false
+      end
+
+      def check_for_processing!
+        effective_processor.ingest!(self)
+      end
+
+      private
+
+      def set_default_provider
+        self.provider ||= Helios::Videos.configuration.processor.to_s
+      end
+
+      def enqueue_check_for_video
+        Helios::Videos::CheckVideoJob.perform_later(video: self)
+      end
+
+      def delete_from_service
+        effective_processor.delete!(self)
+      rescue => e
+        Rails.logger.warn("[helios-videos] Failed to delete video #{id} from service: #{e.message}")
+        true # Don't block destroy
+      end
+    end
+  end
+end

data/app/models/helios/videos/video.rb

@@ -3,57 +3,12 @@ module Helios
     class Video < ActiveRecord::Base
       self.table_name = "helios_videos_videos"
 
+      include Helios::Videos::VideoConcern
+
       # Optional association to helios-press block (when both gems are loaded)
       if defined?(Helios::Press::Block)
         belongs_to :block, class_name: "Helios::Press::Block", optional: true
       end
-
-      has_one_attached :video_file
-      has_one_attached :thumbnail_image
-
-      after_create :enqueue_check_for_video
-      before_destroy :delete_from_service
-
-      def player_component(muted: false, expiration: 4.hours)
-        Helios::Videos.processor.player_component(self, muted: muted, expiration: expiration)
-      end
-
-      def playback_url(signed: false, expiration: 4.hours)
-        Helios::Videos.processor.playback_url(self, signed: signed, expiration: expiration)
-      end
-
-      def signed_url(expiration: 4.hours)
-        playback_url(signed: true, expiration: expiration)
-      end
-
-      def download_and_store_thumbnail!(time: "3s")
-        Helios::Videos.processor.download_thumbnail!(self, time: time)
-      end
-
-      def thumbnail_url(time: "4s")
-        thumbnail_image.attached? ? thumbnail_image : nil
-      end
-
-      def requires_signed_urls?
-        respond_to?(:requires_signed_urls) ? requires_signed_urls : false
-      end
-
-      def check_for_processing!
-        Helios::Videos.processor.ingest!(self)
-      end
-
-      private
-
-      def enqueue_check_for_video
-        CheckVideoJob.perform_later(video: self)
-      end
-
-      def delete_from_service
-        Helios::Videos.processor.delete!(self)
-      rescue => e
-        Rails.logger.warn("[helios-videos] Failed to delete video #{id} from service: #{e.message}")
-        true # Don't block destroy
-      end
     end
   end
 end

data/config/routes.rb

@@ -1,5 +1,5 @@
 Helios::Videos::Engine.routes.draw do
   namespace :admin do
-    resources :videos, only: [:update]
+    resources :videos, only: [:show, :update]
   end
 end

data/db/migrate/20250510000001_create_helios_videos_videos.rb

@@ -5,6 +5,7 @@ class CreateHeliosVideosVideos < ActiveRecord::Migration[8.0]
       t.string :key
       t.jsonb :playback_urls
       t.boolean :requires_signed_urls, default: false, null: false
+      t.string :provider
       t.integer :block_id
 
       t.timestamps
@@ -12,5 +13,6 @@ class CreateHeliosVideosVideos < ActiveRecord::Migration[8.0]
 
     add_index :helios_videos_videos, :block_id
     add_index :helios_videos_videos, :key, unique: true
+    add_index :helios_videos_videos, :provider
   end
 end

data/db/migrate/20250524000001_add_provider_to_helios_videos_videos.rb

@@ -0,0 +1,8 @@
+class AddProviderToHeliosVideosVideos < ActiveRecord::Migration[8.0]
+  def change
+    unless column_exists?(:helios_videos_videos, :provider)
+      add_column :helios_videos_videos, :provider, :string
+      add_index :helios_videos_videos, :provider
+    end
+  end
+end

data/lib/helios/videos/configuration.rb

@@ -4,6 +4,7 @@ module Helios
       attr_accessor :processor,
                     :require_signed_urls,
                     :admin_parent_controller,
+                    :video_model,
                     # Cloudflare
                     :cloudflare_account_id,
                     :cloudflare_api_token,
@@ -16,6 +17,7 @@ module Helios
         @processor = :cloudflare
         @require_signed_urls = true
         @admin_parent_controller = "ApplicationController"
+        @video_model = "Helios::Videos::Video"
         @cloudflare_account_id = ENV["CLOUDFLARE_ACCOUNT_ID"]
         @cloudflare_api_token = ENV["CLOUDFLARE_API_TOKEN"]
         @cloudflare_customer_subdomain = ENV["CLOUDFLARE_CUSTOMER_SUBDOMAIN"]

data/lib/helios/videos/engine.rb

@@ -4,11 +4,23 @@ module Helios
       isolate_namespace Helios::Videos
 
       # When helios-press is also loaded, mix video support into Block
-      initializer "helios_videos.integrate_with_press" do
+      initializer "helios_videos.integrate_with_press", after: :load_config_initializers do
         ActiveSupport.on_load(:active_record) do
           if defined?(Helios::Press::Block)
+            unless Helios::Press::Block.reflect_on_association(:video)
+              Helios::Press::Block.class_eval do
+                has_one :video, class_name: Helios::Videos.configuration.video_model, foreign_key: :block_id, dependent: :destroy
+              end
+            end
+          end
+        end
+      end
+
+      config.to_prepare do
+        if defined?(Helios::Press::Block)
+          unless Helios::Press::Block.reflect_on_association(:video)
             Helios::Press::Block.class_eval do
-              has_one :video, class_name: "Helios::Videos::Video", foreign_key: :block_id, dependent: :destroy
+              has_one :video, class_name: Helios::Videos.configuration.video_model, foreign_key: :block_id, dependent: :destroy
             end
           end
         end

data/lib/helios/videos/processor.rb

@@ -33,6 +33,24 @@ module Helios
         raise NotImplementedError, "#{self.class}#signed_token must be implemented"
       end
 
+      # Return a downloadable MP4 URL for the video (used for migration between providers).
+      def download_url(video, expiration: 4.hours)
+        raise NotImplementedError, "#{self.class}#download_url must be implemented"
+      end
+
+      # Ingest a video from an external URL (used during migration between providers).
+      # Unlike ingest!, this takes a source URL directly rather than using ActiveStorage.
+      # Should set new key and playback_urls on the video without changing provider.
+      def ingest_from_url!(video, source_url, provider:)
+        raise NotImplementedError, "#{self.class}#ingest_from_url! must be implemented"
+      end
+
+      # Check whether a video has finished processing and is ready for playback.
+      # Used by migration CheckIngestionJob to poll for readiness.
+      def ready?(video)
+        raise NotImplementedError, "#{self.class}#ready? must be implemented"
+      end
+
       # Download and store the video thumbnail.
       def download_thumbnail!(video, time: "3s")
         raise NotImplementedError, "#{self.class}#download_thumbnail! must be implemented"

data/lib/helios/videos/processors/cloudflare.rb

@@ -66,6 +66,64 @@ module Helios
           end
         end
 
+        def ingest_from_url!(video, source_url, provider:)
+          uri = URI("https://api.cloudflare.com/client/v4/accounts/#{account_id}/stream/copy")
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+
+          request = Net::HTTP::Post.new(uri.request_uri, {
+            "Authorization" => "Bearer #{api_token}",
+            "Content-Type" => "application/json"
+          })
+
+          request.body = {
+            url: source_url,
+            meta: { name: video.name },
+            requireSignedURLs: config.require_signed_urls
+          }.to_json
+
+          response = http.request(request)
+          body = JSON.parse(response.body)
+
+          unless response.is_a?(Net::HTTPSuccess)
+            Rails.logger.error("[helios-videos] Cloudflare migration ingest error: #{response.code} - #{response.body}")
+            raise "Cloudflare migration ingest failed: #{response.code}"
+          end
+
+          # Store the new Cloudflare key and playback URLs, but don't flip provider yet.
+          # The CheckIngestionJob will flip it once the video is ready.
+          video.update!(
+            key: body["result"]["uid"],
+            playback_urls: body["result"]["playback"],
+            requires_signed_urls: config.require_signed_urls
+          )
+
+          Rails.logger.info("[helios-videos] Migration: video #{video.id} submitted to Cloudflare: #{video.key}")
+        end
+
+        def ready?(video)
+          return false unless video.key.present?
+
+          uri = URI("https://api.cloudflare.com/client/v4/accounts/#{account_id}/stream/#{video.key}")
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+
+          request = Net::HTTP::Get.new(uri.request_uri, {
+            "Authorization" => "Bearer #{api_token}",
+            "Content-Type" => "application/json"
+          })
+
+          response = http.request(request)
+          return false unless response.is_a?(Net::HTTPSuccess)
+
+          body = JSON.parse(response.body)
+          status = body.dig("result", "status", "state")
+          status == "ready"
+        rescue => e
+          Rails.logger.warn("[helios-videos] Migration: error checking readiness for video #{video.id}: #{e.message}")
+          false
+        end
+
         def playback_url(video, signed: false, expiration: 4.hours)
           return nil unless video.key.present?
 
@@ -79,7 +137,14 @@ module Helios
         end
 
         def player_component(video, muted: false, expiration: 4.hours)
-          return "(VIDEO NOT AVAILABLE)" unless video.key.present?
+          unless video.key.present?
+            return <<~HTML.html_safe
+              <div class="text-center p-4 text-muted">
+                <div class="spinner-border spinner-border-sm me-2" role="status"></div>
+                Processing video...
+              </div>
+            HTML
+          end
 
           video_src = playback_url(video, signed: video.requires_signed_urls?, expiration: expiration)
 
@@ -99,7 +164,7 @@ module Helios
           HTML
         end
 
-        def signed_token(video, expiration: 4.hours)
+        def signed_token(video, expiration: 4.hours, downloadable: false)
           key_id, private_key = fetch_signing_key
 
           now = Time.now.to_i
@@ -109,10 +174,19 @@ module Helios
             exp: now + expiration.to_i,
             nbf: now - 60
           }
+          payload[:downloadable] = true if downloadable
 
           JWT.encode(payload, private_key, "RS256", typ: "JWT", kid: key_id)
         end
 
+        def download_url(video, expiration: 4.hours)
+          return nil unless video.key.present?
+
+          token = signed_token(video, expiration: expiration, downloadable: true)
+          subdomain = customer_subdomain(video)
+          "https://#{subdomain}.cloudflarestream.com/#{token}/downloads/default.mp4"
+        end
+
         def download_thumbnail!(video, time: "3s")
           return false unless video.key.present?
           return true if video.thumbnail_image.attached?

data/lib/helios/videos/processors/mux.rb

@@ -14,8 +14,9 @@ module Helios
           end
 
           assets_api = MuxRuby::AssetsApi.new
+          input_settings = MuxRuby::InputSettings.new(url: video.video_file.url)
           create_request = MuxRuby::CreateAssetRequest.new(
-            input: video.video_file.url,
+            input: [input_settings],
             playback_policy: [MuxRuby::PlaybackPolicy::PUBLIC]
           )
 
@@ -30,6 +31,51 @@ module Helios
           Rails.logger.info("[helios-videos] Video #{video.id} ingested into Mux: #{video.key}")
         end
 
+        def ingest_from_url!(video, source_url, provider:)
+          require "mux_ruby"
+
+          MuxRuby.configure do |c|
+            c.username = config.mux_token_id
+            c.password = config.mux_token_secret
+          end
+
+          assets_api = MuxRuby::AssetsApi.new
+          input_settings = MuxRuby::InputSettings.new(url: source_url)
+          create_request = MuxRuby::CreateAssetRequest.new(
+            input: [input_settings],
+            playback_policy: [MuxRuby::PlaybackPolicy::PUBLIC],
+            mp4_support: "standard"
+          )
+
+          response = assets_api.create_asset(create_request)
+          asset = response.data
+
+          video.update!(
+            key: asset.id,
+            playback_urls: { "hls" => "https://stream.mux.com/#{asset.playback_ids&.first&.id}.m3u8" }
+          )
+
+          Rails.logger.info("[helios-videos] Migration: video #{video.id} ingested into Mux: #{video.key}")
+        end
+
+        def ready?(video)
+          return false unless video.key.present?
+
+          require "mux_ruby"
+
+          MuxRuby.configure do |c|
+            c.username = config.mux_token_id
+            c.password = config.mux_token_secret
+          end
+
+          assets_api = MuxRuby::AssetsApi.new
+          asset = assets_api.get_asset(video.key)
+          asset.data.status == "ready"
+        rescue => e
+          Rails.logger.warn("[helios-videos] Migration: error checking Mux readiness for video #{video.id}: #{e.message}")
+          false
+        end
+
         def delete!(video)
           return unless video.key.present?
 
@@ -53,10 +99,16 @@ module Helios
         end
 
         def player_component(video, muted: false, expiration: 4.hours)
-          return "(VIDEO NOT AVAILABLE)" unless video.key.present?
+          unless video.key.present? && extract_playback_id(video).present?
+            return <<~HTML.html_safe
+              <div class="text-center p-4 text-muted">
+                <div class="spinner-border spinner-border-sm me-2" role="status"></div>
+                Processing video...
+              </div>
+            HTML
+          end
 
           playback_id = extract_playback_id(video)
-          return "(VIDEO NOT AVAILABLE)" unless playback_id.present?
 
           <<~HTML.html_safe
             <mux-player
@@ -73,6 +125,16 @@ module Helios
           nil # Mux uses playback IDs, not signed tokens in the same way
         end
 
+        def download_url(video, expiration: 4.hours)
+          return nil unless video.key.present?
+
+          playback_id = extract_playback_id(video)
+          return nil unless playback_id.present?
+
+          # Mux provides static renditions at predictable URLs
+          "https://stream.mux.com/#{playback_id}/high.mp4"
+        end
+
         def download_thumbnail!(video, time: "3s")
           return false unless video.key.present?
           return true if video.thumbnail_image.attached?

data/lib/helios/videos/version.rb

@@ -1,5 +1,5 @@
 module Helios
   module Videos
-    VERSION = "0.1.0"
+    VERSION = "0.2"
   end
 end

data/lib/helios/videos.rb

@@ -16,16 +16,24 @@ module Helios
         yield(configuration)
       end
 
+      def video_class
+        configuration.video_model.constantize
+      end
+
       def processor
         @processor = nil if @processor_type != configuration.processor
         @processor_type = configuration.processor
-        @processor ||= case configuration.processor
+        @processor ||= processor_for(configuration.processor)
+      end
+
+      def processor_for(provider_type)
+        case provider_type.to_sym
         when :cloudflare
           Processors::Cloudflare.new(configuration)
         when :mux
           Processors::Mux.new(configuration)
         else
-          raise "Unknown video processor: #{configuration.processor}. Use :cloudflare or :mux"
+          raise "Unknown video processor: #{provider_type}. Use :cloudflare or :mux"
         end
       end
     end

data/lib/helios-videos.rb

@@ -0,0 +1 @@
+require "helios/videos"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: helios-videos
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: '0.2'
 platform: ruby
 authors:
 - Jason Fleetwood-Boldt
@@ -57,12 +57,18 @@ files:
 - app/javascript/helios/videos/index.js
 - app/jobs/helios/videos/application_job.rb
 - app/jobs/helios/videos/check_video_job.rb
+- app/jobs/helios/videos/migration/check_ingestion_job.rb
+- app/jobs/helios/videos/migration/convert_video_job.rb
+- app/jobs/helios/videos/migration/migrate_videos_job.rb
 - app/mailers/helios/videos/application_mailer.rb
+- app/models/concerns/helios/videos/video_concern.rb
 - app/models/helios/videos/application_record.rb
 - app/models/helios/videos/video.rb
 - app/views/layouts/helios/videos/application.html.erb
 - config/routes.rb
 - db/migrate/20250510000001_create_helios_videos_videos.rb
+- db/migrate/20250524000001_add_provider_to_helios_videos_videos.rb
+- lib/helios-videos.rb
 - lib/helios/videos.rb
 - lib/helios/videos/configuration.rb
 - lib/helios/videos/engine.rb