openc3 7.2.1 → 7.4.0

data/lib/openc3/utilities/running_script.rb

@@ -28,6 +28,7 @@ require 'openc3/utilities/script'
 require 'openc3/utilities/store'
 require 'openc3/utilities/store_queued'
 require 'openc3/utilities/bucket_require'
+require 'openc3/utilities/python_venv'
 require 'openc3/models/offline_access_model'
 require 'openc3/models/environment_model'
 require 'openc3/models/script_engine_model'
@@ -36,7 +37,7 @@ require 'fileutils'
 
 if not defined? RAILS_ROOT
   if ENV['RAILS_ROOT']
-    RAILS_ROOT = ENV['RAILS_ROOT']
+    RAILS_ROOT = ENV.fetch('RAILS_ROOT')
   elsif defined? Rails
     RAILS_ROOT = Rails.root
   else
@@ -432,11 +433,11 @@ class RunningScript
     self.class.message_log
   end
 
-  def self.spawn(scope, name, suite_runner = nil, disconnect = false, environment = nil, user_full_name = nil, username = nil, line_no = nil, end_line_no = nil)
+  def self.spawn(scope, name, suite_runner = nil, disconnect = false, environment = nil, user_full_name = nil, username = nil, line_no = nil, end_line_no = nil, python_venv = nil)
     extension = File.extname(name).to_s.downcase
     script_engine = nil
     if extension == '.py'
-      process_name = ENV['OPENC3_PYTHON_BIN'] || '/openc3/python/.venv/bin/python'
+      process_name = ENV.fetch('OPENC3_PYTHON_BIN', '/openc3/python/.venv/bin/python')
       runner_path = File.join(RAILS_ROOT, 'scripts', 'run_script.py')
     elsif extension == '.rb'
       process_name = 'ruby'
@@ -449,7 +450,7 @@ class RunningScript
       if script_engine_model
         script_engine = script_engine_model.filename
         if File.extname(script_engine).to_s.downcase == '.py'
-          process_name = ENV['OPENC3_PYTHON_BIN'] || '/openc3/python/.venv/bin/python'
+          process_name = ENV.fetch('OPENC3_PYTHON_BIN', '/openc3/python/.venv/bin/python')
           runner_path = File.join(RAILS_ROOT, 'scripts', 'run_script.py')
         else
           process_name = 'ruby'
@@ -468,103 +469,126 @@ class RunningScript
     user_full_name ||= 'Anonymous'
     start_time = Time.now.utc.iso8601
 
-    process = ChildProcess.build(process_name, runner_path.to_s, running_script_id.to_s, scope)
-    process.io.inherit! # Helps with debugging
-    script_cwd = File.join(RAILS_ROOT, 'tmp', "script_#{running_script_id}")
-    FileUtils.mkdir_p(script_cwd)
-    process.cwd = script_cwd
-
-    # Check for offline access token
-    model = nil
-    model = OpenC3::OfflineAccessModel.get_model(name: username, scope: scope) if username != 'Anonymous'
-
-    # Load the global environment variables
-    status_environment = {}
-    values = OpenC3::EnvironmentModel.all(scope: scope).values
-    values.each do |env|
-      process.environment[env['key']] = env['value']
-      status_environment[env['key']] = env['value']
-    end
-    # Load the script specific ENV vars set by the GUI
-    # These can override the previously defined global env vars
-    if environment
-      environment.each do |env|
+    begin
+      process = ChildProcess.build(process_name, runner_path.to_s, running_script_id.to_s, scope)
+      process.io.inherit! # Helps with debugging
+      script_cwd = File.join(RAILS_ROOT, 'tmp', "script_#{running_script_id}")
+      FileUtils.mkdir_p(script_cwd)
+      process.cwd = script_cwd
+
+      # Check for offline access token
+      model = nil
+      model = OpenC3::OfflineAccessModel.get_model(name: username, scope: scope) if username != 'Anonymous'
+
+      # Load the global environment variables
+      status_environment = {}
+      values = OpenC3::EnvironmentModel.all(scope: scope).values
+      values.each do |env|
         process.environment[env['key']] = env['value']
         status_environment[env['key']] = env['value']
       end
