openc3 7.2.1 → 7.3.0

data/lib/openc3/models/scope_model.rb

@@ -43,6 +43,38 @@ module OpenC3
   class ScopeModel < Model
     PRIMARY_KEY = "openc3_scopes"
 
+    # Default thresholds used by the System Health tool and the metrics
+    # microservices. Stored in the 'system_health' setting as a JSON string.
+    SYSTEM_HEALTH_DEFAULTS = {
+      "cpu" => {
+        "redThreshold" => 90.0,
+        "yellowThreshold" => 80.0,
+        "snoozeMinutes" => 15,
+        "lastTriggerTimeRed" => nil,  # timestamp or nil
+        "lastTriggerTimeYellow" => nil,  # timestamp or nil
+        "sustainedSeconds" => 15
+      },
+      "memory" => {
+        "redThreshold" => 90.0,
+        "yellowThreshold" => 80.0,
+        "snoozeMinutes" => 15,
+        "lastTriggerTimeRed" => nil,  # timestamp or nil
+        "lastTriggerTimeYellow" => nil,  # timestamp or nil
+        "sustainedSeconds" => 15
+      },
+      "disk" => {
+        "redThreshold" => 90.0,
+        "yellowThreshold" => 80.0,
+        "snoozeMinutes" => 720,  # 12 hours
+        "lastTriggerTimeRed" => nil,  # timestamp or nil
+        "lastTriggerTimeYellow" => nil,  # timestamp or nil
+        "sustainedSeconds" => 60
+      },
+      "global" => {
+        "enableAlerts" => true
+      }
+    }
+
     attr_accessor :children
     attr_accessor :text_log_cycle_time
     attr_accessor :text_log_cycle_size
@@ -407,36 +439,8 @@ module OpenC3
       SettingModel.set({name: "news_feed", data: true}, scope: @scope)
 
       setting = SettingModel.get(name: "system_health")
-      system_health_data = {
-        "cpu" => {
-          "redThreshold" => 90.0,
-          "yellowThreshold" => 80.0,
-          "snoozeMinutes" => 15,
-          "lastTriggerTimeRed" => nil,  # timestamp or nil
-          "lastTriggerTimeYellow" => nil,  # timestamp or nil
-          "sustainedSeconds" => 15
-        },
-        "memory" => {
-          "redThreshold" => 90.0,
-          "yellowThreshold" => 80.0,
-          "snoozeMinutes" => 15,
-          "lastTriggerTimeRed" => nil,  # timestamp or nil
-          "lastTriggerTimeYellow" => nil,  # timestamp or nil
-          "sustainedSeconds" => 15
-        },
-        "disk" => {
-          "redThreshold" => 90.0,
-          "yellowThreshold" => 80.0,
-          "snoozeMinutes" => 720,  # 12 hours
-          "lastTriggerTimeRed" => nil,  # timestamp or nil
-          "lastTriggerTimeYellow" => nil,  # timestamp or nil
-          "sustainedSeconds" => 60
-        },
-        "global" => {
-          "enableAlerts" => true
-        }
-      }
-      SettingModel.set({name: "system_health", data: system_health_data}, scope: "DEFAULT") unless setting
+      # Settings are stored as JSON strings
+      SettingModel.set({name: "system_health", data: JSON.generate(SYSTEM_HEALTH_DEFAULTS)}, scope: "DEFAULT") unless setting
     end
   end
 end

data/lib/openc3/models/target_model.rb

@@ -30,6 +30,7 @@ require 'openc3/topics/config_topic'
 require 'openc3/system'
 require 'openc3/utilities/local_mode'
 require 'openc3/utilities/bucket'
+require 'openc3/utilities/target_file'
 require 'openc3/utilities/zip'
 require 'fileutils'
 require 'ostruct'
@@ -50,6 +51,7 @@ module OpenC3
     ERB_EXTENSIONS = %w(.txt .rb .py .json .yaml .yml)
     ITEM_MAP_CACHE_TIMEOUT = 10.0
     PACKET_CACHE_TIMEOUT = 10.0
+    MAX_COLUMN_HEADER_LENGTH = 127 # QuestDB column header limit for item/param names
     @@item_map_cache = {}
     @@packet_cache = {}
     @@packet_cache_mutex = Mutex.new
