openc3 5.17.1 → 5.19.0

data/lib/openc3/api/cmd_api.rb

@@ -20,6 +20,7 @@
 # This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
+require 'openc3/api/interface_api'
 require 'openc3/models/target_model'
 require 'openc3/topics/command_topic'
 require 'openc3/topics/command_decom_topic'
@@ -107,7 +108,7 @@ module OpenC3
     # Build a command binary
     #
     # @since 5.8.0
-    def build_cmd(*args, range_check: true, raw: false, scope: $openc3_scope, token: $openc3_token, **kwargs)
+    def build_cmd(*args, range_check: true, raw: false, manual: false, scope: $openc3_scope, token: $openc3_token, **kwargs)
       extract_string_kwargs_to_args(args, kwargs)
       case args.length
       when 1
@@ -127,31 +128,31 @@ module OpenC3
       target_name = target_name.upcase
       cmd_name = cmd_name.upcase
       cmd_params = cmd_params.transform_keys(&:upcase)
-      authorize(permission: 'cmd_info', target_name: target_name, scope: scope, token: token)
+      authorize(permission: 'cmd_info', target_name: target_name, manual: manual, scope: scope, token: token)
       DecomInterfaceTopic.build_cmd(target_name, cmd_name, cmd_params, range_check, raw, scope: scope)
     end
     # build_command is DEPRECATED
     alias build_command build_cmd
 
     # Helper method for disable_cmd / enable_cmd
-    def _get_and_set_cmd(method, *args, scope: $openc3_scope, token: $openc3_token)
+    def _get_and_set_cmd(method, *args, manual:, scope:, token:)
       target_name, command_name = _extract_target_command_names(method, *args)
-      authorize(permission: 'admin', target_name: target_name, packet_name: command_name, scope: scope, token: token)
+      authorize(permission: 'admin', target_name: target_name, packet_name: command_name, manual: manual, scope: scope, token: token)
       command = yield TargetModel.packet(target_name, command_name, type: :CMD, scope: scope)
       TargetModel.set_packet(target_name, command_name, command, type: :CMD, scope: scope)
     end
 
     # @since 5.15.1
-    def enable_cmd(*args, scope: $openc3_scope, token: $openc3_token)
-      _get_and_set_cmd('enable_cmd', *args, scope: scope, token: token) do |command|
+    def enable_cmd(*args, manual: false, scope: $openc3_scope, token: $openc3_token)
+      _get_and_set_cmd('enable_cmd', *args, manual: manual, scope: scope, token: token) do |command|
         command['disabled'] = false
         command
       end
     end
 
     # @since 5.15.1
-    def disable_cmd(*args, scope: $openc3_scope, token: $openc3_token)
-      _get_and_set_cmd('disable_cmd', *args, scope: scope, token: token) do |command|
+    def disable_cmd(*args, manual: false, scope: $openc3_scope, token: $openc3_token)
+      _get_and_set_cmd('disable_cmd', *args, manual: manual, scope: scope, token: token) do |command|
         command['disabled'] = true
         command
       end
@@ -161,10 +162,13 @@ module OpenC3
     #
     # @param interface_name [String] The interface to send the raw binary
     # @param data [String] The raw binary data
-    def send_raw(interface_name, data, scope: $openc3_scope, token: $openc3_token)
+    def send_raw(interface_name, data, manual: false, scope: $openc3_scope, token: $openc3_token)
       interface_name = interface_name.upcase
-      authorize(permission: 'cmd_raw', interface_name: interface_name, scope: scope, token: token)
-      get_interface(interface_name, scope: scope, token: token) # Check to make sure the interface exists
+      interface = get_interface(interface_name, scope: scope, token: token)
+      # Verify we have command authority on all the targets mapped to this interface
+      interface['cmd_target_names'].each do |target_name|
+        authorize(permission: 'cmd_raw', interface_name: interface_name, target_name: target_name, manual: manual, scope: scope, token: token)
+      end
       InterfaceTopic.write_raw(interface_name, data, scope: scope)
     end
 
@@ -173,9 +177,9 @@ module OpenC3
     # @param target_name [String] Target name of the command
     # @param command_name [String] Packet name of the command
     # @return [Hash] command hash with last command buffer
