openc3 7.2.0 → 7.3.0

data/lib/openc3/packets/structure.rb

@@ -326,7 +326,7 @@ module OpenC3
     # @return [StructureItem] StructureItem or one of its subclasses
     def get_item(name)
       item = @items[name.upcase]
-      raise ArgumentError, "Unknown item: #{name}" unless item
+      raise ArgumentError, "Unknown item: #{name} (get_item)" unless item
 
       return item
     end
@@ -358,7 +358,7 @@ module OpenC3
     # @param name [String] Name of the item to delete in the items Hash
     def delete_item(name)
       item = @items[name.upcase]
-      raise ArgumentError, "Unknown item: #{name}" unless item
+      raise ArgumentError, "Unknown item: #{name} (delete_item)" unless item
 
       # Find the item to delete in the sorted_items array
       item_index = nil
@@ -604,19 +604,23 @@ module OpenC3
       if item.variable_bit_size
         # Bit size is determined by length field
         length_value = self.read(item.variable_bit_size['length_item_name'], :CONVERTED)
-        if (item.data_type == :INT or item.data_type == :UINT) and not item.original_array_size
-          case length_value
-          when 0
-            return 6
-          when 1
-            return 14
-          when 2
-            return 30
+        if length_value
+          if (item.data_type == :INT or item.data_type == :UINT) and not item.original_array_size
+            case length_value
+            when 0
+              return 6
+            when 1
+              return 14
+            when 2
+              return 30
+            else
+              return 62
+            end
           else
-            return 62
+            return (length_value * item.variable_bit_size['length_bits_per_count']) + item.variable_bit_size['length_value_bit_offset']
           end
         else
-          return (length_value * item.variable_bit_size['length_bits_per_count']) + item.variable_bit_size['length_value_bit_offset']
+          raise "Length value #{item.variable_bit_size['length_item_name']} for item #{item.name} is nil"
         end
       elsif item.original_bit_size <= 0
         # Bit size is full packet length - bits before item + negative bits saved at end

data/lib/openc3/packets/telemetry.rb

@@ -59,7 +59,7 @@ module OpenC3
       def packets(target_name)
         upcase_target_name = target_name.to_s.upcase
         target_packets = @config.telemetry[upcase_target_name]
-        raise "Telemetry target '#{upcase_target_name}' does not exist" unless target_packets
+        raise "Telemetry target '#{upcase_target_name}' does not exist (packets lookup)" unless target_packets
 
         target_packets
       end
@@ -177,7 +177,7 @@ module OpenC3
       if LATEST_PACKET_NAME.casecmp(packet_name).zero?
         target_upcase = target_name.to_s.upcase
         target_latest_data = @config.latest_data[target_upcase]
-        raise "Telemetry Target '#{target_upcase}' does not exist" unless target_latest_data
+        raise "Telemetry target '#{target_upcase}' does not exist (item_names lookup)" unless target_latest_data
 
         item_names = target_latest_data.keys
       else
@@ -208,7 +208,7 @@ module OpenC3
       target_upcase = target_name.to_s.upcase
       item_upcase = item_name.to_s.upcase
       target_latest_data = @config.latest_data[target_upcase]
-      raise "Telemetry target '#{target_upcase}' does not exist" unless target_latest_data
+      raise "Telemetry target '#{target_upcase}' does not exist (latest_packets lookup)" unless target_latest_data
 
       packets = @config.latest_data[target_upcase][item_upcase]
       raise "Telemetry item '#{target_upcase} #{LATEST_PACKET_NAME} #{item_upcase}' does not exist" unless packets

data/lib/openc3/script/commands.rb

@@ -106,7 +106,7 @@ module OpenC3
       cmd_params.each do |param_name, _param_value|
         param = command['items'].find { |item| item['name'] == param_name }
         unless param
-          raise "Packet item '#{target_name} #{cmd_name} #{param_name}' does not exist"
+          raise "Item '#{target_name} #{cmd_name} #{param_name}' does not exist (command parameter validation)"
         end
       end
       _log_cmd(command, raw, no_range, no_hazardous)

data/lib/openc3/script/extract.rb

@@ -20,7 +20,11 @@ require 'openc3/utilities/store'
 
 module OpenC3
   module Extract
