openc3 7.4.1 → 7.5.0

data/lib/openc3/system/system.rb

@@ -78,7 +78,8 @@ module OpenC3
     end
 
     # target_version can also be the actual hash used in the target_archives folder
-    def self.setup_targets(target_names, base_dir, target_version: 'current', scope:)
+    # @param descriptions [Boolean] Whether to keep packet and item descriptions
+    def self.setup_targets(target_names, base_dir, target_version: 'current', scope:, descriptions: true)
       # Nothing to do if there are no targets
       return if target_names.nil? or target_names.length == 0
       if @@instance.nil?
@@ -118,7 +119,7 @@ module OpenC3
         end
 
         # Build System from targets
-        System.instance(target_names, targets_path)
+        System.instance(target_names, targets_path, descriptions: descriptions)
       end
     end
 
@@ -137,14 +138,15 @@ module OpenC3
     #
     # @param target_names [Array of target_names]
     # @param target_config_dir Directory where target config folders are
+    # @param descriptions [Boolean] Whether to keep packet and item descriptions
     # @return [System] The System singleton
-    def self.instance(target_names = nil, target_config_dir = nil)
+    def self.instance(target_names = nil, target_config_dir = nil, descriptions: true)
       return @@instance if @@instance
       raise "System.instance parameters are required on first call" unless target_names and target_config_dir
 
       @@instance_mutex.synchronize do
         return @@instance if @@instance
-        @@instance ||= self.new(target_names, target_config_dir)
+        @@instance ||= self.new(target_names, target_config_dir, descriptions: descriptions)
         @@post_instance_callbacks.each do |callback|
           callback.call
         end
@@ -171,10 +173,11 @@ module OpenC3
     #
     # @param target_names [Array of target names]
     # @param target_config_dir Directory where target config folders are
-    def initialize(target_names, target_config_dir)
+    # @param descriptions [Boolean] Whether to keep packet and item descriptions
+    def initialize(target_names, target_config_dir, descriptions: true)
       OpenC3.add_to_search_path(target_config_dir, true) if target_config_dir
       @targets = {}
-      @packet_config = PacketConfig.new
+      @packet_config = PacketConfig.new(descriptions: descriptions)
       @commands = Commands.new(@packet_config)
       @telemetry = Telemetry.new(@packet_config)
       @limits = Limits.new(@packet_config)

data/lib/openc3/topics/command_decom_topic.rb

@@ -58,7 +58,7 @@ module OpenC3
       msg_hash['json_data'] = JSON.generate(json_hash.as_json, allow_nan: true)
       msg_hash['extra'] = JSON.generate(packet.extra.as_json, allow_nan: true) if packet.extra
       db_shard = Store.db_shard_for_target(packet.target_name, scope: scope)
-      EphemeralStoreQueued.instance(db_shard: db_shard).write_topic(topic, msg_hash)
+      EphemeralStoreQueued.instance(db_shard: db_shard).write_topic(topic, msg_hash, minid: Topic.stream_safety_minid)
     end
 
     def self.get_cmd_item(target_name, packet_name, param_name, type: :FORMATTED, scope: $openc3_scope)

data/lib/openc3/topics/command_topic.rb

@@ -35,7 +35,8 @@ module OpenC3
                    buffer: packet.buffer(false) }
       msg_hash[:extra] = JSON.generate(packet.extra.as_json, allow_nan: true) if packet.extra
       db_shard = Store.db_shard_for_target(packet.target_name, scope: scope)
-      EphemeralStoreQueued.instance(db_shard: db_shard).write_topic(topic, msg_hash)
+      minid = Topic.log_stream_safety_minid(packet.target_name, :CMD, scope: scope)
+      EphemeralStoreQueued.instance(db_shard: db_shard).write_topic(topic, msg_hash, minid: minid)
     end
 
     # @param command [Hash] Command hash structure read to be written to a topic

data/lib/openc3/topics/router_topic.rb

@@ -84,7 +84,8 @@ module OpenC3
         Topic.write_topic(topic, { 'target_name' => packet.target_name, 'cmd_name' => packet.packet_name, 'cmd_buffer' => packet.buffer(false) }, '*', 100)
       elsif target_names.length == 1
         topic = "{#{scope}__CMD}TARGET__#{target_names[0]}"