@@ -76,6 +78,7 @@ module OpenC3
     attr_accessor :tlm_log_retain_time
     attr_accessor :cmd_decom_retain_time
     attr_accessor :tlm_decom_retain_time
+    attr_accessor :decom_flush_period
     attr_accessor :cleanup_poll_time
     attr_accessor :needs_dependencies
     attr_accessor :target_microservices
@@ -123,6 +126,63 @@ module OpenC3
       targets.sort.to_h
     end
 
+    # Splits a plugin instance name ("openc3-cosmos-demo-7.2.0.gem__0") into
+    # [base_name, version] (["openc3-cosmos-demo", "7.2.0"]), or nil when the
+    # name doesn't carry a version segment. Drops the "__N" install-instance
+    # suffix and the ".gem" extension first.
+    def self.plugin_name_version(plugin_instance)
+      return nil if plugin_instance.nil? || plugin_instance.empty?
+      gem = plugin_instance.split('__')[0].sub(/\.gem\z/, '')
+      parts = gem.split('-')
+      return nil if parts.length < 2
+      [parts[0..-2].join('-'), parts[-1]]
+    end
+
+    # "name version" of the plugin that installed this target (e.g.
+    # "openc3-cosmos-demo 7.2.0"), derived from the plugin instance name
+    # ("openc3-cosmos-demo-7.2.0.gem__0"), or nil if unavailable. Used to
+    # annotate the Version History baseline with the file's origin.
+    def self.plugin_version_label(target_name, scope:)
+      model = get(name: target_name, scope: scope)
+      name, version = plugin_name_version(model && model['plugin'])
+      return nil unless name
+      "#{name} #{version}"
+    rescue
+      nil
+    end
+
+    # Version-stripped plugin base name that owns this target, e.g.
+    # "openc3-cosmos-demo" from instance "openc3-cosmos-demo-7.2.0.gem__0".
+    # Used as the per-plugin Version History repo key: stable across upgrades
+    # (only the version segment changes), so history survives version bumps.
+    # Returns nil when the target has no owning plugin (e.g. a hand-created
+    # target); callers fall back to a no-plugin bucket.
+    def self.plugin_base_name(target_name, scope:)
+      model = get(name: target_name, scope: scope)
+      name, _version = plugin_name_version(model && model['plugin'])
+      name
+    rescue
+      nil
+    end
+
+    # Uninstall-only: remove a plugin's entire Version History repo. Called
+    # from the CLI uninstall path with the plugin instance name; upgrade reuses
+    # the repo and must never call this. No-op in Core builds (or whenever
+    # OPENC3_VERSION_HISTORY_DIR is unset) since VersionStore is absent or
+    # disabled. Best-effort: a failure here must not abort the uninstall.
+    def self.destroy_script_versions(plugin_instance_name, scope:)
+      name, _version = plugin_name_version(plugin_instance_name)
+      return unless name
+      begin
+        require 'openc3-enterprise/utilities/version_store'
+      rescue LoadError
+        return
+      end
+      ::VersionStore.destroy_repo(scope: scope, plugin: name)
+    rescue => e
+      Logger.warn("destroy_script_versions failed for #{scope}/#{plugin_instance_name}: #{e.message}")
+    end
+
     # Given target's modified file list
     def self.modified_files(target_name, scope:)
       modified = []
@@ -145,7 +205,19 @@ module OpenC3
       modified.sort
     end
 
-    def self.delete_modified(target_name, scope:)
+    # files: optional list of specific modified files to delete, each a name
+    # relative to scope ("TARGET/sub/path", matching modified_files output).
+    # When given, only those files are removed (used by plugin upgrade to drop
+    # some modified files while keeping others); when nil, every modified file
+    # for the target is removed (the original behavior).
+    def self.delete_modified(target_name, scope:, files: nil)
+      if files && !files.empty?
+        files.each do |name|
+          # TargetFile.destroy handles both local mode and the bucket.
+          OpenC3::TargetFile.destroy(scope, name)
+        end
+        return
+      end
       if ENV['OPENC3_LOCAL_MODE']
         OpenC3::LocalMode.delete_modified(target_name, scope: scope)
       end