-    SCANNING_REGULAR_EXPRESSION = %r{ (?:"(?:[^\\"]|\\.)*") | (?:'(?:[^\\']|\\.)*') | (?:\[(?:[^\\\[\]]|\\.)*\]) | \S+ }x # "
+    # Tokenizer for command parameters: matches double quoted strings, single quoted strings,
+    # bracket delimited arrays (one level of nesting), a bare comma delimiter, or bare words
+    # (runs of non-whitespace, non-comma characters). Commas are tokenized separately so
+    # whitespace around them is optional.
+    SCANNING_REGULAR_EXPRESSION = %r{ (?:"(?:[^\\"]|\\.)*") | (?:'(?:[^\\']|\\.)*') | (?:\[(?:[^\\\[\]]|\\.|\[(?:[^\\\[\]]|\\.)*\])*\]) | , | [^\s,]+ }x # "
 
     private
 
@@ -88,35 +92,26 @@ module OpenC3
         second_half = split_string[1].scan(SCANNING_REGULAR_EXPRESSION)
         keyword = nil
         value = nil
-        comma = nil
         second_half.each do |item|
-          unless keyword
+          if item == ','
+            # A comma completes the current keyword / value pair.
+            # A comma with nothing pending is a leading or duplicated comma.
+            raise "Missing command parameter before comma: #{text}" unless keyword
+            raise "Missing value for last command parameter: #{text}" unless value
+            add_cmd_parameter(keyword, value, packet, cmd_params)
+            keyword = nil
+            value = nil
+          elsif keyword.nil?
             keyword = item
-            next
-          end
-          unless value
-            if item[-1..-1] == ','
-              value = item[0..-2]
-              comma = true
-            else
-              value = item
-              next
-            end
-          end
-          unless comma
-            raise "Missing comma in command parameters: #{text}" if item != ','
+          elsif value.nil?
+            value = item
+          else
+            raise "Missing comma in command parameters: #{text}"
           end
-          add_cmd_parameter(keyword, value, packet, cmd_params)
-          keyword = nil
-          value = nil
-          comma = nil
         end
         if keyword
-          if value
-            add_cmd_parameter(keyword, value, packet, cmd_params)
-          else
-            raise "Missing value for last command parameter: #{text}"
-          end
+          raise "Missing value for last command parameter: #{text}" unless value
+          add_cmd_parameter(keyword, value, packet, cmd_params)
         end
       end
 

data/lib/openc3/script/limits.rb

@@ -20,7 +20,7 @@ module OpenC3
     private
 
     # Define all the modification methods such that we can disconnect them
-    %i(enable_limits disable_limits set_limits enable_limits_group disable_limits_group set_limits_set).each do |method_name|
+    %i(enable_limits disable_limits set_limits set_state_color enable_limits_group disable_limits_group set_limits_set delete_limits_set).each do |method_name|
       define_method(method_name) do |*args, **kw_args, &block|
         kw_args[:scope] = $openc3_scope unless kw_args[:scope]
         if $disconnect

data/lib/openc3/script/suite_runner.rb

@@ -26,6 +26,11 @@ module OpenC3
   end
 
   class SuiteRunner
+    # Default suite_runner options shared by all callers (e.g. openc3cli) so
+    # the values stay consistent in one place.
+    DEFAULT_METHOD = 'start'
+    DEFAULT_OPTIONS = ['continueAfterError'].freeze
+
     @@suites = []
     @@settings = {}
     @@suite_results = nil
@@ -42,17 +47,46 @@ module OpenC3
       @@suite_results
     end
 
+    # Validate the suite_runner option combinations that don't require the
+    # built suites. Shared by all callers (the running script via execute and
+    # openc3cli when constructing options) so the contract lives in one place.
+    # Suite/Group existence is checked in execute since it needs @@suites.
+    def self.validate_options(group: nil, script: nil)
+      raise ArgumentError, "Script #{script} requires a Group" if script and not group
+    end
+
+    # Build the canonical, validated suite_runner hash from raw values,
+    # applying defaults. Shared by openc3cli (constructing from CLI flags) and
+    # the running script (normalizing a received hash before dispatch) so the
+    # hash shape, defaults, and validation live in one place.
+    def self.build_options(suite:, group: nil, script: nil, method: nil, options: nil)
+      validate_options(group: group, script: script)
+      suite_runner = { 'suite' => suite }
+      if group
+        suite_runner['group'] = group
+        suite_runner['script'] = script if script
+      end
+      # A script always runs via start, matching the GUI
+      suite_runner['method'] = script ? DEFAULT_METHOD : (method || DEFAULT_METHOD)
+      suite_runner['options'] = options || DEFAULT_OPTIONS.dup
+      suite_runner
+    end
+
     def self.execute(result_string, suite_class, group_class = nil, script = nil)
       @@suite_results = SuiteResults.new
