openc3 7.4.1 → 7.5.0

data/lib/openc3/script/api_shared.rb

@@ -530,7 +530,7 @@ module OpenC3
 
       value = yield(target_name, packet_name, item_name)
       if comparison_to_eval
-        _check_eval(target_name, packet_name, item_name, comparison_to_eval, value)
+        _check_comparison(target_name, packet_name, item_name, comparison_to_eval, value)
       else
         puts "CHECK: #{_upcase(target_name, packet_name, item_name)} == #{value.nil? ? 'nil' : value.inspect}"
       end
@@ -733,28 +733,16 @@ module OpenC3
       return [target_name, packet_name, item_name, comparison_to_eval, timeout, polling_rate]
     end
 
-    def _openc3_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, exp_to_eval, scope: $openc3_scope, token: $openc3_token, &block)
+    # Waits for the comparison to be true or the timeout to expire.
+    # The comparison is a callable which takes the telemetry value and returns true or false.
+    # A block passed by the user takes precedence over the comparison.
+    def _openc3_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, comparison, scope: $openc3_scope, token: $openc3_token, &block)
+      condition = block || comparison
       end_time = Time.now.sys + timeout
-      if exp_to_eval and !exp_to_eval.is_printable?
-        raise "ERROR: Invalid comparison to non-ascii value"
-      end
       while true
         work_start = Time.now.sys
         value = tlm(target_name, packet_name, item_name, type: value_type, scope: scope, token: token)
-        if not block.nil?
-          if block.call(value)
-            return true, value
-          end
-        else
-          begin
-            if eval(exp_to_eval)
-              return true, value
-            end
-          # NoMethodError is raised when the tlm() returns nil and we try to eval the expression
-          # In this case we just continue and see if eventually we get a good value from tlm()
-          rescue NoMethodError
-          end
-        end
+        return true, value if condition and condition.call(value)
         break if Time.now.sys >= end_time
 
         delta = Time.now.sys - work_start
@@ -766,58 +754,62 @@ module OpenC3
 
         if canceled
           value = tlm(target_name, packet_name, item_name, type: value_type, scope: scope, token: token)
-          if not block.nil?
-            if block.call(value)
-              return true, value
-            else
-              return false, value
-            end
+          if condition and condition.call(value)
+            return true, value
           else
-            begin
-              if eval(exp_to_eval)
-                return true, value
-              else
-                return false, value
-              end
-            # NoMethodError is raised when the tlm() returns nil and we try to eval the expression
-            rescue NoMethodError
-              return false, value
-            end
+            return false, value
           end
         end
       end
 
       return false, value
-    rescue NameError => e
-      if e.message =~ /uninitialized constant OpenC3::ApiShared::(\w+)/
-        new_error = NameError.new("Uninitialized constant #{$1}. Did you mean '#{$1}' as a string?")
-        new_error.set_backtrace(e.backtrace)
-        raise new_error
-      else
-        raise e
-      end
+    end
+
+    # Builds a callable which compares a telemetry value against the given comparison string,
+    # e.g. "> 1". Returns nil if there is no comparison, e.g. a block based wait_check().
+    # Raises if the comparison is invalid, e.g. an unsupported operator or unparsable operand.
+    def _comparison_implementation(comparison_to_eval)
+      return nil unless comparison_to_eval
+
+      operator, operand = extract_operator_and_operand_from_comparison(comparison_to_eval)
+      return nil unless operator
+      lambda { |value| compare_values(value, operator, operand) }
     end
 
     # Wait for a converted telemetry item to pass a comparison
     def _openc3_script_wait_implementation_comparison(target_name, packet_name, item_name, value_type, comparison_to_eval, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, scope: $openc3_scope, token: $openc3_token, &block)
-      if comparison_to_eval
-        exp_to_eval = "value " + comparison_to_eval
-      else
-        exp_to_eval = nil
+      # The comparison text is logged whether or not it is parsed so it is always validated
+      if comparison_to_eval and !comparison_to_eval.is_printable?
+        raise "ERROR: Invalid comparison to non-ascii value"
       end