@@ -224,7 +296,7 @@ module OpenC3
 
       # Assume it exists and just try to get it to avoid an extra call to Store.exist?
       json = store_for_target(target_name, scope: scope).hget("#{scope}__openc3#{type.to_s.downcase}__#{target_name}", packet_name)
-      raise "Packet '#{target_name} #{packet_name}' does not exist" if json.nil?
+      raise "Packet definition '#{target_name} #{packet_name}' does not exist" if json.nil?
 
       packet = JSON.parse(json, allow_nan: true, create_additions: true)
 
@@ -245,7 +317,7 @@ module OpenC3
     # @return [Array<Hash>] All packet hashes under the target_name
     def self.packets(target_name, type: :TLM, scope:)
       raise "Unknown type #{type} for #{target_name}" unless VALID_TYPES.include?(type)
-      raise "Target '#{target_name}' does not exist for scope: #{scope}" unless get(name: target_name, scope: scope)
+      raise "Target '#{target_name}' does not exist for scope: #{scope} (TargetModel)" unless get(name: target_name, scope: scope)
 
       result = []
       packets = store_for_target(target_name, scope: scope).hgetall("#{scope}__openc3#{type.to_s.downcase}__#{target_name}")
@@ -281,7 +353,7 @@ module OpenC3
     def self.packet_item(target_name, packet_name, item_name, type: :TLM, scope:)
       packet = packet(target_name, packet_name, type: type, scope: scope)
       item = packet['items'].find { |item| item['name'] == item_name.to_s }
-      raise "Item '#{packet['target_name']} #{packet['packet_name']} #{item_name}' does not exist" unless item
+      raise "Item '#{packet['target_name']} #{packet['packet_name']} #{item_name}' does not exist (TargetModel)" unless item
       item
     end
 
@@ -400,6 +472,7 @@ module OpenC3
       tlm_log_retain_time: nil,
       cmd_decom_retain_time: nil,
       tlm_decom_retain_time: nil,
+      decom_flush_period: 5.0,
       cleanup_poll_time: 3600,
       needs_dependencies: false,
       target_microservices: {},
@@ -428,6 +501,7 @@ module OpenC3
       @tlm_log_retain_time = tlm_log_retain_time
       @cmd_decom_retain_time = cmd_decom_retain_time
       @tlm_decom_retain_time = tlm_decom_retain_time
+      @decom_flush_period = decom_flush_period
       @cleanup_poll_time = cleanup_poll_time
       @needs_dependencies = needs_dependencies
       @target_microservices = target_microservices
@@ -461,6 +535,7 @@ module OpenC3
         'tlm_log_retain_time' => @tlm_log_retain_time,
         'cmd_decom_retain_time' => @cmd_decom_retain_time,
         'tlm_decom_retain_time' => @tlm_decom_retain_time,
+        'decom_flush_period' => @decom_flush_period,
         'cleanup_poll_time' => @cleanup_poll_time,
         'needs_dependencies' => @needs_dependencies,
         'target_microservices' => @target_microservices.as_json(),
@@ -515,6 +590,9 @@ module OpenC3
         if @tlm_decom_retain_time and !@tlm_decom_retain_time.match?(/^\d+[hdwMy]$/)
           raise ConfigParser::Error.new(parser, "TLM_DECOM_RETAIN_TIME must be a number followed by h, d, w, M, or y (e.g., 24h, 7d, 1y)")
         end
+      when 'DECOM_FLUSH_PERIOD'
+        parser.verify_num_parameters(1, 1, "#{keyword} <Flush period in seconds>")
+        @decom_flush_period = Float(parameters[0])
       when 'REDUCED_MINUTE_LOG_RETAIN_TIME', 'REDUCED_HOUR_LOG_RETAIN_TIME', 'REDUCED_DAY_LOG_RETAIN_TIME', 'REDUCED_LOG_RETAIN_TIME'
         # DEPRECATED
       when 'REDUCER_DISABLE', 'REDUCER_DISABLED', 'REDUCER_MAX_CPU_UTILIZATION', 'REDUCED_MAX_CPU_UTILIZATION'
@@ -576,11 +654,23 @@ module OpenC3
       return nil
     end
 