-      @@suites.each do |suite|
-        if suite.class == suite_class
-          @@suite_results.start(result_string, suite_class, group_class, script, @@settings)
-          loop do
-            yield(suite)
-            break if not @@settings['Loop'] or (ScriptStatus.instance.fail_count > 0 and @@settings['Break Loop On Error'])
-          end
-          break
-        end
+      # Surface invalid suite / group / option combinations rather than
+      # silently running nothing or failing with an opaque nil error. An
+      # invalid script method raises later in Group#run_method.
+      validate_options(group: group_class, script: script)
+      suite = @@suites.find { |s| s.class == suite_class }
+      raise ArgumentError, "Suite #{suite_class} not found" unless suite
+      if group_class and not suite.scripts.key?(group_class)
+        raise ArgumentError, "Group #{group_class} not found in Suite #{suite_class}"
+      end
+      @@suite_results.start(result_string, suite_class, group_class, script, @@settings)
+      loop do
+        yield(suite)
+        break if not @@settings['Loop'] or (ScriptStatus.instance.fail_count > 0 and @@settings['Break Loop On Error'])
       end
     end
 

data/lib/openc3/script/web_socket_api.rb

@@ -1,4 +1,4 @@
-# encoding: ascii-8bit
+# encoding: utf-8
 
 # Copyright 2026 OpenC3, Inc.
 # All Rights Reserved.
@@ -22,7 +22,10 @@ module OpenC3
 
     # Create the WebsocketApi object. If a block is given will automatically connect/disconnect
     def initialize(url:, write_timeout: 10.0, read_timeout: 10.0, connect_timeout: 5.0, authentication: nil, scope: $openc3_scope, &block)
-      @scope = scope
+      # $openc3_scope is only set inside the Script Runner / microservice
+      # environment. Fall back to OPENC3_SCOPE (mirrors the Python client) so a
+      # bare `ruby script.rb` doesn't send a nil scope that the server rejects.
+      @scope = scope || ENV.fetch('OPENC3_SCOPE', 'DEFAULT')
       @authentication = authentication.nil? ? generate_auth() : authentication
       @url = url
       @write_timeout = write_timeout
@@ -100,6 +103,34 @@ module OpenC3
         json_hash['identifier'] = JSON.generate(@identifier, allow_nan: true)
         @stream.write(JSON.generate(json_hash, allow_nan: true))
         @subscribed = true
+        wait_for_subscribed()
+      end
+    end
+
+    # Block until the server confirms the subscription. ActionCable / anycable-go
+    # process 'subscribe' and 'message' commands as independent RPCs, so an action
+    # (add/remove) written immediately after subscribe can reach
+    # StreamingChannel#add before the subscription's broadcaster exists, where it
+    # is silently dropped (a no-op) and no data ever streams. Waiting for
+    # confirm_subscription guarantees the broadcaster is ready before any action
+    # is written.
+    def wait_for_subscribed
+      while true
+        message = @stream.read
+        raise "WebSocket closed before subscription was confirmed" if message.nil? || message.empty?
+
+        json_hash = JSON.parse(message, allow_nan: true, create_additions: true)
+        case json_hash['type']
+        when 'confirm_subscription'
+          return
+        when 'reject_subscription'
+          raise "Subscription Rejected"
+        when 'disconnect'
+          raise "Unauthorized" if json_hash['reason'] == 'unauthorized'
+        else
+          # Ignore welcome / ping and keep waiting for confirmation
+          next
+        end
       end
     end
 
@@ -116,6 +147,13 @@ module OpenC3
 
     # Send an ActionCable command
     def write_action(data_hash)