-        Topic.write_topic(topic, { 'target_name' => packet.target_name ? packet.target_name : 'UNKNOWN', 'cmd_name' => 'UNKNOWN', 'cmd_buffer' => packet.buffer(false) }, '*', 100)
+        # Name the routed target so the interface identifies against it (and sends it as UNKNOWN if that fails)
+        Topic.write_topic(topic, { 'target_name' => target_names[0], 'cmd_name' => 'UNKNOWN', 'cmd_buffer' => packet.buffer(false) }, '*', 100)
       else
         raise "No route for command: #{packet.target_name ? packet.target_name : 'UNKNOWN'} #{packet.packet_name ? packet.packet_name : 'UNKNOWN'}"
       end

data/lib/openc3/topics/telemetry_decom_topic.rb

@@ -45,7 +45,7 @@ module OpenC3
         }
         msg_hash[:extra] = JSON.generate(packet.extra.as_json, allow_nan: true) if packet.extra
         db_shard = Store.db_shard_for_target(packet.target_name, scope: scope)
-        Topic.write_topic("#{scope}__DECOM__{#{packet.target_name}}__#{packet.packet_name}", msg_hash, id, db_shard: db_shard)
+        Topic.write_topic("#{scope}__DECOM__{#{packet.target_name}}__#{packet.packet_name}", msg_hash, id, minid: Topic.stream_safety_minid(id), db_shard: db_shard)
 
         unless packet.stored
           # Also update the current value table with the latest decommutated data

data/lib/openc3/topics/telemetry_topic.rb

@@ -33,10 +33,11 @@ module OpenC3
       msg_hash[:extra] = JSON.generate(packet.extra.as_json, allow_nan: true) if packet.extra
       topic = "#{scope}__TELEMETRY__{#{packet.target_name}}__#{packet.packet_name}"
       db_shard = Store.db_shard_for_target(packet.target_name, scope: scope)
+      minid = Topic.log_stream_safety_minid(packet.target_name, :TLM, scope: scope)
       if queued
-        EphemeralStoreQueued.instance(db_shard: db_shard).write_topic(topic, msg_hash)
+        EphemeralStoreQueued.instance(db_shard: db_shard).write_topic(topic, msg_hash, minid: minid)
       else
-        Topic.write_topic(topic, msg_hash, db_shard: db_shard)
+        Topic.write_topic(topic, msg_hash, minid: minid, db_shard: db_shard)
       end
     end
   end

data/lib/openc3/topics/topic.rb

@@ -16,9 +16,48 @@
 # if purchased from OpenC3, Inc.
 
 require 'openc3/utilities/store'
+require 'openc3/utilities/logger'
 
 module OpenC3
   class Topic