-    def get_cmd_buffer(*args, scope: $openc3_scope, token: $openc3_token)
+    def get_cmd_buffer(*args, manual: false, scope: $openc3_scope, token: $openc3_token)
       target_name, command_name = _extract_target_command_names('get_cmd_buffer', *args)
-      authorize(permission: 'cmd_info', target_name: target_name, packet_name: command_name, scope: scope, token: token)
+      authorize(permission: 'cmd_info', target_name: target_name, packet_name: command_name, manual: manual, scope: scope, token: token)
       TargetModel.packet(target_name, command_name, type: :CMD, scope: scope)
       topic = "#{scope}__COMMAND__{#{target_name}}__#{command_name}"
       msg_id, msg_hash = Topic.get_newest_message(topic)
@@ -191,9 +195,9 @@ module OpenC3
     # @since 5.0.0
     # @param target_name [String] Name of the target
     # @return [Array<Hash>] Array of all commands as a hash
-    def get_all_cmds(target_name, scope: $openc3_scope, token: $openc3_token)
+    def get_all_cmds(target_name, manual: false, scope: $openc3_scope, token: $openc3_token)
       target_name = target_name.upcase
-      authorize(permission: 'cmd_info', target_name: target_name, scope: scope, token: token)
+      authorize(permission: 'cmd_info', target_name: target_name, manual: manual, scope: scope, token: token)
       TargetModel.packets(target_name, type: :CMD, scope: scope)
     end
     # get_all_commands is DEPRECATED
@@ -204,7 +208,7 @@ module OpenC3
     # @since 5.0.6
     # @param target_name [String] Name of the target
     # @return [Array<String>] Array of all command packet names
-    def get_all_cmd_names(target_name, hidden: false, scope: $openc3_scope, token: $openc3_token)
+    def get_all_cmd_names(target_name, hidden: false, manual: false, scope: $openc3_scope, token: $openc3_token)
       begin
         packets = get_all_cmds(target_name, scope: scope, token: token)
       rescue RuntimeError
@@ -227,9 +231,9 @@ module OpenC3
     #
     # @since 5.0.0
     # @return [Hash] Command as a hash
-    def get_cmd(*args, scope: $openc3_scope, token: $openc3_token)
+    def get_cmd(*args, manual: false, scope: $openc3_scope, token: $openc3_token)
       target_name, command_name = _extract_target_command_names('get_cmd', *args)
-      authorize(permission: 'cmd_info', target_name: target_name, scope: scope, token: token)
+      authorize(permission: 'cmd_info', target_name: target_name, manual: manual, scope: scope, token: token)
       TargetModel.packet(target_name, command_name, type: :CMD, scope: scope)
     end
     # get_command is DEPRECATED
@@ -242,9 +246,9 @@ module OpenC3
     # @param command_name [String] Name of the packet
     # @param parameter_name [String] Name of the parameter
     # @return [Hash] Command parameter as a hash
-    def get_param(*args, scope: $openc3_scope, token: $openc3_token)
+    def get_param(*args, manual: false, scope: $openc3_scope, token: $openc3_token)
       target_name, command_name, parameter_name = _extract_target_command_parameter_names('get_param', *args)
-      authorize(permission: 'cmd_info', target_name: target_name, packet_name: command_name, scope: scope, token: token)
+      authorize(permission: 'cmd_info', target_name: target_name, packet_name: command_name, manual: manual, scope: scope, token: token)
       TargetModel.packet_item(target_name, command_name, parameter_name, type: :CMD, scope: scope)
     end
     # get_parameter is DEPRECATED
@@ -258,7 +262,7 @@ module OpenC3
     #
     # @param args [String|Array<String>] See the description for calling style
     # @return [Boolean] Whether the command is hazardous
-    def get_cmd_hazardous(*args, scope: $openc3_scope, token: $openc3_token, **kwargs)
+    def get_cmd_hazardous(*args, manual: false, scope: $openc3_scope, token: $openc3_token, **kwargs)
       extract_string_kwargs_to_args(args, kwargs)
       case args.length
       when 1
@@ -279,7 +283,7 @@ module OpenC3
       command_name = command_name.upcase
       parameters = parameters.transform_keys(&:upcase)
 