+      # Subscribe first so the token is present in @identifier before we
+      # serialize it below. ActionCable matches a 'message' command to its
+      # subscription by the exact identifier string; if subscribe() injected the
+      # token only afterward, the message identifier (no token) would not match
+      # the subscription identifier (with token) and the server would silently
+      # ignore the action.
+      subscribe()
       json_hash = {}
       json_hash['command'] = 'message'
       json_hash['identifier'] = JSON.generate(@identifier, allow_nan: true)
@@ -354,7 +392,8 @@ module OpenC3
     #   PACKET - Packet name
     #   VALUETYPE - RAW, CONVERTED, FORMATTED, or PURE (pure means all types as stored in log)
     #
-    def add(items: nil, packets: nil, start_time: nil, end_time: nil, scope: $openc3_scope)
+    def add(items: nil, packets: nil, start_time: nil, end_time: nil, scope: nil)
+      scope ||= @scope
       data_hash = {}
       data_hash['action'] = 'add'
       if start_time
@@ -395,7 +434,8 @@ module OpenC3
     #   PACKET - Packet name
     #   VALUETYPE - RAW, CONVERTED, FORMATTED, or PURE (pure means all types as stored in log)
     #
-    def remove(items: nil, packets: nil, scope: $openc3_scope)
+    def remove(items: nil, packets: nil, scope: nil)
+      scope ||= @scope
       data_hash = {}
       data_hash['action'] = 'remove'
       data_hash['items'] = items if items
@@ -407,7 +447,7 @@ module OpenC3
 
     # Convenience method to read all data until end marker is received.
     # Warning: DATA IS STORED IN RAM.  Do not use this with large queries
-    def self.read_all(items: nil, packets: nil, start_time: nil, end_time:, scope: $openc3_scope, timeout: nil)
+    def self.read_all(items: nil, packets: nil, start_time: nil, end_time:, scope: nil, timeout: nil)
       read_all_start_time = Time.now
       data = []
       self.new do |api|

data/lib/openc3/system/target.rb

@@ -102,7 +102,10 @@ module OpenC3
     def process_file(filename)
       Logger.instance.info "Processing target definition in file '#{filename}'"
       parser = ConfigParser.new("https://docs.openc3.com/docs/configuration/target")
-      parser.parse_file(filename) do |keyword, parameters|
+      # run_erb is false: ERB is only rendered once, at plugin install time
+      # (TargetModel#deploy). At runtime target files are read already-rendered
+      # from the bucket, so they are treated as data, not re-executed as code.
+      parser.parse_file(filename, false, true, false) do |keyword, parameters|
         case keyword
         when 'LANGUAGE'
           usage = "#{keyword} <ruby | python>"

data/lib/openc3/tools/table_manager/table_config.rb

@@ -85,7 +85,10 @@ module OpenC3
         ConfigParser.new(
           'https://openc3.com/docs/tools/#table-manager-configuration-openc3--39',
         )
-      parser.parse_file(filename) do |keyword, params|
+      # run_erb is false: ERB is only rendered once, at plugin install time
+      # (TargetModel#deploy). Table definitions are read already-rendered from the
+      # bucket here, so they are treated as data, not re-executed as code.
+      parser.parse_file(filename, false, true, false) do |keyword, params|
         if @building_generic_conversion
           case keyword
           # Complete a generic conversion

data/lib/openc3/top_level.rb

@@ -108,7 +108,7 @@ module OpenC3
     # This method is taken directly from the Rails source:
     #   https://api.rubyonrails.org/v5.2/classes/ActiveStorage/Filename.html#method-i-sanitized
     # NOTE: I removed the '/' character because we have to allow this in order to traverse the path
-    sanitized = path.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: "�").strip.tr("\u{202E}%$|:;\t\r\n\\", "-").gsub('..', '-')
+    sanitized = path.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: "\u{FFFD}").strip.tr("\u{202E}%$|:;\t\r\n\\", "-").gsub('..', '-')
     if sanitized != path
       raise StorageError, "Invalid path: #{path}"
     end

data/lib/openc3/topics/command_decom_topic.rb

@@ -30,13 +30,28 @@ module OpenC3
                    received_count: packet.received_count }
       # Read all RAW values at once - optimized by accessor
       json_hash = packet.read_items(packet.sorted_items)