-    def deploy(gem_path, variables, validate_only: false)
+    # upgrade_context (plugin upgrades only) drives two modes, both keyed by
+    # the deployed file name "TARGET/sub/path" (matches modified_files output):
+    #   { diff_collector: [] } — dry run (with validate_only): append the names
+    #     of modified files whose live content differs from the rendered plugin
+    #     content. Read-only; used to warn before an upgrade.
+    #   { username:, plugin: "name version", version_files: [<name>...] } — for
+    #     each listed file with a modified copy: record the modified copy in
+    #     Version History, drop the shadow so the plugin content becomes current,
+    #     then commit the incoming content as a plugin-upgrade version.
+    # nil (the default and Core builds without VersionStore) = no-op.
+    def deploy(gem_path, variables, validate_only: false, upgrade_context: nil)
       variables["target_name"] = @name
       start_path = "/targets/#{@folder_name}/"
       temp_dir = Dir.mktmpdir
       found = false
+      diff_collector = upgrade_context && upgrade_context[:diff_collector]
+      versioning = !validate_only && upgrade_context && upgrade_context[:version_files] && version_store_available?
       begin
         target_path = gem_path + start_path + "**/*"
         Dir.glob(target_path) do |filename|
@@ -616,15 +706,30 @@ module OpenC3
           File.open(local_path, 'wb') { |file| file.write(data) }
           found = true
           @bucket.put_object(bucket: ENV['OPENC3_CONFIG_BUCKET'], key: key, body: data) unless validate_only
+
+          # Plugin upgrade: either collect this file into the diff (dry run) or
+          # take it from the plugin while preserving the modified copy in
+          # Version History. Both skip files with no modified copy.
+          name = "#{@name}/#{target_folder_path}"
+          if diff_collector
+            collect_modified_diff(name, data, diff_collector)
+          elsif versioning && upgrade_context[:version_files].include?(name)
+            apply_upgrade_version(name, data, upgrade_context)
+          end
         end
         raise "No target files found at #{target_path}" unless found
 
         target_folder = File.join(temp_dir, @name)
         # Build a System for just this target
         system = System.new([@name], temp_dir)
+        check_column_header_lengths(system)
         if variables["xtce_output"]
           puts "Converting target #{@name} to .xtce files in #{variables["xtce_output"]}/#{@name}"
-          puts "    Using mnemonic '#{variables['time_association_name']}' as the packet time item."
+          if variables['time_association_name'].to_s.empty?
+            puts "    No packet time item given, so no TimeAssociation will be written."
+          else
+            puts "    Using mnemonic '#{variables['time_association_name']}' as the packet time item."
+          end
           system.packet_config.to_xtce(variables["xtce_output"], variables['time_association_name'])
         end
         unless validate_only
@@ -638,6 +743,74 @@ module OpenC3
       end
     end
 