-      authorize(permission: 'cmd_info', target_name: target_name, packet_name: command_name, scope: scope, token: token)
+      authorize(permission: 'cmd_info', target_name: target_name, packet_name: command_name, manual: manual, scope: scope, token: token)
       packet = TargetModel.packet(target_name, command_name, type: :CMD, scope: scope)
       return true if packet['hazardous']
 
@@ -307,7 +311,7 @@ module OpenC3
     #   get_cmd_value("TGT PKT ITEM", type: :RAW)
     #   get_cmd_value("TGT", "PKT", "ITEM", type: :RAW)
     #   get_cmd_value("TGT", "PKT", "ITEM", :RAW) # DEPRECATED
-    def get_cmd_value(*args, type: :CONVERTED, scope: $openc3_scope, token: $openc3_token)
+    def get_cmd_value(*args, type: :CONVERTED, manual: false, scope: $openc3_scope, token: $openc3_token)
       target_name = nil
       command_name = nil
       parameter_name = nil
@@ -330,7 +334,7 @@ module OpenC3
       if target_name.nil? or command_name.nil? or parameter_name.nil?
         raise "ERROR: Target name, command name and parameter name required. Usage: get_cmd_value(\"TGT CMD PARAM\") or #{method_name}(\"TGT\", \"CMD\", \"PARAM\")"
       end
-      authorize(permission: 'cmd_info', target_name: target_name, packet_name: command_name, scope: scope, token: token)
+      authorize(permission: 'cmd_info', target_name: target_name, packet_name: command_name, manual: manual, scope: scope, token: token)
       CommandDecomTopic.get_cmd_item(target_name, command_name, parameter_name, type: type, scope: scope)
     end
 
@@ -341,8 +345,8 @@ module OpenC3
     # @param command_name [String] Packet name of the command. If not given then
     #    then most recent time from the given target will be returned.
     # @return [Array<Target Name, Command Name, Time Seconds, Time Microseconds>]
-    def get_cmd_time(target_name = nil, command_name = nil, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'cmd_info', target_name: target_name, packet_name: command_name, scope: scope, token: token)
+    def get_cmd_time(target_name = nil, command_name = nil, manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'cmd_info', target_name: target_name, packet_name: command_name, manual: manual, scope: scope, token: token)
       if target_name and command_name
         target_name = target_name.upcase
         command_name = command_name.upcase
@@ -379,9 +383,9 @@ module OpenC3
     # @param target_name [String] Target name of the command
     # @param command_name [String] Packet name of the command
     # @return [Numeric] Transmit count for the command
-    def get_cmd_cnt(*args, scope: $openc3_scope, token: $openc3_token)
+    def get_cmd_cnt(*args, manual: false, scope: $openc3_scope, token: $openc3_token)
       target_name, command_name = _extract_target_command_names('get_cmd_cnt', *args)
-      authorize(permission: 'system', target_name: target_name, packet_name: command_name, scope: scope, token: token)
+      authorize(permission: 'system', target_name: target_name, packet_name: command_name, manual: manual, scope: scope, token: token)
       TargetModel.packet(target_name, command_name, type: :CMD, scope: scope)
       Topic.get_cnt("#{scope}__COMMAND__{#{target_name}}__#{command_name}")
     end
@@ -390,8 +394,8 @@ module OpenC3
     #
     # @param target_commands [Array<Array<String, String>>] Array of arrays containing target_name, packet_name
     # @return [Numeric] Transmit count for the command