+    # Stream trimming contract for the high rate target streams
+    # (TELEMETRY__, COMMAND__, DECOM__, DECOMCMD__):
+    #
+    # The streams are primarily trimmed by their consumers once the data is safely
+    # persisted elsewhere:
+    #   * TELEMETRY__ / COMMAND__ are trimmed by the log microservice (LogWriter) once a
+    #     log file has been moved to the bucket plus LogWriter::CLEANUP_DELAY.
+    #   * DECOM__ / DECOMCMD__ are trimmed by the TSDB microservice which keeps
+    #     TsdbMicroservice::TRIM_KEEP_MS of data.
+    #
+    # If a trimmer is absent (logging disabled, no TSDB) or falls far behind, the streams
+    # would grow without bound. As a safety net every write to these streams also passes
+    # an approximate XADD MINID so no entry older than the safety max age is retained.
+    # The max age is OPENC3_STREAM_MAX_AGE_SECONDS (default 600s, 0 or empty disables) and is
+    # never less than STREAM_MAX_AGE_MIN_SECONDS. For TELEMETRY__ / COMMAND__ the max age is
+    # never less than two log cycles plus the cleanup delay, because historical streaming reads
+    # data not yet in the bucket from the stream.
+    #
+    # When the minid is calculated from now (auto generated ids) it uses this host's clock while
+    # Redis generates the ids from its own clock. A writer clock ahead of Redis by more than the
+    # max age would trim the entire stream (including the entry being added) so hosts must be
+    # time synchronized (NTP).
+    STREAM_MAX_AGE_DEFAULT_SECONDS = 600
+    # Twice TsdbMicroservice::TRIM_KEEP_MS. Also protects against small clock offsets.
+    STREAM_MAX_AGE_MIN_SECONDS = 120
+    # LogWriter::CLEANUP_DELAY is defined from this
+    LOG_CLEANUP_DELAY_SECONDS = 60
+    # TargetModel default log cycle time
+    DEFAULT_LOG_CYCLE_TIME_SECONDS = 600
+    # How long to wait before retrying a failed log cycle time lookup
+    LOG_CYCLE_LOOKUP_RETRY_SECONDS = 60
+    # These are calculated on the write path of every packet so they are cached per process.
+    # The environment doesn't change while a microservice runs and the log cycle time only
+    # changes when the plugin (and therefore the microservices) are reinstalled.
+    @@stream_max_age_ms = nil
+    @@log_stream_max_age_ms = {}
+    @@log_cycle_lookup_retry_at = {}
+
     # Delegate all unknown class methods to EphemeralStore db_shard 0 (system-level topics)
     def self.method_missing(message, *args, **kwargs, &block)
       EphemeralStore.public_send(message, *args, **kwargs, &block)
@@ -37,8 +76,121 @@ module OpenC3
     # DB_Shard-aware topic methods for target-specific streams.
     # These explicitly route to the correct EphemeralStore db_shard.
 