+      # Items with a write conversion have already been transformed by the time the
+      # value lands in the buffer, so reading the buffer back does not recover what
+      # the user actually commanded. Use the given values (as passed to build_cmd)
+      # for those items. State items are the exception: the user can give either the
+      # state name or the state value, so they always read from the buffer to log the
+      # normalized state name. Raw commands bypass the write conversions entirely so
+      # their given values are raw and must not be logged as converted.
+      given_values = packet.raw ? nil : packet.given_values
+      given_values = given_values.transform_keys { |key| key.to_s.upcase } if given_values
       # Read additional value types using given_raw to avoid re-reading from buffer
       packet.sorted_items.each do |item|
         if item.hidden
           json_hash.delete(item.name)
         else
           given_raw = json_hash[item.name]
-          json_hash[item.name + "__C"] = packet.read_item(item, :CONVERTED, packet.buffer, given_raw) if item.write_conversion or item.states
+          if item.write_conversion or item.states
+            if item.write_conversion and !item.states and given_values and given_values.key?(item.name)
+              json_hash[item.name + "__C"] = given_values[item.name]
+            else
+              json_hash[item.name + "__C"] = packet.read_item(item, :CONVERTED, packet.buffer, given_raw)
+            end
+          end
           json_hash[item.name + "__F"] = packet.read_item(item, :FORMATTED, packet.buffer, given_raw) if item.format_string
         end
       end

data/lib/openc3/topics/limits_event_topic.rb

@@ -39,9 +39,15 @@ module OpenC3
       case event[:type]
       when :LIMITS_CHANGE
         # The current_limits hash keeps only the current limits state of items
-        # It is used by the API to determine the overall limits state
-        field = "#{event[:target_name]}__#{event[:packet_name]}__#{event[:item_name]}"
-        Store.hset("#{scope}__current_limits", field, event[:new_limits_state])
+        # It is used by the API to determine the overall limits state.
+        # When the event originates from a stored packet in a non-PROCESS mode
+        # (LOG or DISABLE), skip updating current_limits so that historical
+        # data does not affect the real-time overall limits state or the
+        # out_of_limits API response.
+        unless event[:suppress_stored]
+          field = "#{event[:target_name]}__#{event[:packet_name]}__#{event[:item_name]}"
+          Store.hset("#{scope}__current_limits", field, event[:new_limits_state])
+        end
 
       when :LIMITS_SETTINGS
         # Limits updated in limits_api.rb to avoid circular reference to TargetModel
@@ -79,9 +85,22 @@ module OpenC3
         limits_settings['enabled'] = event[:enabled]
         Store.hset("#{scope}__current_limits_settings", field, JSON.generate(limits_settings, allow_nan: true))
 
+      when :LIMITS_STATE_COLOR
+        # Persist the state color so it survives a decom microservice restart (applied by sync_system)
+        field = "#{event[:target_name]}__#{event[:packet_name]}__#{event[:item_name]}"
+        limits_settings = Store.hget("#{scope}__current_limits_settings", field)
+        if limits_settings
+          limits_settings = JSON.parse(limits_settings, allow_nan: true, create_additions: true)
+        else
+          limits_settings = {}
+        end
+        limits_settings['state_colors'] ||= {}
+        limits_settings['state_colors'][event[:state_name].to_s] = event[:color].to_s
+        Store.hset("#{scope}__current_limits_settings", field, JSON.generate(limits_settings, allow_nan: true))
+
       when :LIMITS_SET
         sets = sets(scope: scope)
-        raise "Set '#{event[:set]}' does not exist!" unless sets.key?(event[:set])
+        raise "Limits set '#{event[:set]}' does not exist" unless sets.key?(event[:set])
 
         # Set all existing sets to "false"
         sets = sets.transform_values! { |_key, _value| "false" }
@@ -173,6 +192,28 @@ module OpenC3
       end
     end
 