-    def get_cmd_cnts(target_commands, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system', scope: scope, token: token)
+    def get_cmd_cnts(target_commands, manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'system', manual: manual, scope: scope, token: token)
       unless target_commands.is_a?(Array) and target_commands[0].is_a?(Array)
         raise "get_cmd_cnts takes an array of arrays containing target, packet_name, e.g. [['INST', 'COLLECT'], ['INST', 'ABORT']]"
       end
@@ -448,8 +452,9 @@ module OpenC3
       return [target_name, command_name, parameter_name]
     end
 
-    def _cmd_implementation(method_name, *args, range_check:, hazardous_check:, raw:, timeout: nil, log_message: nil,
-                           scope: $openc3_scope, token: $openc3_token, **kwargs)
+    # NOTE: When adding new keywords to this method, make sure to update script/commands.rb
+    def _cmd_implementation(method_name, *args, range_check:, hazardous_check:, raw:, timeout: nil, log_message: nil, manual: false, validate: true,
+                            scope: $openc3_scope, token: $openc3_token, **kwargs)
       extract_string_kwargs_to_args(args, kwargs)
       unless [nil, true, false].include?(log_message)
         raise "Invalid log_message parameter: #{log_message}. Must be true or false."
@@ -480,7 +485,24 @@ module OpenC3
       target_name = target_name.upcase
       cmd_name = cmd_name.upcase
       cmd_params = cmd_params.transform_keys(&:upcase)
-      authorize(permission: 'cmd', target_name: target_name, packet_name: cmd_name, scope: scope, token: token)
+      user = authorize(permission: 'cmd', target_name: target_name, packet_name: cmd_name, manual: manual, scope: scope, token: token)
+      if user.nil?
+        user = {}
+        user['username'] = ENV['OPENC3_MICROSERVICE_NAME']
+
+        # Get the caller stack trace to determine the point in the code where the command was called
+        # This code works but ultimately we didn't want to overload 'username' and take a performance hit
+        # caller.each do |frame|
+        #   # Look for the following line in the stack trace which indicates custom code
+        #   # /tmp/d20240827-62-8e57pf/targets/INST/lib/example_limits_response.rb:31:in `call'
+        #   if frame.include?("/targets/#{target_name}")
+        #     user = {}
+        #     # username is the name of the custom code file
+        #     user['username'] = frame.split("/targets/")[-1].split(':')[0]
+        #     break
+        #   end
+        # end
+      end
       packet = TargetModel.packet(target_name, cmd_name, type: :CMD, scope: scope)
       if packet['disabled']
         error = DisabledError.new
@@ -489,29 +511,35 @@ module OpenC3
         raise error
       end
 
-      command = {
-        'target_name' => target_name,
-        'cmd_name' => cmd_name,
-        'cmd_params' => cmd_params,
-        'range_check' => range_check.to_s,
-        'hazardous_check' => hazardous_check.to_s,
-        'raw' => raw.to_s
-      }
       if log_message.nil? # This means the default was used, no argument was passed
         log_message = true # Default is true
         # If the packet has the DISABLE_MESSAGES keyword then no messages by default
         log_message = false if packet["messages_disabled"]
         # Check if any of the parameters have DISABLE_MESSAGES
         cmd_params.each do |key, value|
-          item = packet['items'].find { |item| item['name'] == key.to_s }
+          item = packet['items'].find { |find_item| find_item['name'] == key.to_s }
           if item && item['states'] && item['states'][value] && item['states'][value]["messages_disabled"]
             log_message = false
           end
         end
       end
+      cmd_string = _build_cmd_output_string(method_name, target_name, cmd_name, cmd_params, packet)
       if log_message
-        Logger.info(_build_cmd_output_string(method_name, target_name, cmd_name, cmd_params, packet), scope: scope)
+        Logger.info(cmd_string, scope: scope)
       end
+
+      username = user && user['username'] ? user['username'] : 'anonymous'
+      command = {
+        'target_name' => target_name,
+        'cmd_name' => cmd_name,
+        'cmd_params' => cmd_params,
+        'range_check' => range_check.to_s,
+        'hazardous_check' => hazardous_check.to_s,
+        'raw' => raw.to_s,
+        'cmd_string' => cmd_string,
+        'username' => username,
+        'validate' => validate.to_s
+      }
       CommandTopic.send_command(command, timeout: timeout, scope: scope)
     end
 
@@ -525,7 +553,7 @@ module OpenC3
         cmd_params.each do |key, value|
           next if Packet::RESERVED_ITEM_NAMES.include?(key)
 
-          item = packet['items'].find { |item| item['name'] == key.to_s }
+          item = packet['items'].find { |find_item| find_item['name'] == key.to_s }
 
           begin
             item_type = item['data_type'].intern

data/lib/openc3/api/config_api.rb

@@ -33,28 +33,28 @@ module OpenC3
       'delete_config'
     ])
 