+    # Version History is an Enterprise feature. The plugin deploy runs in the
+    # cmd-tlm-api process, which (unlike script-runner-api) doesn't otherwise
+    # require the store, so lazily load it on demand. Returns false in Core
+    # builds where the Enterprise gem isn't present.
+    def version_store_available?
+      return true if defined?(::VersionStore)
+      require 'openc3-enterprise/utilities/version_store'
+      defined?(::VersionStore) ? true : false
+    rescue LoadError
+      false
+    end
+
+    # See deploy/upgrade_context. Reads the modified shadow directly (not
+    # TargetFile.body, which would fall back to the just-overwritten pristine
+    # copy), commits it, removes it, then commits the incoming plugin content.
+    # Best-effort: a versioning failure must not abort the plugin upgrade.
+    def apply_upgrade_version(name, new_data, ctx)
+      modified_key = "#{@scope}/targets_modified/#{name}"
+      resp = @bucket.get_object(bucket: ENV['OPENC3_CONFIG_BUCKET'], key: modified_key)
+      return unless resp && resp.body
+      old_body = resp.body.read
+      # Nothing actually changed — the modification already matches the plugin.
+      # Leave the (identical) shadow in place and create no version churn.
+      return if old_body.b == new_data.b
+      old_body = old_body.force_encoding('UTF-8') unless File.extname(name) == '.bin'
+      # Preserve the pre-upgrade (user-modified) content as a version.
+      # Idempotent: a no-op when it already matches the latest version.
+      ::VersionStore.commit(scope: @scope, name: name, text: old_body)
+      # Drop the modified shadow so the plugin file (already written to
+      # targets/) becomes the live content.
+      OpenC3::TargetFile.destroy(@scope, name)
+      # Commit the incoming plugin content as a plugin-upgrade version,
+      # attributed to the installing user.
+      ::VersionStore.commit(scope: @scope, name: name, text: new_data,
+        username: ctx[:username], source: 'plugin-upgrade', plugin: ctx[:plugin])
+    rescue => e
+      Logger.warn("Version History upgrade capture failed for #{@scope}/#{name}: #{e.message}")
+    end
+
+    # Dry-run companion to apply_upgrade_version: append name to collector when
+    # a modified copy exists and differs (by bytes) from the rendered plugin
+    # content. Read-only.
+    def collect_modified_diff(name, new_data, collector)
+      resp = @bucket.get_object(bucket: ENV['OPENC3_CONFIG_BUCKET'], key: "#{@scope}/targets_modified/#{name}")
+      return unless resp && resp.body
+      collector << name if resp.body.read.b != new_data.b
+    rescue => e
+      Logger.warn("Modified diff check failed for #{@scope}/#{name}: #{e.message}")
+    end
+
+    def check_column_header_lengths(system)
+      too_long = []
+      [system.packet_config.telemetry, system.packet_config.commands].each do |packets_by_target|
+        packets_by_target.each do |target_name, packets|
+          packets.each do |packet_name, packet|
+            packet.sorted_items.each do |item|
+              if item.name.length > MAX_COLUMN_HEADER_LENGTH
+                too_long << "#{target_name} #{packet_name} #{item.name} (#{item.name.length})"
+              end
+            end
+          end
+        end
+      end
+      unless too_long.empty?
+        raise "Item / parameter names must be #{MAX_COLUMN_HEADER_LENGTH} characters or less (QuestDB column header limit). The following are too long:\n  #{too_long.join("\n  ")}"
+      end
+    end
+
     def undeploy
       prefix = "#{@scope}/targets/#{@name}/"
       objects = @bucket.list_objects(bucket: ENV['OPENC3_CONFIG_BUCKET'], prefix: prefix)
@@ -1032,6 +1205,7 @@ module OpenC3
       options = []
       options << ["CMD_DECOM_RETAIN_TIME", @cmd_decom_retain_time] if @cmd_decom_retain_time
       options << ["TLM_DECOM_RETAIN_TIME", @tlm_decom_retain_time] if @tlm_decom_retain_time