-    def self.write_topic(topic, msg_hash, id = '*', maxlen = nil, approximate = 'true', db_shard: 0)
-      EphemeralStore.instance(db_shard: db_shard).write_topic(topic, msg_hash, id, maxlen, approximate)
+    def self.write_topic(topic, msg_hash, id = '*', maxlen = nil, approximate = 'true', minid: nil, db_shard: 0)
+      EphemeralStore.instance(db_shard: db_shard).write_topic(topic, msg_hash, id, maxlen, approximate, minid: minid)
+    end
+
+    # @return [Float] Configured safety max age in seconds (<= 0 means disabled)
+    def self.stream_max_age_seconds
+      value = ENV.fetch('OPENC3_STREAM_MAX_AGE_SECONDS', nil)
+      return STREAM_MAX_AGE_DEFAULT_SECONDS if value.nil?
+      return 0.0 if value.strip.empty?
+      # Strictly parse and reject nan / inf, which would raise when converted to
+      # milliseconds on every write. A typo keeps the safety cap at the default
+      # rather than disabling it.
+      seconds = Float(value, exception: false)
+      return seconds if seconds&.finite?
+      Logger.warn("OPENC3_STREAM_MAX_AGE_SECONDS of '#{value}' is invalid, using #{STREAM_MAX_AGE_DEFAULT_SECONDS}")
+      return STREAM_MAX_AGE_DEFAULT_SECONDS
+    end
+
+    # @return [Integer] Cached safety max age in milliseconds (0 means disabled)
+    def self.stream_max_age_ms
+      @@stream_max_age_ms ||= begin
+        seconds = stream_max_age_seconds
+        if seconds <= 0
+          0
+        elsif seconds < STREAM_MAX_AGE_MIN_SECONDS
+          Logger.warn("OPENC3_STREAM_MAX_AGE_SECONDS of #{seconds} is below the minimum, using #{STREAM_MAX_AGE_MIN_SECONDS}")
+          STREAM_MAX_AGE_MIN_SECONDS * 1000
+        else
+          (seconds * 1000).to_i
+        end
+      end
+    end
+
+    # Calculates the MINID to pass to XADD to cap the age of entries in a target stream.
+    # The cap is anchored to the id being written (or now for auto generated ids) so an
+    # explicitly id'd entry (e.g. decom reusing the raw packet id) is never trimmed by its own add.
+    #
+    # @param id [String] The id being written ('*' or nil for auto generation)
+    # @param max_age_ms [Integer] Max age to retain (<= 0 means disabled)
+    # @return [String|nil] The minid or nil if the safety cap is disabled
+    def self.stream_safety_minid(id = '*', max_age_ms: stream_max_age_ms)
+      return nil if max_age_ms <= 0
+      if id.nil? or id == '*'
+        base_ms = Process.clock_gettime(Process::CLOCK_REALTIME, :millisecond)
+      else
+        base_ms = id.to_s.to_i # Stops at the '-' sequence separator
+      end
+      minid_ms = base_ms - max_age_ms
+      return nil if minid_ms <= 0
+      return minid_ms.to_s
+    end
+
+    # Calculates the MINID for a TELEMETRY__ / COMMAND__ stream write which also never
+    # trims younger than log_stream_min_age_seconds. The resulting max age is cached per stream.
+    #
+    # @param target_name [String] Target name
+    # @param cmd_or_tlm [Symbol] :CMD or :TLM
+    # @return [String|nil] The minid or nil if the safety cap is disabled
+    def self.log_stream_safety_minid(target_name, cmd_or_tlm, scope:)
+      target_cache = ((@@log_stream_max_age_ms[scope] ||= {})[target_name] ||= {})
+      max_age_ms = target_cache[cmd_or_tlm]
+      unless max_age_ms
+        max_age_ms = log_stream_max_age_ms(target_name, cmd_or_tlm, scope: scope)
+        return nil unless max_age_ms # Log cycle time unknown so don't cap yet
+        target_cache[cmd_or_tlm] = max_age_ms
+      end
+      return stream_safety_minid(max_age_ms: max_age_ms)
+    end
+
+    # @param target_name [String] Target name
+    # @param cmd_or_tlm [Symbol] :CMD or :TLM
+    # @return [Integer|nil] Max age in milliseconds for a TELEMETRY__ / COMMAND__ stream (0 means
+    #   disabled) or nil if the log cycle time couldn't be determined. Guessing the log cycle time
+    #   could trim data historical streaming still needs, so the stream isn't capped until a
+    #   lookup (retried every LOG_CYCLE_LOOKUP_RETRY_SECONDS) succeeds.
+    def self.log_stream_max_age_ms(target_name, cmd_or_tlm, scope:)
+      max_age_ms = stream_max_age_ms
+      return max_age_ms if max_age_ms <= 0
+      key = [scope, target_name, cmd_or_tlm]
+      now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      retry_at = @@log_cycle_lookup_retry_at[key]
+      return nil if retry_at and now < retry_at
+      begin
+        min_age_ms = log_stream_min_age_seconds(target_name, cmd_or_tlm, scope: scope) * 1000
+      rescue => e
+        Logger.warn("Unable to determine log cycle time for #{target_name} #{cmd_or_tlm}, stream age not capped: #{e.message}")
+        @@log_cycle_lookup_retry_at[key] = now + LOG_CYCLE_LOOKUP_RETRY_SECONDS
+        return nil
+      end
+      @@log_cycle_lookup_retry_at.delete(key)
+      return [max_age_ms, min_age_ms].max
+    end
+
+    # Minimum age to retain in a TELEMETRY__ / COMMAND__ stream so the log microservice
+    # and historical streaming always have the data not yet moved to the bucket.
+    #
+    # @param target_name [String] Target name
+    # @param cmd_or_tlm [Symbol] :CMD or :TLM
+    # @return [Integer] Minimum age in seconds
+    # @raise If the TargetModel lookup fails
+    def self.log_stream_min_age_seconds(target_name, cmd_or_tlm, scope:)
+      require 'openc3/models/target_model'
+      cycle_time = DEFAULT_LOG_CYCLE_TIME_SECONDS
+      model = TargetModel.get(name: target_name, scope: scope)
+      if model
+        value = model[cmd_or_tlm == :CMD ? 'cmd_log_cycle_time' : 'tlm_log_cycle_time'].to_i
+        cycle_time = value if value > 0
+      end
+      return 2 * (cycle_time + LOG_CLEANUP_DELAY_SECONDS)
+    end
+
+    def self.clear_stream_max_age_cache
+      @@stream_max_age_ms = nil
+      @@log_stream_max_age_ms = {}
+      @@log_cycle_lookup_retry_at = {}
     end
 
     def self.read_topics(topics, offsets = nil, timeout_ms = 1000, count = nil, db_shard: 0, &block)