-    end
+      # Load the script specific ENV vars set by the GUI
+      # These can override the previously defined global env vars
+      if environment
+        environment.each do |env|
+          process.environment[env['key']] = env['value']
+          status_environment[env['key']] = env['value']
+        end
+      end
 
-    script_status = OpenC3::ScriptStatusModel.new(
-      name: running_script_id.to_s, # Unique id for this script
-      state: 'spawning', # State will be spawning until the script is running
-      shard: 0, # Future enhancement of script runner shards
-      filename: name, # Initial filename never changes
-      current_filename: name, # Current filename updates while we are running
-      line_no: 0, # 0 means not running yet
-      start_line_no: line_no || 1, # Line number to start running the script
-      end_line_no: end_line_no || nil, # Line number to stop running the script
-      username: username, # username of the person who started the script
-      user_full_name: user_full_name, # full name of the person who started the script
-      start_time: start_time, # Time the script started ISO format
-      end_time: nil, # Time the script ended ISO format
-      disconnect: disconnect, # Disconnect is set to true if the script is running in a disconnected mode
-      environment: status_environment, # hash of environment variables set for the script
-      suite_runner: suite_runner ? suite_runner : nil, # current suite information if any
-      errors: nil, # array of errors that occurred during the script run
-      pid: nil, # pid of the script process - set by the script itself when it starts
-      script_engine: script_engine, # script engine filename
-      updated_at: nil, # Set by create/update
-      scope: scope # Scope of the script
-    )
-    script_status.create()
-
-    # Set proper secrets for running script
-    process.environment['SECRET_KEY_BASE'] = nil
-    process.environment['OPENC3_REDIS_USERNAME'] = ENV['OPENC3_SR_REDIS_USERNAME']
-    process.environment['OPENC3_REDIS_PASSWORD'] = ENV['OPENC3_SR_REDIS_PASSWORD']
-    process.environment['OPENC3_BUCKET_USERNAME'] = ENV['OPENC3_SR_BUCKET_USERNAME']
-    process.environment['OPENC3_BUCKET_PASSWORD'] = ENV['OPENC3_SR_BUCKET_PASSWORD']
-    process.environment['OPENC3_SR_REDIS_USERNAME'] = nil
-    process.environment['OPENC3_SR_REDIS_PASSWORD'] = nil
-    process.environment['OPENC3_SR_BUCKET_USERNAME'] = nil
-    process.environment['OPENC3_SR_BUCKET_PASSWORD'] = nil
-    process.environment['OPENC3_API_CLIENT'] = ENV['OPENC3_API_CLIENT']
-    if model and model.offline_access_token
-      auth = OpenC3::OpenC3KeycloakAuthentication.new(ENV['OPENC3_KEYCLOAK_URL'])
-      valid_token = auth.get_token_from_refresh_token(model.offline_access_token)
-      if valid_token
-        process.environment['OPENC3_API_TOKEN'] = model.offline_access_token
+      script_status = OpenC3::ScriptStatusModel.new(
+        name: running_script_id.to_s, # Unique id for this script
+        state: 'spawning', # State will be spawning until the script is running
+        shard: 0, # Future enhancement of script runner shards
+        filename: name, # Initial filename never changes
+        current_filename: name, # Current filename updates while we are running
+        line_no: 0, # 0 means not running yet
+        start_line_no: line_no || 1, # Line number to start running the script
+        end_line_no: end_line_no || nil, # Line number to stop running the script
+        username: username, # username of the person who started the script
+        user_full_name: user_full_name, # full name of the person who started the script
+        start_time: start_time, # Time the script started ISO format
+        end_time: nil, # Time the script ended ISO format
+        disconnect: disconnect, # Disconnect is set to true if the script is running in a disconnected mode
+        environment: status_environment, # hash of environment variables set for the script
+        suite_runner: suite_runner ? suite_runner : nil, # current suite information if any
+        errors: nil, # array of errors that occurred during the script run
+        pid: nil, # pid of the script process - set by the script itself when it starts
+        script_engine: script_engine, # script engine filename
+        updated_at: nil, # Set by create/update
+        scope: scope # Scope of the script
+      )
+      script_status.create()
+
+      # Set proper secrets for running script
+      process.environment['SECRET_KEY_BASE'] = nil
+      process.environment['OPENC3_REDIS_USERNAME'] = ENV.fetch('OPENC3_SR_REDIS_USERNAME', nil)
+      process.environment['OPENC3_REDIS_PASSWORD'] = ENV.fetch('OPENC3_SR_REDIS_PASSWORD', nil)
+      process.environment['OPENC3_BUCKET_USERNAME'] = ENV.fetch('OPENC3_SR_BUCKET_USERNAME', nil)
+      process.environment['OPENC3_BUCKET_PASSWORD'] = ENV.fetch('OPENC3_SR_BUCKET_PASSWORD', nil)
+      process.environment['OPENC3_SR_REDIS_USERNAME'] = nil
+      process.environment['OPENC3_SR_REDIS_PASSWORD'] = nil
+      process.environment['OPENC3_SR_BUCKET_USERNAME'] = nil
+      process.environment['OPENC3_SR_BUCKET_PASSWORD'] = nil
+      process.environment['OPENC3_API_CLIENT'] = ENV.fetch('OPENC3_API_CLIENT', nil)
+      if model and model.offline_access_token
+        auth = OpenC3::OpenC3KeycloakAuthentication.new(ENV.fetch('OPENC3_KEYCLOAK_URL', nil))
+        valid_token = auth.get_token_from_refresh_token(model.offline_access_token)
+        if valid_token
+          process.environment['OPENC3_API_TOKEN'] = model.offline_access_token
+        else
+          model.offline_access_token = nil
+          model.update
+          raise "offline_access token invalid for script"
+        end
       else