+      options << ["DECOM_FLUSH_PERIOD", @decom_flush_period] if @decom_flush_period
       microservice = MicroserviceModel.new(
         name: microservice_name,
         folder_name: @folder_name,

data/lib/openc3/models/tool_model.rb

@@ -25,6 +25,13 @@ module OpenC3
   class ToolModel < Model
     PRIMARY_KEY = 'openc3_tools'
 
+    # Tools are global to the entire COSMOS installation and are always stored
+    # in the DEFAULT scope. The frontend navigation always requests the tool
+    # list from DEFAULT, so a tool installed into any other scope would be
+    # inaccessible. Every scope parameter in this class is therefore ignored
+    # and replaced with TOOL_SCOPE.
+    TOOL_SCOPE = 'DEFAULT'
+
     attr_accessor :folder_name
     attr_accessor :icon
     attr_accessor :url
@@ -39,21 +46,24 @@ module OpenC3
 
     # NOTE: The following three class methods are used by the ModelController
     # and are reimplemented to enable various Model class methods to work
+    # NOTE: scope is deprecated since 7.3.0 as tools always live in the DEFAULT scope, see TOOL_SCOPE
     def self.get(name:, scope: nil)
-      super("#{scope}__#{PRIMARY_KEY}", name: name)
+      super("#{TOOL_SCOPE}__#{PRIMARY_KEY}", name: name)
     end
 
+    # NOTE: scope is deprecated since 7.3.0 as tools always live in the DEFAULT scope, see TOOL_SCOPE
     def self.names(scope: nil)
       array = []
-      all(scope: scope).each do |name, _tool|
+      all().each do |name, _tool|
         array << name
       end
       array
     end
 
+    # NOTE: scope is deprecated since 7.3.0 as tools always live in the DEFAULT scope, see TOOL_SCOPE
     def self.all(scope: nil)
       ordered_array = []
-      tools = unordered_all(scope: scope)
+      tools = unordered_all()
       tools.each do |_name, tool|
         ordered_array << tool
       end
@@ -65,14 +75,10 @@ module OpenC3
       ordered_hash
     end
 
+    # Tools only exist in the DEFAULT scope. Kept for backwards compatibility
+    # with the ToolsController importmap endpoint.
     def self.all_scopes
-      result = {}
-      scopes = OpenC3::ScopeModel.all
-      scopes.each do |key, _scope|
-        tools = unordered_all(scope: key)
-        result.merge!(tools)
-      end
-      result
+      unordered_all()
     end
 
     # Called by the PluginModel to allow this class to validate it's top-level keyword: "TOOL"
@@ -80,7 +86,8 @@ module OpenC3
       case keyword
       when 'TOOL'
         parser.verify_num_parameters(2, 2, "TOOL <Folder Name> <Name>")
-        return self.new(folder_name: parameters[0], name: parameters[1], plugin: plugin, needs_dependencies: needs_dependencies, scope: scope)
+        # NOTE: scope is intentionally ignored, see TOOL_SCOPE
+        return self.new(folder_name: parameters[0], name: parameters[1], plugin: plugin, needs_dependencies: needs_dependencies, scope: TOOL_SCOPE)
       else
         raise ConfigParser::Error.new(parser, "Unknown keyword and parameters for Tool: #{keyword} #{parameters.join(" ")}")
       end
@@ -89,8 +96,10 @@ module OpenC3
 
     # The ToolsTab.vue calls the ToolsController which uses this method to reorder the tools
     # Position is index in the list starting with 0 = first
-    def self.set_position(name:, position:, scope:)
-      moving = from_json(get(name: name, scope: scope), scope: scope)
+    # NOTE: scope is deprecated since 7.3.0 as tools always live in the DEFAULT scope, see TOOL_SCOPE
+    def self.set_position(name:, position:, scope: nil)
+      tool_scope = TOOL_SCOPE
+      moving = from_json(get(name: name, scope: tool_scope), scope: tool_scope)
       old_pos = moving.position
       new_pos = position
       direction = :down
@@ -101,8 +110,8 @@ module OpenC3
       end
 
       # Go through all the tools and reorder
-      all(scope: scope).each do |_tool_name, tool|
-        tool_model = from_json(tool, scope: scope)
+      all(scope: tool_scope).each do |_tool_name, tool|
+        tool_model = from_json(tool, scope: tool_scope)
         # Update the requested model to the new position
         if tool_model.name == name
           tool_model.position = position
@@ -134,9 +143,11 @@ module OpenC3
       needs_dependencies: false,
       disable_erb: nil,
       import_map_items: nil,
-      scope:
+      scope: nil  # NOTE: deprecated since 7.3.0 as tools are always created in the DEFAULT scope, see TOOL_SCOPE
     )
-      super("#{scope}__#{PRIMARY_KEY}", name: name, plugin: plugin, updated_at: updated_at, scope: scope)
+      # Tools are always created in the DEFAULT scope regardless of the scope
+      # the plugin is being installed into, see TOOL_SCOPE
+      super("#{TOOL_SCOPE}__#{PRIMARY_KEY}", name: name, plugin: plugin, updated_at: updated_at, scope: TOOL_SCOPE)
       @folder_name = folder_name
       @icon = icon
       @url = url
@@ -156,14 +167,15 @@ module OpenC3
     end
 
     def create(update: false, force: false, queued: false)
-      tools = self.class.all(scope: @scope)
+      tools = self.class.all()
 
       # Make sure a tool with this folder_name doesn't already exist
+      # NOTE: Tools are global (TOOL_SCOPE) so this check is across all scopes
       unless update
         if @folder_name
           tools.each do |_tool_name, tool|
             if tool['folder_name'] == @folder_name
-              raise "Tool with folder_name #{@folder_name} already exists at create"
+              raise "Tool with folder_name #{@folder_name} already exists at create. Tools are global to the entire COSMOS installation and can only be installed once."
             end
           end
         end
@@ -308,8 +320,9 @@ module OpenC3
     ##################################################
 
     # Returns the list of tools or the default OpenC3 tool set if no tools have been created
+    # NOTE: scope is deprecated since 7.3.0 as tools always live in the DEFAULT scope, see TOOL_SCOPE
     def self.unordered_all(scope: nil)