data/lib/openc3/utilities/cli_generator.rb

@@ -11,6 +11,8 @@
 # This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
+require 'open3'
+
 module OpenC3
   class CliGenerator
     GENERATORS = %w(plugin target microservice widget conversion processor limits_response tool tool_vue tool_angular tool_react tool_svelte command_validator)
@@ -392,9 +394,26 @@ module OpenC3
       end
       FileUtils.mkdir(plugin_name)
       Dir.chdir(plugin_name) # Change to the plugin path to make copying easier
+      # Every installed plugin's lib/ goes on sys.path, so python code shared
+      # across the plugin lives in a package named after the plugin rather than
+      # directly in lib/, where a same-named module in another plugin collides.
+      package_name = plugin_name.gsub(/[^a-z0-9]+/, '_')
 
       process_template("#{TEMPLATES_DIR}/plugin", binding) do |filename|
         filename.sub!("plugin.gemspec", "#{plugin_name}.gemspec")
+        filename.sub!("lib/PACKAGE", "lib/#{package_name}")
+        # Only python plugins get a pyproject.toml. Shipping one in every plugin
+        # would make install_phase2 take the python dependency path (and build a
+        # per-plugin venv) for plugins that have no python code at all.
+        #
+        # lib/ comes with it because pyproject.toml sets ty's extra-paths to
+        # lib/, and ty exits non-zero rather than warning when a configured path
+        # does not exist. The package's __init__.py does reach the gem, which is
+        # harmless: the gem's pyproject.toml already sets needs_dependencies.
+        if @@language != 'py'
+          next true if filename == 'pyproject.toml'
+          next true if filename == 'lib' or filename.start_with?('lib/')
+        end
         false
       end
 
@@ -409,10 +428,28 @@ module OpenC3
         end
       end
 
+      write_python_version if @@language == 'py'
+
       puts "Plugin #{plugin_name} successfully generated!"
       return plugin_name
     end
 