-        model.offline_access_token = nil
-        model.update
-        raise "offline_access token invalid for script"
+        process.environment['OPENC3_API_USER'] = ENV.fetch('OPENC3_API_USER', nil)
+        if ENV['OPENC3_SERVICE_PASSWORD']
+          process.environment['OPENC3_API_PASSWORD'] = ENV.fetch('OPENC3_SERVICE_PASSWORD')
+        else
+          raise "No authentication available for script"
+        end
       end
-    else
-      process.environment['OPENC3_API_USER'] = ENV['OPENC3_API_USER']
-      if ENV['OPENC3_SERVICE_PASSWORD']
-        process.environment['OPENC3_API_PASSWORD'] = ENV['OPENC3_SERVICE_PASSWORD']
-      else
-        raise "No authentication available for script"
+      process.environment['GEM_HOME'] = ENV.fetch('GEM_HOME', nil)
+
+      python_venv_dir = OpenC3::PythonVenv.configure_for_script(
+        process.environment, name: name, scope: scope, python_venv: python_venv
+      )
+      unless python_venv_dir
+        system_venv = File.dirname(ENV.fetch('OPENC3_PYTHON_BIN', '/openc3/python/.venv/bin/python')).chomp('/bin')
+        process.environment['VIRTUAL_ENV'] = system_venv
+        process.environment['PYTHONUSERBASE'] = ENV.fetch('PYTHONUSERBASE', OpenC3::PythonVenv::DEFAULT_PYTHONUSERBASE)
+        # Deliberately nil when PYTHONPATH is unset rather than defaulting to
+        # something like '.', which would put the script's own working directory
+        # on the import path and let a local file shadow a real module.
+        process.environment['PYTHONPATH'] = ENV.fetch('PYTHONPATH', nil)
       end
