vizcore 1.1.0 → 1.2.0

data/lib/vizcore/server/rack_app.rb

@@ -4,6 +4,7 @@ require "json"
 require "pathname"
 require "rack"
 require_relative "../control_preset"
+require_relative "../plugin_asset_policy"
 require_relative "websocket_handler"
 
 module Vizcore
@@ -29,6 +30,7 @@ module Vizcore
       # @param control_preset_path [String, Pathname, nil]
       # @param plugin_assets [Array<String, Pathname>, nil]
       # @param projector_mode [Boolean]
+      # @param runtime_status_provider [#call, nil]
       def initialize(
         frontend_root:,
         websocket_path: "/ws",
@@ -41,7 +43,8 @@ module Vizcore
         control_preset: nil,
         control_preset_path: nil,
         plugin_assets: nil,
-        projector_mode: false
+        projector_mode: false,
+        runtime_status_provider: nil
       )
         @frontend_root = frontend_root.expand_path
         @websocket_path = websocket_path
@@ -55,6 +58,7 @@ module Vizcore
         @control_preset_path = control_preset_path ? Pathname.new(control_preset_path).expand_path : nil
         @plugin_assets = normalize_plugin_assets(plugin_assets)
         @projector_mode = !!projector_mode
+        @runtime_status_provider = runtime_status_provider
       end
 
       # @param env [Hash]
@@ -96,7 +100,11 @@ module Vizcore
           control_preset_writable: !!@control_preset_path,
           control_preset_url: @control_preset_path ? CONTROL_PRESET_PATH : nil,
           plugin_assets: @plugin_assets.map { |asset| asset.fetch(:url) },
-          projector_mode: @projector_mode
+          projector_mode: @projector_mode,
+          websocket_clients: WebSocketHandler.connection_count,
+          dropped_frames: WebSocketHandler.dropped_frame_count,
+          websocket_backpressure: WebSocketHandler.backpressure_status,
+          runtime: runtime_status
         }
 
         if audio_file_available?
@@ -187,6 +195,35 @@ module Vizcore
         @projector_mode ? "projector" : "auto"
       end
 