-    def config_tool_names(scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system', scope: scope, token: token)
+    def config_tool_names(manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'system', manual: manual, scope: scope, token: token)
       ToolConfigModel.config_tool_names(scope: scope)
     end
 
-    def list_configs(tool, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system', scope: scope, token: token)
+    def list_configs(tool, manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'system', manual: manual, scope: scope, token: token)
       ToolConfigModel.list_configs(tool, scope: scope)
     end
 
-    def load_config(tool, name, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system', scope: scope, token: token)
+    def load_config(tool, name, manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'system', manual: manual, scope: scope, token: token)
       ToolConfigModel.load_config(tool, name, scope: scope)
     end
 
-    def save_config(tool, name, data, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system_set', scope: scope, token: token)
+    def save_config(tool, name, data, manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'system_set', manual: manual, scope: scope, token: token)
       ToolConfigModel.save_config(tool, name, data, scope: scope)
     end
 
-    def delete_config(tool, name, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system_set', scope: scope, token: token)
+    def delete_config(tool, name, manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'system_set', manual: manual, scope: scope, token: token)
       ToolConfigModel.delete_config(tool, name, scope: scope)
     end
   end

data/lib/openc3/api/interface_api.rb

@@ -45,8 +45,8 @@ module OpenC3
     # @since 5.0.0
     # @param interface_name [String] Interface name
     # @return [Hash] Hash of all the interface information
-    def get_interface(interface_name, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system', interface_name: interface_name, scope: scope, token: token)
+    def get_interface(interface_name, manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'system', interface_name: interface_name, manual: manual, scope: scope, token: token)
       interface = InterfaceModel.get(name: interface_name, scope: scope)
       raise "Interface '#{interface_name}' does not exist" unless interface
 
@@ -54,8 +54,8 @@ module OpenC3
     end
 
     # @return [Array<String>] All the interface names
-    def get_interface_names(scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system', scope: scope, token: token)
+    def get_interface_names(manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'system', manual: manual, scope: scope, token: token)
       InterfaceModel.names(scope: scope)
     end
 
@@ -63,24 +63,27 @@ module OpenC3
     #
     # @param interface_name [String] The name of the interface
     # @param interface_params [Array] Optional parameters to pass to the interface
-    def connect_interface(interface_name, *interface_params, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system_set', interface_name: interface_name, scope: scope, token: token)
+    def connect_interface(interface_name, *interface_params, manual: false, scope: $openc3_scope, token: $openc3_token)
+      # TODO: Check if they have command authority for the targets mapped to this interface
+      authorize(permission: 'system_set', interface_name: interface_name, manual: manual, scope: scope, token: token)
       InterfaceTopic.connect_interface(interface_name, *interface_params, scope: scope)
     end
 
     # Disconnects from an interface and kills its telemetry gathering thread
     #
     # @param interface_name [String] The name of the interface
-    def disconnect_interface(interface_name, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system_set', interface_name: interface_name, scope: scope, token: token)
+    def disconnect_interface(interface_name, manual: false, scope: $openc3_scope, token: $openc3_token)
+      # TODO: Check if they have command authority for the targets mapped to this interface
+      authorize(permission: 'system_set', interface_name: interface_name, manual: manual, scope: scope, token: token)
       InterfaceTopic.disconnect_interface(interface_name, scope: scope)
     end
 
     # Starts raw logging for an interface
     #
     # @param interface_name [String] The name of the interface
-    def start_raw_logging_interface(interface_name = 'ALL', scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system_set', interface_name: interface_name, scope: scope, token: token)
+    def start_raw_logging_interface(interface_name = 'ALL', manual: false, scope: $openc3_scope, token: $openc3_token)
+      # TODO: Check if they have command authority for the targets mapped to this interface
+      authorize(permission: 'system_set', interface_name: interface_name, manual: manual, scope: scope, token: token)
       if interface_name == 'ALL'
         get_interface_names().each do |interface_name|
           InterfaceTopic.start_raw_logging(interface_name, scope: scope)
@@ -93,8 +96,9 @@ module OpenC3
     # Stop raw logging for an interface
     #
     # @param interface_name [String] The name of the interface
-    def stop_raw_logging_interface(interface_name = 'ALL', scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system_set', interface_name: interface_name, scope: scope, token: token)
+    def stop_raw_logging_interface(interface_name = 'ALL', manual: false, scope: $openc3_scope, token: $openc3_token)
+      # TODO: Check if they have command authority for the targets mapped to this interface
+      authorize(permission: 'system_set', interface_name: interface_name, manual: manual, scope: scope, token: token)
       if interface_name == 'ALL'
         get_interface_names().each do |interface_name|
           InterfaceTopic.stop_raw_logging(interface_name, scope: scope)
@@ -110,10 +114,10 @@ module OpenC3
     #   Numeric, Numeric>>] Array of Arrays containing \[name, state, num clients,
     #   TX queue size, RX queue size, TX bytes, RX bytes, Command count,
     #   Telemetry count] for all interfaces
-    def get_all_interface_info(scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system', scope: scope, token: token)
+    def get_all_interface_info(manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'system', manual: manual, scope: scope, token: token)
       info = []
-      InterfaceStatusModel.all(scope: scope).each do |int_name, int|
+      InterfaceStatusModel.all(scope: scope).each do |_int_name, int|
         info << [int['name'], int['state'], int['clients'], int['txsize'], int['rxsize'],
                  int['txbytes'], int['rxbytes'], int['txcnt'], int['rxcnt']]
       end
@@ -127,8 +131,9 @@ module OpenC3
     #
     # @param target_name [String/Array] The name of the target(s)
     # @param interface_name (see #connect_interface)
-    def map_target_to_interface(target_name, interface_name, cmd_only: false, tlm_only: false, unmap_old: true, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system_set', interface_name: interface_name, scope: scope, token: token)
+    def map_target_to_interface(target_name, interface_name, cmd_only: false, tlm_only: false, unmap_old: true, manual: false, scope: $openc3_scope, token: $openc3_token)
+      # TODO: Check if they have command authority for the targets mapped to this interface
+      authorize(permission: 'system_set', interface_name: interface_name, manual: manual, scope: scope, token: token)
       new_interface = InterfaceModel.get_model(name: interface_name, scope: scope)
       if Array === target_name
         target_names = target_name
@@ -142,13 +147,15 @@ module OpenC3
       nil
     end
 
-    def interface_cmd(interface_name, cmd_name, *cmd_params, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system_set', interface_name: interface_name, scope: scope, token: token)
+    def interface_cmd(interface_name, cmd_name, *cmd_params, manual: false, scope: $openc3_scope, token: $openc3_token)
+      # TODO: Check if they have command authority for the targets mapped to this interface
+      authorize(permission: 'system_set', interface_name: interface_name, manual: manual, scope: scope, token: token)
       InterfaceTopic.interface_cmd(interface_name, cmd_name, *cmd_params, scope: scope)
     end
 
-    def interface_protocol_cmd(interface_name, cmd_name, *cmd_params, read_write: :READ_WRITE, index: -1, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system_set', interface_name: interface_name, scope: scope, token: token)
+    def interface_protocol_cmd(interface_name, cmd_name, *cmd_params, read_write: :READ_WRITE, index: -1, manual: false, scope: $openc3_scope, token: $openc3_token)
+      # TODO: Check if they have command authority for the targets mapped to this interface
+      authorize(permission: 'system_set', interface_name: interface_name, manual: manual, scope: scope, token: token)
       InterfaceTopic.protocol_cmd(interface_name, cmd_name, *cmd_params, read_write: read_write, index: index, scope: scope)
     end
   end

data/lib/openc3/api/limits_api.rb

@@ -47,8 +47,8 @@ module OpenC3
     #   [[target name, packet name, item name, item limits state], ...]
     #
     # @return [Array<Array<String, String, String, String>>]
-    def get_out_of_limits(scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'tlm', scope: scope, token: token)
+    def get_out_of_limits(manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'tlm', manual: manual, scope: scope, token: token)
       LimitsEventTopic.out_of_limits(scope: scope)
     end
 
@@ -59,7 +59,7 @@ module OpenC3
     # @param ignored_items [Array<Array<String, String, String|nil>>] Array of [TGT, PKT, ITEM] strings
     #   to ignore when determining overall state. Note, ITEM can be nil to indicate to ignore entire packet.
     # @return [String] The overall limits state for the system, one of 'GREEN', 'YELLOW', 'RED'
-    def get_overall_limits_state(ignored_items = nil, scope: $openc3_scope, token: $openc3_token)
+    def get_overall_limits_state(ignored_items = nil, manual: false, scope: $openc3_scope, token: $openc3_token)
       # We only need to check out of limits items so call get_out_of_limits() which authorizes
       out_of_limits = get_out_of_limits(scope: scope, token: token)
       overall = 'GREEN'
@@ -107,10 +107,10 @@ module OpenC3
     # Favor the first syntax where possible as it is more succinct.
     #
     # @param args [String|Array<String>] See the description for calling style
-    # @return [Boolean] Whether limits are enable for the itme
-    def limits_enabled?(*args, scope: $openc3_scope, token: $openc3_token)
+    # @return [Boolean] Whether limits are enable for the item
+    def limits_enabled?(*args, manual: false, scope: $openc3_scope, token: $openc3_token)
       target_name, packet_name, item_name = _tlm_process_args(args, 'limits_enabled?', scope: scope)
-      authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
+      authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, manual: manual, scope: scope, token: token)
       return TargetModel.packet_item(target_name, packet_name, item_name, scope: scope)['limits']['enabled'] ? true : false
     end
     alias limits_enabled limits_enabled?
@@ -124,9 +124,9 @@ module OpenC3
     # Favor the first syntax where possible as it is more succinct.
     #
     # @param args [String|Array<String>] See the description for calling style
-    def enable_limits(*args, scope: $openc3_scope, token: $openc3_token)
+    def enable_limits(*args, manual: false, scope: $openc3_scope, token: $openc3_token)
       target_name, packet_name, item_name = _tlm_process_args(args, 'enable_limits', scope: scope)
-      authorize(permission: 'tlm_set', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
+      authorize(permission: 'tlm_set', target_name: target_name, packet_name: packet_name, manual: manual, scope: scope, token: token)
       packet = TargetModel.packet(target_name, packet_name, scope: scope)
       found_item = nil
       packet['items'].each do |item|
@@ -157,9 +157,9 @@ module OpenC3
     # Favor the first syntax where possible as it is more succinct.
     #
     # @param args [String|Array<String>] See the description for calling style
-    def disable_limits(*args, scope: $openc3_scope, token: $openc3_token)
+    def disable_limits(*args, manual: false, scope: $openc3_scope, token: $openc3_token)
       target_name, packet_name, item_name = _tlm_process_args(args, 'disable_limits', scope: scope)
-      authorize(permission: 'tlm_set', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
+      authorize(permission: 'tlm_set', target_name: target_name, packet_name: packet_name, manual: manual, scope: scope, token: token)
       packet = TargetModel.packet(target_name, packet_name, scope: scope)
       found_item = nil
       packet['items'].each do |item|
@@ -190,8 +190,8 @@ module OpenC3
     #               'TVAC' => [-25, -10, 50, 55] }
     #
     # @return [Hash{String => Array<Number, Number, Number, Number, Number, Number>}]
-    def get_limits(target_name, packet_name, item_name, cache_timeout: nil, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
+    def get_limits(target_name, packet_name, item_name, cache_timeout: nil, manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, manual: manual, scope: scope, token: token)
       limits = {}
       item = _get_item(target_name, packet_name, item_name, cache_timeout: cache_timeout, scope: scope)
       item['limits'].each do |key, vals|
@@ -207,8 +207,8 @@ module OpenC3
     # is created to avoid overriding existing limits.
     def set_limits(target_name, packet_name, item_name, red_low, yellow_low, yellow_high, red_high,
                    green_low = nil, green_high = nil, limits_set = 'CUSTOM', persistence = nil, enabled = true,
-                   scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'tlm_set', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
+                   manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'tlm_set', target_name: target_name, packet_name: packet_name, manual: manual, scope: scope, token: token)
       if (red_low > yellow_low) || (yellow_low >= yellow_high) || (yellow_high > red_high)
         raise "Invalid limits specified. Ensure yellow limits are within red limits."
       end
@@ -259,38 +259,38 @@ module OpenC3
     # Returns all limits_groups and their members
     # @since 5.0.0 Returns hash with values
     # @return [Hash{String => Array<Array<String, String, String>>]
-    def get_limits_groups(scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'tlm', scope: scope, token: token)
+    def get_limits_groups(manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'tlm', manual: manual, scope: scope, token: token)
       TargetModel.limits_groups(scope: scope)
     end
 
     # Enables limits for all the items in the group
     #
     # @param group_name [String] Name of the group to enable
-    def enable_limits_group(group_name, scope: $openc3_scope, token: $openc3_token)
-      _limits_group(group_name, action: :enable, scope: scope, token: token)
+    def enable_limits_group(group_name, manual: false, scope: $openc3_scope, token: $openc3_token)
+      _limits_group(group_name, action: :enable, manual: manual, scope: scope, token: token)
     end
 
     # Disables limits for all the items in the group
     #
     # @param group_name [String] Name of the group to disable
-    def disable_limits_group(group_name, scope: $openc3_scope, token: $openc3_token)
-      _limits_group(group_name, action: :disable, scope: scope, token: token)
+    def disable_limits_group(group_name, manual: false, scope: $openc3_scope, token: $openc3_token)
+      _limits_group(group_name, action: :disable, manual: manual, scope: scope, token: token)
     end
 
     # Returns all defined limits sets
     #
     # @return [Array<String>] All defined limits sets
-    def get_limits_sets(scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'tlm', scope: scope, token: token)
+    def get_limits_sets(manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'tlm', manual: manual, scope: scope, token: token)
       LimitsEventTopic.sets(scope: scope).keys
     end
 
     # Changes the active limits set that applies to all telemetry
     #
     # @param limits_set [String] The name of the limits set
-    def set_limits_set(limits_set, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'tlm_set', scope: scope, token: token)
+    def set_limits_set(limits_set, manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'tlm_set', manual: manual, scope: scope, token: token)
       message = "Setting Limits Set: #{limits_set}"
       Logger.info(message, scope: scope)
       LimitsEventTopic.write({ type: :LIMITS_SET, set: limits_set.to_s,
@@ -300,8 +300,8 @@ module OpenC3
     # Returns the active limits set that applies to all telemetry
     #
     # @return [String] The current limits set
-    def get_limits_set(scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'tlm', scope: scope, token: token)
+    def get_limits_set(manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'tlm', manual: manual, scope: scope, token: token)
       LimitsEventTopic.current_set(scope: scope)
     end
 
@@ -313,8 +313,8 @@ module OpenC3
     # @param count [Integer] The total number of events returned. Default is 100.
     # @return [Hash, Integer] Event hash followed by the offset. The offset can
     #   be used in subsequent calls to return events from where the last call left off.
-    def get_limits_events(offset = nil, count: 100, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'tlm', scope: scope, token: token)
+    def get_limits_events(offset = nil, count: 100, manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'tlm', manual: manual, scope: scope, token: token)
       LimitsEventTopic.read(offset, count: count, scope: scope)
     end
 
@@ -323,8 +323,8 @@ module OpenC3
     ###########################################################################
 
     # Enables or disables a limits group
-    def _limits_group(group_name, action:, scope:, token:)
-      authorize(permission: 'tlm_set', scope: scope, token: token)
+    def _limits_group(group_name, action:, manual:, scope:, token:)
+      authorize(permission: 'tlm_set', manual: manual, scope: scope, token: token)
       group_name.upcase!
       group = get_limits_groups(scope: scope, token: token)[group_name]
       raise "LIMITS_GROUP #{group_name} undefined. Ensure your telemetry definition contains the line: LIMITS_GROUP #{group_name}" unless group

data/lib/openc3/api/metrics_api.rb

@@ -66,15 +66,15 @@ module OpenC3
     SUM_METRICS['text_log_total'] = 0
     SUM_METRICS['text_log_error_total'] = 0
 
-    def get_metrics(scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system', scope: scope, token: token)
+    def get_metrics(manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'system', manual: manual, scope: scope, token: token)
 
       sum_metrics = SUM_METRICS.dup
       duration_metrics = DURATION_METRICS.dup
       delay_metrics = DELAY_METRICS.dup
 
       metrics = MetricModel.all(scope: scope)
-      metrics.each do |microservice_name, metrics|
+      metrics.each do |_microservice_name, metrics|
         next unless metrics and metrics['values']
         metrics['values'].each do |metric_name, data|
           value = data['value']