-      tools = Store.hgetall("#{scope}__#{PRIMARY_KEY}")
+      tools = Store.hgetall("#{TOOL_SCOPE}__#{PRIMARY_KEY}")
       tools.each do |key, value|
         tools[key] = JSON.parse(value, allow_nan: true, create_additions: true)
       end

data/lib/openc3/operators/microservice_operator.rb

@@ -47,10 +47,39 @@ module OpenC3
       env = microservice_config["env"].dup
       if microservice_config["needs_dependencies"]
         env['GEM_HOME'] = '/gems'
-        env['PYTHONUSERBASE'] = '/gems/python_packages'
-        # Ensure PYTHONPATH includes both the UV venv (for base openc3 module) and user packages
-        # This is critical for UV-based Python installations where openc3 is installed as editable
-        env['PYTHONPATH'] = "#{ENV['PYTHONPATH']}"
+
+        # Resolve the Python virtual environment for this microservice.
+        # If the microservice belongs to a plugin that has a per-plugin UV venv
+        # (created by uvinstall during plugin install), use that isolated venv.
+        # Otherwise fall back to the shared PYTHONUSERBASE for legacy plugins.
+        plugin_name = microservice_config["plugin"]
+        plugin_venv_dir = nil
+        if plugin_name
+          scope = microservice_name.split("__")[0]
+          sanitized_name = "#{scope}__#{plugin_name}".tr('^a-zA-Z0-9_-', '_')
+          candidate = "/gems/plugin_venvs/#{sanitized_name}/.venv"
+          plugin_venv_dir = candidate if File.directory?(candidate)
+        end
+
+        if plugin_venv_dir
+          env['VIRTUAL_ENV'] = plugin_venv_dir
+          env['PATH'] = "#{plugin_venv_dir}/bin:#{ENV.fetch('PATH', '')}"
+          env['PYTHONUSERBASE'] = plugin_venv_dir
+          # Add the plugin venv's site-packages to PYTHONPATH so the base venv's
+          # Python binary can find plugin-specific packages. We keep the base binary
+          # because it has openc3 core installed; PYTHONPATH is always respected by
+          # CPython regardless of venv activation state.
+          site_packages = Dir.glob("#{plugin_venv_dir}/lib/python*/site-packages").first
+          existing_pythonpath = ENV.fetch('PYTHONPATH', '')
+          if site_packages
+            env['PYTHONPATH'] = existing_pythonpath.empty? ? site_packages : "#{site_packages}:#{existing_pythonpath}"
+          else
+            env['PYTHONPATH'] = existing_pythonpath.empty? ? nil : existing_pythonpath
+          end
+        else
+          env['PYTHONUSERBASE'] = '/gems/python_packages'
+          env['PYTHONPATH'] = ENV.fetch('PYTHONPATH', nil)
+        end
       else
         env['GEM_HOME'] = nil
         env['PYTHONUSERBASE'] = nil

data/lib/openc3/packets/commands.rb

@@ -61,7 +61,7 @@ module OpenC3
     #   target name keyed by the packet name
     def packets(target_name)
       target_packets = @config.commands[target_name.to_s.upcase]
-      raise "Command target '#{target_name.to_s.upcase}' does not exist" unless target_packets
+      raise "Command target '#{target_name.to_s.upcase}' does not exist (packets lookup)" unless target_packets
 
       target_packets
     end
@@ -73,7 +73,7 @@ module OpenC3
     def packet(target_name, packet_name)
       target_packets = packets(target_name)
       packet = target_packets[packet_name.to_s.upcase]
-      raise "Command packet '#{target_name.to_s.upcase} #{packet_name.to_s.upcase}' does not exist" unless packet
+      raise "Command packet '#{target_name.to_s.upcase} #{packet_name.to_s.upcase}' does not exist (packet lookup)" unless packet
 
       packet
     end
@@ -187,9 +187,9 @@ module OpenC3
 
       # Lookup the command directly - avoid redundant upcase in packet()/packets()
       target_packets = @config.commands[target_upcase]
-      raise "Command target '#{target_upcase}' does not exist" unless target_packets
+      raise "Command target '#{target_upcase}' does not exist (build_cmd)" unless target_packets
       pkt = target_packets[packet_upcase]