+      def runtime_status
+        return {} unless @runtime_status_provider.respond_to?(:call)
+
+        normalize_runtime_status(@runtime_status_provider.call)
+      rescue StandardError => e
+        { "last_error" => e.message }
+      end
+
+      def normalize_runtime_status(values)
+        Hash(values || {}).each_with_object({}) do |(key, value), output|
+          output[key.to_s] = normalize_runtime_status_value(value)
+        end
+      rescue StandardError
+        {}
+      end
+
+      def normalize_runtime_status_value(value)
+        case value
+        when Hash
+          normalize_runtime_status(value)
+        when Array
+          value.map { |entry| normalize_runtime_status_value(entry) }
+        when Symbol
+          value.to_s
+        else
+          value
+        end
+      end
+
       def static_response(body, content_type:)
         headers = {
           "content-type" => content_type,
@@ -280,7 +317,23 @@ module Vizcore
           control = (action[:control] || action["control"]).to_s.strip
           return nil unless %w[blackout freeze].include?(control)
 
-          { type: "live_control", control: control }
+          live_control = { type: "live_control", control: control }
+          if action.key?(:value) || action.key?("value")
+            live_control[:value] = action[:value]
+            live_control[:value] = action["value"] if action.key?("value")
+          end
+          fade = action.key?(:fade) ? action[:fade] : action["fade"]
+          release = action.key?(:release) ? action[:release] : action["release"]
+          color = action.key?(:color) ? action[:color] : action["color"]
+          normalized_fade = finite_float(fade)
+          normalized_release = finite_float(release)
+          normalized_color = normalize_control_color(color)
+          return live_control if normalized_fade.nil? && normalized_release.nil? && !live_control.key?(:value) && normalized_color.nil?
+
+          live_control[:fade] = normalized_fade if normalized_fade
+          live_control[:release] = normalized_release if normalized_release
+          live_control[:color] = normalized_color if normalized_color
+          live_control
         end
       end
 
@@ -299,21 +352,115 @@ module Vizcore
         preset = values.is_a?(Hash) ? values : {}
         visual_settings = preset[:visual_settings] || preset["visual_settings"] || preset[:visualSettings] || preset["visualSettings"]
         midi_learn_bindings = preset[:midi_learn_bindings] || preset["midi_learn_bindings"] || preset[:midiLearnBindings] || preset["midiLearnBindings"]
+        scene_overrides = preset[:scene_overrides] || preset["scene_overrides"] || preset[:sceneOverrides] || preset["sceneOverrides"]
 
         {}.tap do |payload|
           payload["visual_settings"] = visual_settings if visual_settings.is_a?(Hash)
           payload["midi_learn_bindings"] = midi_learn_bindings if midi_learn_bindings.is_a?(Hash)
+          normalized_scene_overrides = normalize_scene_overrides(scene_overrides)
+          payload["scene_overrides"] = normalized_scene_overrides if normalized_scene_overrides
+        end
+      rescue StandardError
+        {}
+      end
+
+      def normalize_scene_overrides(values)
+        return nil unless values
+
+        raw_overrides = values.is_a?(Hash) ? values : {}
+        normalized = {}
+
+        raw_overrides.each do |raw_scene, raw_override|
+          scene_name = raw_scene.to_s.strip
+          next if scene_name.empty?
+
+          scene_override = normalize_scene_override(raw_override)
+          next if scene_override.empty?
+
+          normalized[scene_name] = scene_override
+        end
+
+        normalized.empty? ? nil : normalized
+      rescue StandardError
+        nil
+      end
+
+      def normalize_scene_override(value)
+        input = value.is_a?(Hash) ? value : {}
+
+        {
+          visual_settings: input[:visual_settings] || input["visual_settings"] || input[:visualSettings] || input["visualSettings"],
+          midi_learn_bindings: input[:midi_learn_bindings] || input["midi_learn_bindings"] || input[:midiLearnBindings] || input["midiLearnBindings"] || input[:midi] || input["midi"]
+        }.each_with_object({}) do |(key, value), output|
+          output[key.to_s] = value if value.is_a?(Hash)
         end
       rescue StandardError
         {}
       end
 
+      def finite_float(value)
+        numeric = Float(value)
+        return numeric if numeric.finite?
+
+        nil
+      rescue ArgumentError, TypeError
+        nil
+      end
+
+      def normalize_control_color(value)
+        return nil if value.nil?
+        if value.is_a?(Array)
+          return nil unless (3..4).cover?(value.length)
+
+          channels = Array(value).map { |entry| Float(entry, exception: false) }
+          return nil if channels.include?(nil)
+
+          rgb = channels.take(3)
+          alpha = channels[3]
+          normalized_rgb = if rgb.all? { |channel| channel.between?(0.0, 1.0) }
+            rgb
+          else
+            rgb.map { |channel| channel / 255.0 }
+          end
+          normalized = normalized_rgb.map { |channel| [0.0, [1.0, channel].min].max }
+          return alpha.nil? ? normalized : normalized + [normalize_control_alpha(alpha)]
+        end
+
+        raw = value.to_s.strip
+        match = raw.match(/^#([0-9a-fA-F]{3}|[0-9a-fA-F]{4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/)
+        return nil unless match
+
+        raw_hex = match[1]
+        hex = raw_hex.length == 3 || raw_hex.length == 4 ? raw_hex.chars.map { |entry| "#{entry}#{entry}" }.join("") : raw_hex
+
+        [
+          Integer("0x#{hex[0, 2]}", 16),
+          Integer("0x#{hex[2, 2]}", 16),
+          Integer("0x#{hex[4, 2]}", 16),
+          Integer("0x#{hex[6, 2]}", 16)
+        ].take(raw_hex.length > 4 ? 4 : 3).map { |channel| [0.0, [1.0, channel / 255.0].min].max }
+      rescue ArgumentError, TypeError
+        nil
+      end
+
+      def normalize_control_alpha(value)
+        return nil if value.nil?
+
+        alpha = Float(value, exception: false)
+        return nil if alpha.nil?
+
+        return [0.0, [1.0, alpha].min].max if alpha.between?(0.0, 1.0)
+
+        [0.0, [1.0, alpha / 255.0].min].max
+      end
+
       def normalize_plugin_assets(values)
         Array(values).each_with_index.filter_map do |value, index|
           raw_value = value.to_s.strip
           next if raw_value.empty?
 
-          path = value.is_a?(Pathname) ? value.expand_path : Pathname.new(raw_value).expand_path
+          raw_path = value.is_a?(Pathname) ? value.expand_path : Pathname.new(raw_value).expand_path
+          path = Vizcore::PluginAssetPolicy.validate!(raw_path)
           {
             path: path,
             url: "#{PLUGIN_ASSET_PREFIX}#{index}/#{rack_escape_path(path.basename.to_s)}"