-    end
-    process.environment['GEM_HOME'] = ENV['GEM_HOME']
-    process.environment['PYTHONUSERBASE'] = ENV['PYTHONUSERBASE']
-    # Preserve PYTHONPATH to ensure Python can find both UV venv and user packages
-    process.environment['PYTHONPATH'] = ENV['PYTHONPATH']
-
-    # Spawned process should not be controlled by same Bundler constraints as spawning process
-    ENV.each do |key, _value|
-      if key =~ /^BUNDLE/
-        process.environment[key] = nil
+
+      # Spawned process should not be controlled by same Bundler constraints as spawning process
+      ENV.each do |key, _value|
+        if key =~ /^BUNDLE/
+          process.environment[key] = nil
+        end
       end
-    end
-    process.environment['RUBYOPT'] = nil # Removes loading bundler setup
-    process.environment['OPENC3_SCOPE'] = scope
-    process.environment['RAILS_ROOT'] = RAILS_ROOT
+      process.environment['RUBYOPT'] = nil # Removes loading bundler setup
+      process.environment['OPENC3_SCOPE'] = scope
+      process.environment['RAILS_ROOT'] = RAILS_ROOT
 
-    process.detach = true
-    process.start
-    running_script_id
+      process.detach = true
+      process.start
+      running_script_id
+    rescue => e
+      begin
+        # Clean up the orphaned script status record so the script
+        # does not remain stuck in 'spawning' state forever.
+        # Guard against nil in case the error occurred before these were assigned.
+        script_status.destroy() if script_status
+        FileUtils.rm_rf(script_cwd) if script_cwd
+      rescue => cleanup_error
+        OpenC3::Logger.error("Failed to cleanup after spawn failure: #{cleanup_error.message}")
+      end
+      raise e
+    end
   end
 
   def initialize(script_status)
@@ -601,7 +625,7 @@ class RunningScript
 
     # Retrieve file
     @body = ::Script.body(@script_status.scope, @script_status.filename)
-    raise "Script not found: #{@script_status.filename}" if @body.nil?
+    raise "Script not found during initialization: #{@script_status.filename}" if @body.nil?
     breakpoints = @@breakpoints[@script_status.filename]&.filter { |_, present| present }&.map { |line_number, _| line_number - 1 } # -1 because frontend lines are 0-indexed
     breakpoints ||= []
     running_script_anycable_publish("running-script-channel:#{@script_status.id}", { type: :file, filename: @script_status.filename, scope: @script_status.scope, text: @body.to_utf8, breakpoints: breakpoints })
@@ -1476,7 +1500,7 @@ class RunningScript
       running_script_anycable_publish("running-script-channel:#{@script_status.id}", { type: :file, filename: filename, text: @body.to_utf8, breakpoints: breakpoints })
     else
       text = ::Script.body(@script_status.scope, filename)
-      raise "Script not found: #{filename}" if text.nil?
+      raise "Script not found during load/require: #{filename}" if text.nil?
       @@file_cache[filename] = text
       @body = text
       running_script_anycable_publish("running-script-channel:#{@script_status.id}", { type: :file, filename: filename, text: @body.to_utf8, breakpoints: breakpoints })
@@ -1501,7 +1525,7 @@ class RunningScript
     $stdout = OpenC3::Stdout.instance
     $stderr = OpenC3::Stderr.instance
     OpenC3::Logger.stdout = true
-    OpenC3::Logger.level = OpenC3::Logger::INFO
+    OpenC3::Logger.level = OpenC3::Logger.default_level
   end
 
   def output_thread

data/lib/openc3/utilities/s3_autoload.rb