-      _openc3_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, exp_to_eval, scope: scope, token: token, &block)
+      # A user supplied block is the condition so the comparison text is never parsed
+      comparison = block ? nil : _comparison_implementation(comparison_to_eval)
+      _openc3_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, comparison, scope: scope, token: token, &block)
     end
 
     def _openc3_script_wait_implementation_tolerance(target_name, packet_name, item_name, value_type, expected_value, tolerance, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, scope: $openc3_scope, token: $openc3_token, &block)
-      exp_to_eval = "((#{expected_value} - #{tolerance})..(#{expected_value} + #{tolerance})).include? value"
-      _openc3_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, exp_to_eval, scope: scope, token: token, &block)
+      comparison = lambda do |value|
+        begin
+          value >= (expected_value - tolerance) and value <= (expected_value + tolerance)
+        rescue ArgumentError, NoMethodError, TypeError
+          false
+        end
+      end
+      _openc3_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, comparison, scope: scope, token: token, &block)
     end
 
     def _openc3_script_wait_implementation_array_tolerance(array_size, target_name, packet_name, item_name, value_type, expected_value, tolerance, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, scope: $openc3_scope, token: $openc3_token, &block)
-      statements = []
-      array_size.times { |i| statements << "(((#{expected_value[i]} - #{tolerance[i]})..(#{expected_value[i]} + #{tolerance[i]})).include? value[#{i}])" }
-      exp_to_eval = statements.join(" && ")
-      _openc3_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, exp_to_eval, scope: scope, token: token, &block)
+      comparison = lambda do |values|
+        begin
+          next false unless values.is_a?(Array) and values.length == array_size
+          array_size.times.all? do |i|
+            values[i] >= (expected_value[i] - tolerance[i]) and values[i] <= (expected_value[i] + tolerance[i])
+          end
+        rescue ArgumentError, NoMethodError, TypeError
+          false
+        end
+      end
+      _openc3_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, comparison, scope: scope, token: token, &block)
     end
 
     # Wait on an expression to be true.
@@ -859,17 +851,15 @@ module OpenC3
       end
     end
 
-    def _check_eval(target_name, packet_name, item_name, comparison_to_eval, value)
-      string = "value " + comparison_to_eval
+    def _check_comparison(target_name, packet_name, item_name, comparison_to_eval, value)
       check_str = "CHECK: #{_upcase(target_name, packet_name, item_name)} #{comparison_to_eval}"
       # Show user the check against a quoted string
-      # Note: We have to preserve the original 'value' variable because we're going to eval against it
       value_str = value.is_a?(String) ? "'#{value}'" : value
       value_str = 'nil' if value.nil? # Show user nil value as 'nil'
       with_value = "with value == #{value_str}"
 
-      eval_is_valid = _check_eval_validity(value, comparison_to_eval)
-      unless eval_is_valid
+      operator, operand = extract_operator_and_operand_from_comparison(comparison_to_eval)
+      unless _valid_comparison?(value, operator, operand)
         message = "Invalid comparison for types"
         if $disconnect
           puts "ERROR: #{message}"
@@ -878,7 +868,7 @@ module OpenC3
         end
       end
 
-      if eval_is_valid && eval(string)
+      if compare_values(value, operator, operand)
         puts "#{check_str} success #{with_value}"
       else
         message = "#{check_str} failed #{with_value}"
@@ -888,35 +878,19 @@ module OpenC3
           raise CheckError, message
         end
       end
-    rescue NameError => e
-      if e.message =~ /uninitialized constant OpenC3::ApiShared::(\w+)/
-        new_error = NameError.new("Uninitialized constant #{$1}. Did you mean '#{$1}' as a string?")
-        new_error.set_backtrace(e.backtrace)
-        raise new_error
-      else
-        raise e
-      end
     end
 
-    def _check_eval_validity(value, comparison)
-      return true if comparison.nil? || comparison.empty?
-
-      begin
-        operator, operand = extract_operator_and_operand_from_comparison(comparison)
-      rescue RuntimeError => e
-        if e.message.include?("Unable to parse operand")
-          # If we can't parse the operand, let the eval happen anyway
-          # It will raise an appropriate error (like NameError for undefined constants)
-          return true
-        end
-        raise # Re-raise invalid operator errors
-      rescue JSON::ParserError
-        return true
-      end
+    # Returns whether the value and operand can be meaningfully compared with the operator.
+    # Note this is only used by check() because wait() polls until the value changes.
+    def _valid_comparison?(value, operator, operand)
+      return true if operator.nil?
 
       if [">=", "<=", ">", "<"].include?(operator)