+    # Pin the plugin's local uv environment to the Python minor version COSMOS
+    # runs, read from the interpreter itself rather than hardcoded in the
+    # template: it differs between images (Debian vs UBI) and moves with the base
+    # image. `cli generate` runs in the cmd-tlm-api image, which sets
+    # OPENC3_PYTHON_BIN. Outside an image (e.g. the gem installed on a dev
+    # machine) there is no COSMOS Python to match, so no file is written.
+    def self.write_python_version
+      python_bin = ENV.fetch('OPENC3_PYTHON_BIN', nil)
+      return if python_bin.nil? || !File.executable?(python_bin)
+      version, status = Open3.capture2(python_bin, '-c', 'import sys; print("%d.%d" % sys.version_info[:2])')
+      return unless status.success? && version.strip =~ /\A\d+\.\d+\z/
+      File.write('.python-version', "#{version.strip}\n")
+    rescue SystemCallError
+      nil
+    end
+
     def self.generate_target(args)
       validate_language_inheriting_args!('target', args,
         example: ['cli generate target EXAMPLE --ruby', 'Creates: targets/EXAMPLE/'],
@@ -447,18 +484,33 @@ module OpenC3
         end
         gemspec_filename = Dir['*.gemspec'][0]
         gemspec = File.read(gemspec_filename)
-        gemspec.gsub!(/s\.files = Dir\.glob.*\n/) do |match|
-          <<RUBY
-# Prefer pyproject.toml over requirements.txt
-  python_dep_file = if File.exist?('pyproject.toml')
-    'pyproject.toml'
-  else
-    'requirements.txt'
-  end
-  s.files = Dir.glob("{targets,lib,public,tools,microservices}/**/*") + %w(Rakefile README.md LICENSE.md plugin.txt) + [python_dep_file]
-RUBY
+        # Older COSMOS versions wrote a singular python_dep_file block that never
+        # ships uv.lock, and a second python target nested another copy of it.
+        # Strip every copy plus its use on the s.files line so the rewrite below
+        # replaces it. A hand-edited block that no longer matches leaves some
+        # python_dep_file reference behind, so the gemspec is kept as it was.
+        legacy_block = /^ *# Prefer pyproject\.toml over requirements\.txt\n *python_dep_file = if File\.exist\?\('pyproject\.toml'\)\n *'pyproject\.toml'\n *else\n *'requirements\.txt'\n *end\n/
+        upgraded = gemspec.gsub(legacy_block, '').sub(' + [python_dep_file]', '')
+        gemspec = upgraded unless upgraded.include?('python_dep_file')
+        # Skip when a previous python target already rewrote s.files: the line it
+        # wrote matches the pattern below too, so rewriting again would nest a
+        # second dependency block. python_dep_file also covers a legacy block
+        # the upgrade above left alone. Also skip a gemspec from the
+        # python plugin template, which already ships pyproject.toml and uv.lock.
+        unless gemspec.include?('python_dep_file') || gemspec.include?('pyproject.toml')
+          gemspec.gsub!(/^ *s\.files = Dir\.glob.*\n/) do
+            <<~RUBY.gsub(/^/, '  ')
+              # Prefer pyproject.toml (plus uv.lock if committed) over requirements.txt
+              python_dep_files = if File.exist?('pyproject.toml')
+                ['pyproject.toml'] + Dir.glob('uv.lock')
+              else
+                ['requirements.txt']
+              end
+              s.files = Dir.glob("{targets,lib,public,tools,microservices}/**/*") + %w(Rakefile README.md LICENSE.md plugin.txt) + python_dep_files
+            RUBY
+          end
+          File.write(gemspec_filename, gemspec)
         end
-        File.write(gemspec_filename, gemspec)
 
         target_txt_filename = "targets/#{target_name}/target.txt"
         target_txt = File.read(target_txt_filename)
@@ -626,8 +678,8 @@ RUBY
             arguments: common_args,
             notes: common_note,
             example: [
-              "cli generate #{args[0]} 'Data Viewer'",
-              "Creates: tools/dataviewer/ (#{framework}-based)",
+              "cli generate #{args[0]} 'Mission Planner'",
+              "Creates: tools/missionplanner/ (#{framework}-based)",
             ],
             in_plugin_extra: 'For other tool types, see: cli generate tool --help',
             docs: docs_url,
@@ -650,8 +702,8 @@ RUBY
               ],
             },
             example: [
-              "cli generate tool 'Data Viewer'",
-              'Creates: tools/dataviewer/',
+              "cli generate tool 'Mission Planner'",
+              'Creates: tools/missionplanner/',
             ],
             docs: docs_url,
             exit_code: (args[1].nil? ? 1 : 0),

data/lib/openc3/utilities/config_overlay.rb

@@ -15,24 +15,27 @@ module OpenC3
   # Shared predicates describing which parts of the user-writable config overlay
   # (targets_modified) a non-admin may write.
   #
-  # The cmd_tlm overlay (targets_modified/<TARGET>/cmd_tlm/...) is loaded by
-  # System.setup_targets and processed by PacketConfig, which evaluates
-  # GENERIC_READ_CONVERSION / GENERIC_WRITE_CONVERSION blocks as code in the
-  # decom microservices. Writing it is therefore an admin operation, matching the
-  # tier COSMOS requires everywhere else code is introduced (plugin install).
-  # Only the server-side dynamic-packet mechanism (TargetModel#dynamic_update)
-  # writes that area without going through an API request.
+  # Two target subdirectories hold definitions whose GENERIC_READ_CONVERSION /
+  # GENERIC_WRITE_CONVERSION blocks are evaluated as code:
+  #   - <TARGET>/cmd_tlm/...: loaded by System.setup_targets and processed by
+  #     PacketConfig in the decom microservices. Only the server-side
+  #     dynamic-packet mechanism (TargetModel#dynamic_update) writes that area
+  #     without going through an API request.
+  #   - <TARGET>/tables/config/...: table definitions, processed by TableConfig
+  #     in cmd-tlm-api for every Table Manager operation.
+  # Writing either is therefore an admin operation, matching the tier COSMOS
+  # requires everywhere else code is introduced (plugin install).
   #
   # Every API writer that can reach the overlay must consult these predicates:
   #   - storage_controller#get_upload_presigned_request / delete (presigned S3 upload)