+    # Removes a limits set from the limits_sets hash and from the
+    # current_limits_settings of every item. Note that the set is not removed
+    # from the TargetModel packet definitions; that is cleaned up on the next
+    # plugin install. Running microservices will continue to hold the set in
+    # memory until they restart and resync from current_limits_settings.
+    def self.delete_set(set_name, scope:)
+      set_name = set_name.to_s
+      limits_settings = Store.hgetall("#{scope}__current_limits_settings")
+      # Collect all changed items and write them back in a single hmset to
+      # avoid a Redis round trip per item (this hash can be large)
+      updates = {}
+      limits_settings.each do |item, settings|
+        settings = JSON.parse(settings, allow_nan: true, create_additions: true)
+        if settings.key?(set_name)
+          settings.delete(set_name)
+          updates[item] = JSON.generate(settings, allow_nan: true)
+        end
+      end
+      Store.hmset("#{scope}__current_limits_settings", *updates.flatten) unless updates.empty?
+      Store.hdel("#{scope}__limits_sets", set_name)
+    end
+
     # Update the local System based on overall state
     def self.sync_system(scope:)
       all_limits_settings = Store.hgetall("#{scope}__current_limits_settings")
@@ -188,6 +229,12 @@ module OpenC3
             persistence = limits_settings['persistence_setting']
             limits_settings.each do |limits_set, settings|
               next unless Hash === settings
+              if limits_set == 'state_colors'
+                settings.each do |state_name, color|
+                  System.limits.set_state_color(target_name, packet_name, item_name, state_name, color)
+                end
+                next
+              end
               System.limits.set(target_name, packet_name, item_name, settings['red_low'], settings['yellow_low'], settings['yellow_high'], settings['red_high'], settings['green_low'], settings['green_high'], limits_set.to_s.intern, persistence, enabled)
             end
             if not enabled.nil?
@@ -242,6 +289,18 @@ module OpenC3
           end
         end
 
+      when 'LIMITS_STATE_COLOR'
+        target_name = event['target_name']
+        packet_name = event['packet_name']
+        item_name = event['item_name']
+        target = telemetry[target_name]
+        if target
+          packet = target[packet_name]
+          if packet
+            System.limits.set_state_color(target_name, packet_name, item_name, event['state_name'], event['color'])
+          end
+        end
+
       when 'LIMITS_SET'
         System.limits_set = event['set']
       end

data/lib/openc3/topics/telemetry_decom_topic.rb

@@ -20,7 +20,7 @@ require 'openc3/utilities/open_telemetry'
 
 module OpenC3
   class TelemetryDecomTopic < Topic
-    def self.write_packet(packet, id: nil, scope:)
+    def self.write_packet(packet, id: nil, include_limits_states: true, scope:)
       OpenC3.in_span("write_packet") do
         # Need to build a JSON hash of the decommutated data
         # Support "downward typing"
@@ -29,7 +29,7 @@ module OpenC3
         # If nothing - item does not exist - nil
         # __ as separators ITEM1, ITEM1__C, ITEM1__F
 
-        json_hash = CvtModel.build_json_from_packet(packet)
+        json_hash = CvtModel.build_json_from_packet(packet, include_limits_states: include_limits_states)
         # Convert to JSON-safe types once and reuse for both topic write and CVT set
         json_safe_hash = json_hash.as_json
         json_data = JSON.generate(json_safe_hash, allow_nan: true)

data/lib/openc3/utilities/aws_bucket.rb

@@ -213,6 +213,14 @@ module OpenC3
     # If the key is not found return nil
     rescue Aws::S3::Errors::NoSuchKey
       nil
+    # AWS S3 returns 403 AccessDenied rather than 404 NoSuchKey when the caller
+    # does not have s3:ListBucket on the bucket. Callers which probe for an
+    # optional key (i.e. TargetFile.body checking targets_modified first) would
+    # otherwise raise instead of falling through, so treat it as not found.
+    # Warn since a genuine permission problem looks identical from here.
+    rescue Aws::S3::Errors::AccessDenied
+      Logger.warn("Access denied reading #{bucket}/#{key}. Treating as not found. Verify bucket permissions if this key should exist.")
+      nil
     end
 
     def list_objects(bucket:, prefix: nil, max_request: 1000, max_total: 100_000)
@@ -233,7 +241,7 @@ module OpenC3
       # Array of objects with key and size methods
       result
     rescue Aws::S3::Errors::NoSuchBucket
-      raise NotFound, "Bucket '#{bucket}' does not exist."
+      raise NotFound, "Bucket '#{bucket}' does not exist (list_objects)"
     end
 
     # Lists the files under a specified path
@@ -283,7 +291,7 @@ module OpenC3
       end
       result
     rescue Aws::S3::Errors::NoSuchBucket