-      raise "Command packet '#{target_upcase} #{packet_upcase}' does not exist" unless pkt
+      raise "Command packet '#{target_upcase} #{packet_upcase}' does not exist (build_cmd)" unless pkt
       # Use deep_copy to avoid shared item modifications affecting the template
       # This is critical for variable_bit_size items where handle_write_variable_bit_size
       # modifies item.bit_offset and item.array_size during writes

data/lib/openc3/packets/limits.rb

@@ -159,16 +159,24 @@ module OpenC3
     # @param packet_name [String] Packet Name
     # @param item_name [String] Item Name
     # @param state_name [String] State Name (e.g. 'CONNECTED')
-    # @param color [String or Symbol] New color: GREEN, YELLOW, or RED
-    # @return [Symbol] The color that was set
+    # @param color [String or Symbol, nil] New color: GREEN, YELLOW, or RED.
+    #   Pass nil to clear (remove) the state color.
+    # @return [Symbol, nil] The color that was set, or nil if the color was cleared
     def set_state_color(target_name, packet_name, item_name, state_name, color)
       packet = _get_packet(target_name, packet_name)
       item = packet.get_item(item_name)
-      raise "Item #{target_name} #{packet_name} #{item_name} does not have any states" unless item.states
+      raise "Item '#{target_name} #{packet_name} #{item_name}' does not have any states" unless item.states
       state_name = state_name.to_s.upcase
-      raise "State #{state_name} does not exist for #{target_name} #{packet_name} #{item_name}" unless item.states.key?(state_name)
+      raise "State '#{state_name}' does not exist for item '#{target_name} #{packet_name} #{item_name}'" unless item.states.key?(state_name)
+      if color.nil?
+        # Clear the state color while keeping state_colors as a Hash so limits
+        # checking (which indexes state_colors by value) continues to work.
+        item.state_colors.delete(state_name) if item.state_colors
+        packet.update_limits_items_cache(item)
+        return nil
+      end
       color = color.to_s.upcase.intern
-      raise "Invalid state color #{color}. Must be one of #{PacketItem::STATE_COLORS.join(' ')}." unless PacketItem::STATE_COLORS.include?(color)
+      raise "Invalid state color '#{color}'. Must be one of #{PacketItem::STATE_COLORS.join(', ')}." unless PacketItem::STATE_COLORS.include?(color)
       item.state_colors ||= {}
       item.state_colors[state_name] = color
       item.limits.enabled = true
@@ -182,10 +190,10 @@ module OpenC3
       raise "LATEST packet not valid" if packet_name.upcase == LATEST_PACKET_NAME
 
       packets = @config.telemetry[target_name.to_s.upcase]
-      raise "Telemetry target '#{target_name.to_s.upcase}' does not exist" unless packets
+      raise "Telemetry target '#{target_name.to_s.upcase}' does not exist (limits lookup)" unless packets
 
       packet = packets[packet_name.to_s.upcase]
-      raise "Telemetry packet '#{target_name.to_s.upcase} #{packet_name.to_s.upcase}' does not exist" unless packet
+      raise "Telemetry packet '#{target_name.to_s.upcase} #{packet_name.to_s.upcase}' does not exist (limits lookup)" unless packet
 
       return packet
     end

data/lib/openc3/packets/packet.rb

@@ -616,7 +616,7 @@ module OpenC3
     def get_item(name)
       return super(name)
     rescue ArgumentError
-      raise "Packet item '#{@target_name} #{@packet_name} #{name.upcase}' does not exist"
+      raise "Item '#{@target_name} #{@packet_name} #{name.upcase}' does not exist (Packet)"
     end
 
     # Read an item in the packet

data/lib/openc3/packets/parsers/state_parser.rb

@@ -124,7 +124,7 @@ module OpenC3
     def get_state_colors(item)
       color = @parser.parameters[2].upcase.to_sym
       unless PacketItem::STATE_COLORS.include? color
-        raise @parser.error("Invalid state color #{color}. Must be one of #{PacketItem::STATE_COLORS.join(' ')}.", @usage)
+        raise @parser.error("Invalid state color '#{color}'. Must be one of #{PacketItem::STATE_COLORS.join(', ')}.", @usage)
       end
 
       item.limits.enabled = true