-  #   - tables_controller#save / save_as / generate / destroy (Table -> TargetFile)
+  #   - tables_controller#save / save_as / report / destroy (Table -> TargetFile)
   #   - scripts_controller#create / destroy (Script -> TargetFile)
   module ConfigOverlay
     # Config bucket areas a non-admin is allowed to write at all
     NON_ADMIN_AREAS = ['targets_modified', 'tmp'].freeze
 
-    # Target subdirectory whose contents are executed as code
-    CODE_AREA = 'cmd_tlm'
+    # Target subdirectories whose contents are executed as code
+    CODE_AREAS = [['cmd_tlm'], ['tables', 'config']].freeze
 
     # Split a path into segments, or nil if the path is not canonical.
     #
@@ -48,14 +51,23 @@ module OpenC3
       parts
     end
 
-    # True if the overlay-relative name targets the cmd_tlm subtree, i.e. writing
-    # it requires admin. Name is relative to targets_modified/, e.g.
-    # "<TARGET>/cmd_tlm/tlm.txt". Fails closed (true) on non-canonical names.
-    def self.cmd_tlm_overlay?(name)
+    # True if the overlay-relative name targets a code area (cmd_tlm or
+    # tables/config), i.e. writing it requires admin. Name is relative to
+    # targets_modified/, e.g. "<TARGET>/cmd_tlm/tlm.txt". Fails closed (true)
+    # on non-canonical names.
+    def self.code_overlay?(name)
       parts = canonical_parts(name)
       return true if parts.nil?
-      # parts: <TARGET> / <area> / ...
-      parts[1] == CODE_AREA
+      code_area?(parts)
+    end
+
+    # True if the target-relative name is a canonical table definition path,
+    # e.g. "<TARGET>/tables/config/table_def.txt". Table only parses definitions
+    # from here, so a definition can't be pointed at a non-admin overlay area.
+    def self.table_definition?(name)
+      parts = canonical_parts(name)
+      return false if parts.nil?
+      parts.length > 3 and parts[1, 2] == ['tables', 'config']
     end
 
     # True if the given config bucket key is an overlay path a non-admin may
@@ -68,8 +80,14 @@ module OpenC3
       # parts: <SCOPE> / <area> / <TARGET> / <subdir> / ...
       area = parts[1]
       return false unless NON_ADMIN_AREAS.include?(area)
-      return false if area == 'targets_modified' && parts[3] == CODE_AREA
+      return false if area == 'targets_modified' && code_area?(parts[2..])
       true
     end
+
+    # target_parts: <TARGET> / <subdir> / ...
+    def self.code_area?(target_parts)
+      CODE_AREAS.any? { |area| target_parts[1, area.length] == area }
+    end
+    private_class_method :code_area?
   end
 end

data/lib/openc3/utilities/default_plugins.rb

@@ -0,0 +1,33 @@
+# 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.
+
+require 'yaml'
+
+module OpenC3
+  # The plugins that ship with COSMOS. The list lives in
+  # data/config/default_plugins.yaml and is shared with the Admin Plugins tab
+  # and the script API via the 'default' flag from GET /openc3-api/plugins/all
+  module DefaultPlugins
+    # Short names, i.e. without the version or the __ suffix
+    NAMES = YAML.safe_load_file(
+      File.expand_path('../../../data/config/default_plugins.yaml', __dir__)
+    ).freeze
+
+    # True if the plugin (e.g. "openc3-cosmos-tool-admin-6.0.0.gem__20260101000000")
+    # is one that ships with COSMOS
+    def self.default?(plugin_name)
+      # Strip the __ suffix and the trailing -version.gem to get the short name
+      NAMES.include?(plugin_name.split('__')[0].split('-')[0..-2].join('-'))
+    end
+  end
+end