-        return false if value.nil? || operand.nil? || value.is_a?(Array) || operand.is_a?(Array)
+        return false if value.nil? or operand.nil?
+        return false if value.is_a?(Array) or operand.is_a?(Array)
+        return false if value.is_a?(String) != operand.is_a?(String)
       end
+      # Note 'in' does not need a check here because the parser already requires a list operand
 
       return true
     end

data/lib/openc3/script/extract.rb

@@ -26,6 +26,37 @@ module OpenC3
     # whitespace around them is optional.
     SCANNING_REGULAR_EXPRESSION = %r{ (?:"(?:[^\\"]|\\.)*") | (?:'(?:[^\\']|\\.)*') | (?:\[(?:[^\\\[\]]|\\.|\[(?:[^\\\[\]]|\\.)*\])*\]) | , | [^\s,]+ }x # "
 
+    # Operators supported by check(), wait() and wait_check() comparisons
+    COMPARISON_OPERATORS = ["==", "!=", ">=", "<=", ">", "<", "in"]
+
+    # Single character escape sequences processed inside a double quoted comparison operand.
+    # The numeric (\nnn, \xHH, \uHHHH, \u{...}) forms are handled by unescape_double_quoted().
+    DOUBLE_QUOTE_ESCAPES = {
+      '\\' => "\\", '"' => '"', "'" => "'", '#' => '#', 'n' => "\n", 't' => "\t",
+      'r' => "\r", 'a' => "\a", 'b' => "\b", 'e' => "\e", 'f' => "\f", 'v' => "\v", 's' => ' '
+    }
+
+    # Tokenizes a double quoted operand into escape sequences, interpolation markers and runs
+    # of plain characters. The alternatives are ordered longest first so \u{1F600} is not read
+    # as \u, and the escape alternatives precede the markers so \#{ is a literal '#{'.
+    DOUBLE_QUOTE_TOKEN_REGEX =
+      /\\u\{[\h\s]*\}|\\u\h{4}|\\x\h{1,2}|\\[0-7]{1,3}|\\M-\\C-.|\\M-.|\\C-.|\\c.|\\.|\#[{@$]|[^\\\#]+|\#/m
+
+    # Escape sequences which have a meaning we deliberately do not implement. Dropping the
+    # backslash would silently change the value so they are rejected instead.
+    UNSUPPORTED_ESCAPE_REGEX = /\A\\(?:c|C-|M-)/
+
+    # The Ruby string interpolation markers. Interpolation would be code execution so it is
+    # rejected rather than silently compared against the uninterpolated text.
+    INTERPOLATION_REGEX = /\A\#[{@$]/
+
+    # Limits Ruby enforces on a \u escape. A codepoint is written with at most six hex digits,
+    # the largest character Unicode defines is 0x10FFFF, and the surrogate range is reserved
+    # for UTF-16 pairs so it is not a character on its own.
+    MAX_UNICODE_DIGITS = 6
+    MAX_UNICODE_CODEPOINT = 0x10FFFF
+    UNICODE_SURROGATE_RANGE = (0xD800..0xDFFF)
+
     private
 
     # Pulls all string keyword arguments into the args array. Raises on any symbol keyword arguments.
@@ -165,8 +196,6 @@ module OpenC3
 
     # Splits `check()` comparison expressions, e.g. "== 'foo bar'" becomes ["==", "foo bar"]
     def extract_operator_and_operand_from_comparison(comparison)
-      valid_operators = ["==", "!=", ">=", "<=", ">", "<", "in"]
-
       operator, operand = comparison.split(nil, 2) # Ruby: second split arg is max number of resultant elements
 
       if operand.nil?
@@ -175,29 +204,196 @@ module OpenC3
         return [nil, nil]
       end
 