@@ -3,9 +3,9 @@ require 'aws-sdk-s3'
 if ENV['OPENC3_CLOUD'] == 'local'
   Aws.config.update(
     s3: {
-      endpoint: ENV['OPENC3_BUCKET_URL'] || (ENV['OPENC3_DEVEL'] ? 'http://127.0.0.1:9000' : 'http://openc3-buckets:9000'),
-      access_key_id: ENV['OPENC3_BUCKET_USERNAME'],
-      secret_access_key: ENV['OPENC3_BUCKET_PASSWORD'],
+      endpoint: ENV.fetch('OPENC3_BUCKET_URL', nil) || (ENV['OPENC3_DEVEL'] ? 'http://127.0.0.1:9000' : 'http://openc3-buckets:9000'),
+      access_key_id: ENV.fetch('OPENC3_BUCKET_USERNAME', nil),
+      secret_access_key: ENV.fetch('OPENC3_BUCKET_PASSWORD', nil),
       force_path_style: true,
       region: 'us-east-1',
       # Disable automatic checksum calculation for S3-compatible backends (versitygw)
@@ -20,9 +20,9 @@ if ENV['OPENC3_CLOUD'] == 'local'
 else # AWS
   Aws.config.update(
     s3: {
-      endpoint: "https://s3.#{ENV['AWS_REGION']}.amazonaws.com",
+      endpoint: "https://s3.#{ENV.fetch('AWS_REGION', nil)}.amazonaws.com",
       force_path_style: true,
-      region: ENV['AWS_REGION']
+      region: ENV.fetch('AWS_REGION', nil)
     }
   )
 end

data/lib/openc3/utilities/script.rb

@@ -17,6 +17,7 @@
 
 require 'tempfile'
 require 'openc3/utilities/target_file'
+require 'openc3/utilities/python_venv'
 require 'openc3/utilities/running_script'
 require 'openc3/script/suite'
 require 'openc3/script/suite_runner'
@@ -25,34 +26,64 @@ require 'openc3/tools/test_runner/test'
 OpenC3.require_file 'openc3/utilities/store'
 
 class Script < OpenC3::TargetFile
+  # Script lifecycle states and the transitions allowed from each state
+  LIFECYCLE_STATES = %w(development review approved)
+  LIFECYCLE_TRANSITIONS = {
+    'development' => %w(review approved),
+    'review' => %w(development approved),
+    'approved' => %w(review development),
+  }
+
   def self.all(scope, target = nil)
     super(scope, nil, target: target) # No path matchers
   end
 
   def self.lock(scope, name, username)
-    name = name.split('*')[0] # Split '*' that indicates modified
-    OpenC3::Store.hset("#{scope}__script-locks", name, username)
+    OpenC3::Store.hset("#{scope}__script-locks", strip_modified(name), username)
   end
 
   def self.unlock(scope, name)
-    name = name.split('*')[0] # Split '*' that indicates modified
-    OpenC3::Store.hdel("#{scope}__script-locks", name)
+    OpenC3::Store.hdel("#{scope}__script-locks", strip_modified(name))
   end
 
   def self.locked?(scope, name)
-    name = name.split('*')[0] # Split '*' that indicates modified
-    locked_by = OpenC3::Store.hget("#{scope}__script-locks", name)
+    locked_by = OpenC3::Store.hget("#{scope}__script-locks", strip_modified(name))
     locked_by ||= false
     locked_by
   end
 
   def self.get_breakpoints(scope, name)
-    breakpoints = OpenC3::Store.hget("#{scope}__script-breakpoints", name.split('*')[0]) # Split '*' that indicates modified
+    breakpoints = OpenC3::Store.hget("#{scope}__script-breakpoints", strip_modified(name))
     return JSON.parse(breakpoints, allow_nan: true, create_additions: true) if breakpoints
     []
   end
 
-  def self.process_suite(name, contents, new_process: true, username: nil, scope:)
+  def self.temp_file?(name)
+    strip_modified(name).start_with?("#{TEMP_FOLDER}/")
+  end
+
+  def self.lifecycle_enabled?
+    defined?(::VersionStore) && ::VersionStore.enabled?
+  end
+
+  def self.lifecycle(scope, name)
+    return { 'state' => 'development', 'history' => [] } if temp_file?(name)
+    return { 'state' => 'development', 'history' => [] } unless lifecycle_enabled?
+    ::VersionStore.lifecycle(scope: scope, name: strip_modified(name))
+  end
+
+  # current: the caller-known current state; pass it to avoid a redundant git
+  # read when the controller has already fetched it for transition validation.
+  def self.set_lifecycle(scope, name, state, username, comment, current: nil)
+    raise "Cannot set lifecycle on temporary files" if temp_file?(name)
+    raise "Script lifecycle requires the version history store" unless lifecycle_enabled?
+    name = strip_modified(name)
+    current ||= lifecycle(scope, name)['state']
+    ::VersionStore.set_lifecycle(scope: scope, name: name, from: current, to: state,
+                                 username: username, comment: comment)
+  end
+
+  def self.process_suite(name, contents, new_process: true, username: nil, scope:, python_venv: nil)
     python = false
     python = true if File.extname(name) == '.py'
 
@@ -119,10 +150,19 @@ class Script < OpenC3::TargetFile
         end
       end
       process.environment['GEM_HOME'] = ENV['GEM_HOME'] || '/gems'
-      process.environment['PYTHONUSERBASE'] = ENV['PYTHONUSERBASE'] || '/gems/python_packages'
+      process.environment['PYTHONUSERBASE'] = ENV['PYTHONUSERBASE'] || OpenC3::PythonVenv::DEFAULT_PYTHONUSERBASE
       # Preserve PYTHONPATH to ensure Python can find both UV venv and user packages
       process.environment['PYTHONPATH'] = ENV['PYTHONPATH'] || '.'
 
+      # Suite analysis executes Python in a separate process before the script
+      # itself is started. Give that process the same plugin venv visibility as
+      # RunningScript so imports used while defining a suite can be resolved.
+      if python
+        OpenC3::PythonVenv.configure_for_script(
+          process.environment, name: name, scope: scope, python_venv: python_venv
+        )
+      end
+
       # Spawned process should not be controlled by same Bundler constraints as spawning process
       ENV.each do |key, _value|
         if key =~ /^BUNDLE/
@@ -189,7 +229,6 @@ class Script < OpenC3::TargetFile
   def self.delete_temp(scope)
     files = super(scope)
     files.each do |name|
-      # Remove any breakpoints associated with the temp files
       OpenC3::Store.hdel("#{scope}__script-breakpoints", "#{TEMP_FOLDER}/#{File.basename(name)}")
     end
   end
@@ -208,13 +247,14 @@ class Script < OpenC3::TargetFile
     user_full_name = nil,
     username = nil,
     line_no = nil,
-    end_line_no = nil
+    end_line_no = nil,
+    python_venv = nil
   )
     # Verify the script exists before spawning a run. Without this check a run
     # is started and the missing file only surfaces as a runtime error inside
     # the spawned process. Returning nil lets the caller return a 404.
     return nil unless Script.body(scope, name)
-    RunningScript.spawn(scope, name, suite_runner, disconnect, environment, user_full_name, username, line_no, end_line_no)
+    RunningScript.spawn(scope, name, suite_runner, disconnect, environment, user_full_name, username, line_no, end_line_no, python_venv)
   end
 
   def self.instrumented(filename, text)

data/lib/openc3/utilities/secrets.rb

@@ -15,13 +15,58 @@ ENV['OPENC3_SECRET_BACKEND'] ||= 'redis'
 
 module OpenC3
   class Secrets
+    # Default base directory that FILE type secret paths must reside under.
+    # FILE type secrets are written by the operator (or mounted by Kubernetes)
+    # and then read back by the microservice, so the path is a destination we
+    # control, not an arbitrary file on the host.
+    DEFAULT_SECRET_FILE_DIR = '/tmp'
+
     def initialize
       @local_secrets = {}
     end
 
+    # Base directory that FILE type secret paths must reside under
+    def self.secret_file_dir
+      dir = ENV.fetch('OPENC3_SECRET_FILE_DIR', nil)
+      dir = DEFAULT_SECRET_FILE_DIR if dir.nil? or dir.empty?
+      dir
+    end
+
+    # Validates a FILE type secret path. The path must expand to a location
+    # strictly inside Secrets.secret_file_dir. This prevents a plugin
+    # configuration such as 'SECRET FILE KEY /root/.ssh/id_rsa' or
+    # 'SECRET FILE KEY /tmp/../etc/shadow' from reading or overwriting arbitrary
+    # files as the OpenC3 process user.
+    #
+    # @param path [String] Path from a SECRET FILE definition
+    # @return [String] The validated absolute path
+    def self.validate_file_path(path)
+      raise ArgumentError, "Secret file path must be a String but is a #{path.class}" unless path.is_a?(String)
+      raise ArgumentError, "Secret file path must not be blank" if path.strip.empty?
+      raise ArgumentError, "Secret file path must not contain a null byte" if path.include?("\x00")
+
+      # expand_path collapses '..' and '.', expands '~', and makes a relative path
+      # absolute, so the comparison below can't be walked out of. This is
+      # deliberately a purely lexical check: it does not touch the filesystem, so
+      # a path validates identically at plugin install time (cmd-tlm-api) and at
+      # write time (openc3-operator), which are separate containers. Symlinks are
+      # rejected by the operator when it writes the secret.
+      base = File.expand_path(secret_file_dir)
+      absolute = File.expand_path(path)
+      unless absolute.start_with?(base + File::SEPARATOR)
+        raise ArgumentError, "Secret file path '#{path}' must be under '#{base}'"
+      end
+      absolute
+    end
+
+    # @return true if path is inside base, or is base itself
+    def self.path_contained?(base, path)
+      path == base or path.start_with?(base.end_with?(File::SEPARATOR) ? base : base + File::SEPARATOR)
+    end
+
     def self.getClient
       raise 'OPENC3_SECRET_BACKEND environment variable is required' unless ENV['OPENC3_SECRET_BACKEND']
-      secrets_class = ENV['OPENC3_SECRET_BACKEND'].capitalize + 'Secrets'
+      secrets_class = ENV.fetch('OPENC3_SECRET_BACKEND').capitalize + 'Secrets'
       klass = OpenC3.require_class('openc3/utilities/' + secrets_class.class_name_to_filename)
       klass.new
     end
@@ -50,9 +95,9 @@ module OpenC3
         type, key, data, _secret_store = secret
         case type
         when 'ENV'
-          @local_secrets[key] = ENV[data]
+          @local_secrets[key] = ENV.fetch(data, nil)
         when 'FILE'
-          @local_secrets[key] = File.read(data)
+          @local_secrets[key] = File.read(Secrets.validate_file_path(data))
         else
           raise "Unknown secret type: #{type}"
         end

data/lib/openc3/utilities/store_autoload.rb

@@ -116,8 +116,8 @@ module OpenC3
     end
 
     def initialize(pool_size = 10, db_shard: 0)
-      @redis_username = ENV['OPENC3_REDIS_USERNAME']
-      @redis_key = ENV['OPENC3_REDIS_PASSWORD']
+      @redis_username = ENV.fetch('OPENC3_REDIS_USERNAME', nil)
+      @redis_key = ENV.fetch('OPENC3_REDIS_PASSWORD', nil)
       hostname = ENV['OPENC3_REDIS_HOSTNAME'].to_s.gsub("SHARDNUM", db_shard.to_s)
       @redis_url = "redis://#{hostname}:#{ENV.fetch('OPENC3_REDIS_PORT', 6379)}"
       @redis_pool = StoreConnectionPool.new(size: pool_size) { build_redis() }

data/lib/openc3/utilities/target_file.rb

@@ -21,6 +21,16 @@ module OpenC3
     # Matches ScriptRunner.vue const TEMP_FOLDER
     TEMP_FOLDER = '__TEMP__'
 
+    # self.all appends '*' to a name to mark it as modified on the server. The
+    # marker is display-only, so every path in and out of the bucket strips it.
+    #
+    # Strip only '*' at the end of a file name. '*' is a legal S3 object key character
+    # and is allowed by FileOpenSaveDialog's filename charset, so files named that
+    # way exist in the field and have to stay addressable.
+    def self.strip_modified(name)
+      name.sub(/\*$/, '')
+    end
+
     def self.all(scope, path_matchers, target: nil)
       target = target.upcase if target
 
@@ -89,7 +99,7 @@ module OpenC3
     end
 
     def self.body(scope, name)
-      name = name.split('*')[0] # Split '*' that indicates modified
+      name = strip_modified(name) # Remove '*' that indicates modified
       # First try opening a potentially modified version by looking for the modified target
       if ENV['OPENC3_LOCAL_MODE']
         local_file = OpenC3::LocalMode.open_local_file(name, scope: scope)
@@ -122,6 +132,10 @@ module OpenC3
 
     def self.create(scope, name, text, content_type: 'text/plain')
       return false unless text
+      # A trailing '*' here is the display-only modified marker leaking in from a
+      # file listing, not a name any caller means to write. Remove it to avoid 
+      # creating a file with a '*' in the name.
+      name = strip_modified(name)
       if ENV['OPENC3_LOCAL_MODE']
         OpenC3::LocalMode.put_target_file("#{scope}/targets_modified/#{name}", text, scope: scope)
       end
@@ -146,6 +160,9 @@ module OpenC3
     end
 
     def self.destroy(scope, name)
+      # Match body/create so deleting a name taken straight from a listing
+      # removes the file the user actually picked
+      name = strip_modified(name)
       if ENV['OPENC3_LOCAL_MODE']
         OpenC3::LocalMode.delete_local("#{scope}/targets_modified/#{name}")
       end

data/lib/openc3/version.rb

@@ -1,14 +1,14 @@
 # encoding: ascii-8bit
 
-OPENC3_VERSION = '7.2.1'
+OPENC3_VERSION = '7.4.0'
 module OpenC3
   module Version
     MAJOR = '7'
-    MINOR = '2'
-    PATCH = '1'
+    MINOR = '4'
+    PATCH = '0'
     OTHER = ''
-    BUILD = 'c0b096796e3070340b34bc4368c21f3972ede7a4'
+    BUILD = 'ed0cb44ca3c661eaf2babb77664d0063c955c68c'
   end
-  VERSION = '7.2.1'
-  GEM_VERSION = '7.2.1'
+  VERSION = '7.4.0'
+  GEM_VERSION = '7.4.0'
 end

data/lib/openc3.rb

@@ -30,9 +30,9 @@ $VERBOSE = saved_verbose
 # Add OpenC3 bin folder to PATH
 require 'openc3/core_ext/kernel'
 if Kernel.is_windows?
-  ENV['PATH'] = File.join(File.dirname(__FILE__), '../bin') + ';' + ENV['PATH']
+  ENV['PATH'] = File.join(File.dirname(__FILE__), '../bin') + ';' + ENV.fetch('PATH')
 else
-  ENV['PATH'] = File.join(File.dirname(__FILE__), '../bin') + ':' + ENV['PATH']
+  ENV['PATH'] = File.join(File.dirname(__FILE__), '../bin') + ':' + ENV.fetch('PATH')
 end
 require 'openc3/ext/platform' if RUBY_ENGINE == 'ruby' and !ENV['OPENC3_NO_EXT']
 require 'openc3/version'