openc3 7.2.1 → 7.3.0

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/web_socket_api.rb

@@ -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/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

@@ -100,7 +100,7 @@ module OpenC3
 
       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" }

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/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/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
 

data/lib/openc3/utilities/ruby_lex_utils.rb

@@ -94,7 +94,11 @@ And so is this
       # of the file and process the last line
       if next_token.type == :EOF
         if !line.empty?
-          yield line, instrumentable, inside_begin, orig_line_no
+          # orig_line_no is normally set below (after this EOF check) but a final
+          # line that never reaches that assignment (e.g. a trailing bareword call
+          # with no parentheses and no newline at end of file) would yield nil.
+          # Fall back to the current token's start line so the line number is valid.
+          yield line, instrumentable, inside_begin, orig_line_no || token.location.start_line
         end
         break
       end

data/lib/openc3/utilities/running_script.rb

@@ -432,7 +432,7 @@ 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'
@@ -468,103 +468,158 @@ 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['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
+        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['OPENC3_API_USER']
+        if ENV['OPENC3_SERVICE_PASSWORD']
+          process.environment['OPENC3_API_PASSWORD'] = ENV['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']
+      process.environment['GEM_HOME'] = ENV['GEM_HOME']
+
+      # Resolve the per-plugin Python venv for this script. For saved scripts
+      # we look up which plugin owns the target and check whether that plugin
+      # has an isolated UV venv. For temp scripts the frontend can pass a
+      # python_venv name directly, skipping the target lookup entirely.
+      python_venv_dir = nil
+      begin
+        target_name = name.split('/')[0].to_s.upcase
+        if target_name == '__TEMP__' && python_venv
+          # File.basename prevents path traversal (strips directory components)
+          safe_name = File.basename(python_venv.to_s)
+          candidate = "/gems/plugin_venvs/#{safe_name}/.venv"
+          python_venv_dir = candidate if File.directory?(candidate)
+        else
+          target_info = OpenC3::TargetModel.get(name: target_name, scope: scope)
+          if target_info && target_info['plugin']
+            sanitized_name = "#{scope}__#{target_info['plugin']}".tr('^a-zA-Z0-9_-', '_')
+            candidate = "/gems/plugin_venvs/#{sanitized_name}/.venv"
+            python_venv_dir = candidate if File.directory?(candidate)
+          end
+        end
+      rescue => e
+        OpenC3::Logger.debug("Could not resolve plugin venv for script '#{name}': #{e.message}")
+      end
+
+      if python_venv_dir
+        process.environment['VIRTUAL_ENV'] = python_venv_dir
+        process.environment['PATH'] = "#{python_venv_dir}/bin:#{ENV.fetch('PATH', '')}"
+        process.environment['PYTHONUSERBASE'] = python_venv_dir
+        # Add plugin venv site-packages to PYTHONPATH so the base venv's Python
+        # binary can find plugin-specific packages. PYTHONPATH is always respected
+        # by CPython regardless of venv activation state.
+        site_packages = Dir.glob("#{python_venv_dir}/lib/python*/site-packages").first
+        existing_pythonpath = ENV.fetch('PYTHONPATH', '')
+        if site_packages
+          process.environment['PYTHONPATH'] = existing_pythonpath.empty? ? site_packages : "#{site_packages}:#{existing_pythonpath}"
+        else
+          process.environment['PYTHONPATH'] = existing_pythonpath.empty? ? nil : existing_pythonpath
+        end
       else
-        raise "No authentication available for script"
+        system_venv = File.dirname(ENV['OPENC3_PYTHON_BIN'] || '/openc3/python/.venv/bin/python').chomp('/bin')
+        process.environment['VIRTUAL_ENV'] = system_venv
+        process.environment['PYTHONUSERBASE'] = ENV['PYTHONUSERBASE']
+        process.environment['PYTHONPATH'] = ENV['PYTHONPATH']
       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 +656,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 +1531,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 })