-      raise "ERROR: Invalid operator: '#{operator}'" unless valid_operators.include?(operator)
+      raise "ERROR: Invalid operator: '#{operator}'" unless COMPARISON_OPERATORS.include?(operator)
+
+      # split leaves any trailing whitespace on the operand which the anchored matches reject
+      operand = extract_operand(operand.strip)
+      # 'in' is containment against a list of values in both Ruby and Python.
+      # Enforced here so check(), wait() and wait_check() all reject the same thing.
+      if operator == "in" and !operand.is_a?(Array)
+        raise "ERROR: The 'in' operator requires a list operand: #{operand.inspect}"
+      end
+
+      return [operator, operand]
+    end
 
-      # Handle string operand: remove surrounding double/single quotes
-      if operand.match?(/^(['"])(.*)\1$/m) # Starts with single or double quote, and ends with matching quote
-        operand = operand[1..-2]
-        return [operator, operand]
+    # Converts the operand of a `check()` comparison expression into a Ruby value.
+    # Note this deliberately does not eval the operand so only literal values are supported.
+    def extract_operand(operand)
+      # A quoted operand must be a single complete string literal. Anything trailing the
+      # closing quote, e.g. "== 'a' garbage 'b'", is a syntax error rather than a string.
+      if (match = operand.match(/\A'((?:[^'\\]|\\.)*)'\z/m))
+        # Ruby single quoted strings only escape the backslash and the single quote
+        return match[1].gsub(/\\([\\'])/) { $1 }
+      end
+      if (match = operand.match(/\A"((?:[^"\\]|\\.)*)"\z/m))
+        return unescape_double_quoted(match[1])
       end
+      return nil if operand == "nil"
+      return false if operand == "false"
+      return true if operand == "true"
 
-      # Handle other operand types
-      if operand == "nil"
-        operand = nil
-      elsif operand == "false"
-        operand = false
-      elsif operand == "true"
-        operand = true
+      # Ruby's Float() rejects these but Python's float() accepts them
+      case operand.upcase
+      when 'INFINITY', '+INFINITY', 'INF', '+INF'
+        return Float::INFINITY
+      when '-INFINITY', '-INF'
+        return -Float::INFINITY
+      when 'NAN', '+NAN', '-NAN'
+        return Float::NAN
       else
-        begin
-          operand = JSON.parse(operand)
-        rescue JSON::ParserError
-          raise "ERROR: Unable to parse operand: #{operand}"
+        # Not an infinity or NaN keyword so fall through to the formats below
+      end
+
+      # Arrays are parsed recursively so their elements follow exactly the same rules as a
+      # bare operand. JSON alone would reject ['ON', 'OFF'], [0xA, 0xB] and [true, nil].
+      if operand.start_with?('[') and operand.end_with?(']')
+        return split_operand_list(operand[1..-2]).map { |element| extract_operand(element) }
+      end
+      # JSON handles decimal numbers and hashes
+      begin
+        return JSON.parse(operand)
+      rescue JSON::ParserError
+        # Fall through to the number formats JSON does not accept
+      end
+      # Number formats JSON does not accept
+      begin
+        # Explicit base prefix: hex (0x), octal (0o) or binary (0b)
+        return Integer(operand) if operand.match?(/\A[+-]?0[xXoObB][0-9a-fA-F_]+\z/)
+        # Integers with underscore separators, e.g. 1_000. A leading zero is deliberately
+        # rejected because it is ambiguous: Ruby reads 010 as octal 8 while Python rejects it.
+        # Write 0o10 for octal 8 or 10 for decimal 10.
+        return Integer(operand, 10) if operand.match?(/\A[+-]?[1-9][0-9_]*\z/)
+        # Floats with underscore separators, e.g. 1_000.5. A leading zero is unambiguous here.
+        return Float(operand) if operand.match?(/\A[+-]?[0-9][0-9_]*(?:\.[0-9_]+(?:[eE][+-]?[0-9_]+)?|[eE][+-]?[0-9_]+)\z/)
+      rescue ArgumentError
+        # Fall through to the error cases
+      end
+
+      # A bare word is almost always a string the user forgot to quote
+      if operand.match?(/\A[A-Za-z_][A-Za-z0-9_]*\z/)
+        raise NameError, "Uninitialized constant #{operand}. Did you mean '#{operand}' as a string?"
+      end
+      raise "ERROR: Unable to parse operand: #{operand}"
+    end
+
+    # Processes the escape sequences in the contents of a double quoted operand
+    def unescape_double_quoted(string)
+      # A \xHH or octal escape can produce a byte which is not valid UTF-8 so build the result
+      # in binary. Otherwise preserve the encoding of the comparison the user passed in.
+      # The escape must not itself be escaped, e.g. "C:\\0" is a backslash followed by a zero.
+      binary = string.match?(/(?<!\\)(?:\\\\)*\\(?:x\h|[0-7])/)
+      result = binary ? ''.b : String.new(encoding: string.encoding)
+      string.scan(DOUBLE_QUOTE_TOKEN_REGEX).each do |token|
+        replacement =
+          if token.match?(INTERPOLATION_REGEX)
+            raise "ERROR: String interpolation is not supported in an operand: #{token}. " +
+                  'Interpolate in the script itself or escape it as \#' + token[1] +
+                  ' to compare against the literal text'
+          elsif !token.start_with?('\\')
+            token
+          elsif token.start_with?('\u{')
+            # \u{1F600} or \u{48 49} which is one or more whitespace separated codepoints
+            token[3..-2].split.map { |codepoint| pack_unicode_codepoint(codepoint, token) }.join
+          elsif token.length == 6 and token.start_with?('\u')
+            pack_unicode_codepoint(token[2..-1], token)
+          elsif token.length > 2 and token.start_with?('\x')
+            [token[2..-1].hex].pack('C')
+          elsif token.match?(/\A\\[0-7]/)
+            [token[1..-1].to_i(8) & 0xFF].pack('C')
+          elsif token.match?(UNSUPPORTED_ESCAPE_REGEX)
+            raise "ERROR: Unsupported escape sequence in operand: #{token}"
+          elsif token == '\u' or token == '\x'
+            raise "ERROR: Invalid escape sequence in operand: #{token}"
+          else
+            # Ruby drops the backslash of an escape which has no special meaning, e.g. "\q"
+            DOUBLE_QUOTE_ESCAPES.fetch(token[1], token[1])
+          end
+        result << (binary ? replacement.b : replacement)
+      end
+      return result
+    end
+
+    # Packs a single codepoint of a \u escape into a UTF-8 character. Ruby rejects a codepoint
+    # which is too long, above the largest Unicode character or in the UTF-16 surrogate range,
+    # so those raise here rather than silently packing into an invalid UTF-8 string.
+    def pack_unicode_codepoint(codepoint, token)
+      value = codepoint.hex
+      if codepoint.length > MAX_UNICODE_DIGITS or value > MAX_UNICODE_CODEPOINT or
+         UNICODE_SURROGATE_RANGE.include?(value)
+        raise "ERROR: Invalid Unicode codepoint in operand: #{token}"
+      end
+      return [value].pack('U')
+    end
+
+    # Splits the contents of a bracketed operand list on the top level commas.
+    # Quotes and nesting are tracked so "['a,b', [1, 2]]" is two elements, not four.
+    def split_operand_list(text)
+      elements = []
+      current = String.new(encoding: text.encoding)
+      depth = 0
+      quote = nil
+      escaped = false
+      text.each_char do |char|
+        if escaped
+          escaped = false
+        elsif quote
+          if char == '\\'
+            escaped = true
+          elsif char == quote
+            quote = nil
+          end
+        elsif char == "'" or char == '"'
+          quote = char
+        elsif char == '[' or char == '{'
+          depth += 1
+        elsif char == ']' or char == '}'
+          depth -= 1
+          raise "ERROR: Unable to parse operand: [#{text}]" if depth < 0
+        elsif char == ',' and depth == 0
+          elements << current.strip
+          current = String.new(encoding: text.encoding)
+          next
         end
+        current << char
       end
-      return [operator, operand]
+      raise "ERROR: Unable to parse operand: [#{text}]" if depth != 0 or quote
+
+      elements << current.strip
+      # A single empty element is an empty list, e.g. []
+      return [] if elements.length == 1 and elements[0].empty?
+      # A trailing comma is allowed, e.g. [1,], matching both Ruby and Python list literals
+      elements.pop if elements[-1].empty?
+      raise "ERROR: Unable to parse operand: [#{text}]" if elements.empty? or elements.any?(&:empty?)
+
+      return elements
+    end
+
+    # Compares a telemetry value against an operand using the given operator.
+    # Returns false rather than raising if the two values can not be compared.
+    def compare_values(value, operator, operand)
+      case operator
+      when "=="
+        value == operand
+      when "!="
+        value != operand
+      when ">"
+        value > operand
+      when ">="
+        value >= operand
+      when "<"
+        value < operand
+      when "<="
+        value <= operand
+      when "in"
+        # 'in' is containment against a list of values, matching Python
+        operand.is_a?(Array) && operand.include?(value)
+      else
+        raise "ERROR: Invalid operator: '#{operator}'"
+      end
+    rescue ArgumentError, NoMethodError, TypeError
+      # Comparing incompatible types, e.g. nil > 1, is simply not a match
+      false
     end
   end
 end

data/lib/openc3/script/plugins.rb

@@ -19,6 +19,7 @@ module OpenC3
       response_body = nil
       begin
         endpoint = "/openc3-api/plugins?scope=#{scope}"
+        endpoint += "&exclude_default=true" unless default
         uri = URI.parse($api_server.generate_url + endpoint)
         auth = $api_server.generate_auth
 
@@ -30,19 +31,11 @@ module OpenC3
           http.request(request) do |response|
             response_body = response.body
             response.value() # Raises an HTTP error if the response is not 2xx (success)
-            plugins = JSON.parse(response.body, allow_nan: true, create_additions: true)
-            if default
-              return plugins
-            else
-              return plugins.select do |plugin|
-                !plugin.include?('openc3-cosmos-tool-') and !plugin.include?('openc3-tool-base') and
-                !plugin.include?('openc3-cosmos-enterprise-tool-') and !plugin.include?('openc3-enterprise-tool-base')
-              end
-            end
+            return JSON.parse(response.body, allow_nan: true, create_additions: true)
           end
         end
       rescue => e
-        raise "get_plugin_list failed due to #{e.formatted}\nURI:#{uri}\nResponse:\n#{response_body}"
+        raise "plugin_list failed due to #{e.formatted}\nURI:#{uri}\nResponse:\n#{response_body}"
       end
     end
 
@@ -65,7 +58,7 @@ module OpenC3
           end
         end
       rescue => e
-        raise "get_plugin failed due to #{e.formatted}\nURI:#{uri}\nResponse:\n#{response_body}"
+        raise "plugin_get failed due to #{e.formatted}\nURI:#{uri}\nResponse:\n#{response_body}"
       end
     end
 

data/lib/openc3/script/storage.rb

@@ -17,6 +17,8 @@
 
 require 'tempfile'
 require 'net/http'
+require 'base64'
+require 'openc3/utilities/local_mode'
 
 ENV['OPENC3_CLOUD'] ||= 'local'
 
@@ -53,6 +55,15 @@ module OpenC3
 
       upload_path = "#{scope}/targets_modified/#{path}"
 
+      if OpenC3::LocalMode.local_only_name?(path)
+        # The local mode volume is only mounted in the cluster so from outside
+        # write it through the API which never sends it to the bucket
+        return _upload_api_file(upload_path, io_or_string, scope: scope) unless $openc3_in_cluster
+        puts "Writing local #{upload_path}"
+        OpenC3::LocalMode.put_target_file(upload_path, io_or_string, scope: scope)
+        return nil
+      end
+
       if ENV['OPENC3_LOCAL_MODE'] and $openc3_in_cluster
         OpenC3::LocalMode.put_target_file(upload_path, io_or_string, scope: scope)
         io_or_string.rewind if io_or_string.respond_to?(:rewind)
@@ -91,22 +102,22 @@ module OpenC3
     # @param original [Boolean] Whether to get the original or modified file
     # @return [File|nil]
     def get_target_file(path, original: false, scope: $openc3_scope)
+      # Local only targets only exist in the local mode volume so original doesn't apply
+      if OpenC3::LocalMode.local_only_name?(path)
+        # The local mode volume is only mounted in the cluster so from outside
+        # read it through the API which serves it from the volume
+        return _get_api_file("targets_modified/#{path}", scope: scope) unless $openc3_in_cluster
+        return _get_local_file(path, scope: scope)
+      end
+
       part = "targets"
       part += "_modified" unless original
       # Loop to allow redo when switching from modified to original
       loop do
         begin
           if part == "targets_modified" and ENV['OPENC3_LOCAL_MODE']
-            local_file = OpenC3::LocalMode.open_local_file(path, scope: scope)
-            if local_file
-              puts "Reading local #{scope}/#{part}/#{path}"
-              file = Tempfile.new('target', binmode: true)
-              file.filename = path
-              file.write(local_file.read)
-              local_file.close
-              file.rewind
-              return file
-            end
+            file = _get_local_file(path, scope: scope)
+            return file if file
           end
 
           return _get_storage_file("#{part}/#{path}", scope: scope)
@@ -125,7 +136,53 @@ module OpenC3
 
     # These are helper methods ... should not be used directly
 
+    # Write a file through the API instead of a presigned URL
+    def _upload_api_file(path, io_or_string, bucket: 'OPENC3_CONFIG_BUCKET', scope: $openc3_scope)
+      data = String === io_or_string ? io_or_string : io_or_string.read
+      endpoint = "/openc3-api/storage/upload_file/#{path}"
+      puts "Writing #{path}"
+      response = $api_server.request('put', endpoint, query: { bucket: bucket },
+        data: { contents: Base64.strict_encode64(data) }, json: true, scope: scope)
+      if response.nil? || response.status != 200
+        raise "Failed to write #{path}"
+      end
+      nil
+    end
+
+    # Read a file through the API instead of a presigned URL
+    # Returns nil if the file doesn't exist
+    def _get_api_file(path, bucket: 'OPENC3_CONFIG_BUCKET', scope: $openc3_scope)
+      endpoint = "/openc3-api/storage/download_file/#{scope}/#{path}"
+      response = $api_server.request('get', endpoint, query: { bucket: bucket }, scope: scope)
+      return nil if response && response.status == 404
+      if response.nil? || response.status != 200
+        raise "Failed to read #{scope}/#{path}"
+      end
+      puts "Reading #{scope}/#{path}"
+      json = JSON.parse(response.body, allow_nan: true, create_additions: true)
+      file = Tempfile.new('target', binmode: true)
+      file.filename = path
+      file.write(Base64.decode64(json['contents']))
+      file.rewind
+      return file
+    end
+
+    def _get_local_file(path, scope: $openc3_scope)
+      local_file = OpenC3::LocalMode.open_local_file(path, scope: scope)
+      return nil unless local_file
+      puts "Reading local #{scope}/targets_modified/#{path}"
+      file = Tempfile.new('target', binmode: true)
+      file.filename = path
+      file.write(local_file.read)
+      local_file.close
+      file.rewind
+      return file
+    end
+
     def _get_download_url(path, scope: $openc3_scope)
+      if OpenC3::LocalMode.local_only_name?(path)
+        raise "#{path} belongs to a local only target (OPENC3_LOCAL_ONLY_TARGETS) and has no bucket download URL"
+      end
       targets = "targets_modified" # First try targets_modified
       response = $api_server.request('get', "/openc3-api/storage/exists/#{scope}/#{targets}/#{path}", query: { bucket: 'OPENC3_CONFIG_BUCKET' }, scope: scope)
       if response.status != 200
@@ -167,6 +224,20 @@ module OpenC3
       return file
     end
 
+    # Retrieve the file selected in open_bucket_dialog
+    # input is the hash returned by the frontend: { 'bucket', 'path', 'filename' }
+    def _get_bucket_dialog_file(input, scope: $openc3_scope)
+      bucket = input['bucket']
+      # Path from bucket dialog already includes scope prefix (e.g. DEFAULT/targets/...)
+      # _get_storage_file prepends scope, so strip it from the path to avoid doubling
+      path = input['path'].sub(/\A#{Regexp.escape(scope)}\//, '')
+      file = _get_storage_file(path, bucket: bucket, scope: scope)
+      file.filename = input['filename']
+      file.bucket = bucket
+      file.bucket_path = input['path']
+      file
+    end
+
     def _get_uri(url)
       if $openc3_in_cluster
         case ENV.fetch('OPENC3_CLOUD', nil)