-      raise NotFound, "Bucket '#{bucket}' does not exist."
+      raise NotFound, "Bucket '#{bucket}' does not exist (list_files)"
     end
 
     # get metadata for a specific object

data/lib/openc3/utilities/cli_generator.rb

@@ -1,4 +1,4 @@
-# encoding: ascii-8bit
+# encoding: utf-8
 
 # Copyright 2026 OpenC3, Inc.
 # All Rights Reserved.
@@ -478,6 +478,10 @@ RUBY
           VARIABLE #{target_name.downcase}_target_name #{target_name}
 
           TARGET #{target_name} <%= #{target_name.downcase}_target_name %>
+            # Decom tlm and cmd data in the time-series database is kept forever by default.
+            # Uncomment to enforce a 30 day retention time. See https://docs.openc3.com/docs/configuration/plugins
+            # CMD_DECOM_RETAIN_TIME 30d
+            # TLM_DECOM_RETAIN_TIME 30d
           #{interface_line}
             MAP_TARGET <%= #{target_name.downcase}_target_name %>
         DOC

data/lib/openc3/utilities/csv.rb

@@ -59,7 +59,7 @@ module OpenC3
     # @param index [Integer] Which value to return
     # @return [Boolean] Single value converted to a boolean (true or false)
     def bool(item, index = 0)
-      raise "#{item} not found" unless keys.include?(item)
+      raise "CSV key '#{item}' not found for bool conversion" unless keys.include?(item)
 
       if Range === index
         @hash[item][index].map do |x|
@@ -91,7 +91,7 @@ module OpenC3
     # @param index [Integer] Which value to return
     # @return [Integer] Single value converted to an integer
     def int(item, index = 0)
-      raise "#{item} not found" unless keys.include?(item)
+      raise "CSV key '#{item}' not found for int conversion" unless keys.include?(item)
 
       if Range === index
         @hash[item][index].map { |x| x.to_i }
@@ -107,7 +107,7 @@ module OpenC3
     # @param index [Integer] Which value to return
     # @return [Float] Single value converted to a float
     def float(item, index = 0)
-      raise "#{item} not found" unless keys.include?(item)
+      raise "CSV key '#{item}' not found for float conversion" unless keys.include?(item)
 
       if Range === index
         @hash[item][index].map { |x| x.to_f }
@@ -122,7 +122,7 @@ module OpenC3
     # @param index [Integer] Which value to return
     # @return [String] Single value converted to a string
     def string(item, index = 0)
-      raise "#{item} not found" unless keys.include?(item)
+      raise "CSV key '#{item}' not found for string lookup" unless keys.include?(item)
 
       if Range === index
         @hash[item][index].map { |x| x.to_s }
@@ -138,7 +138,7 @@ module OpenC3
     # @param index [Integer] Which value to return
     # @return [Symbol] Single value converted to a symbol
     def symbol(item, index = 0)
-      raise "#{item} not found" unless keys.include?(item)
+      raise "CSV key '#{item}' not found for symbol lookup" unless keys.include?(item)
 
       if Range === index
         @hash[item][index].map { |x| x.intern }

data/lib/openc3/utilities/env_helper.rb

@@ -1,4 +1,16 @@
-# For simple boolean flags
+# encoding: ascii-8bit
+
+# Copyright 2026 OpenC3, Inc.
+# All Rights Reserved.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See LICENSE.md for more details.
+#
+# This file may also be used under the terms of a commercial license
+# if purchased from OpenC3, Inc.
+
 class EnvHelper
   def self.enabled?(key)
     ['true', '1', 'yes', 'on'].include?(ENV[key].to_s.downcase)

data/lib/openc3/utilities/local_mode.rb

@@ -485,7 +485,10 @@ module OpenC3
       config_path = "#{OPENC3_LOCAL_MODE_PATH}/#{scope}/settings/#{name}.json"
       return unless File.expand_path(config_path).start_with?(OPENC3_LOCAL_MODE_PATH)
       FileUtils.mkdir_p(File.dirname(config_path))
-      # Anything can be stored as a setting so write it out directly
+      # Anything can be stored as a setting. Strings are written directly since
+      # they're already the serialized form. Anything else is written as JSON so
+      # sync_settings can read it back rather than a Ruby inspect string.
+      data = JSON.generate(data.as_json(:allow_nan => true)) unless String === data
       File.write(config_path, data)
     end