wisco 0.4.2 → 0.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4893611d0b98c82232776fa4705b9f92f83d76f4df549a641e2951068d7a5ee3
-  data.tar.gz: af96365443af8fc4b407ad7de5fae4c279e630665d405f6d8945c7f3a992fb2d
+  metadata.gz: 3ab77bb62a7ce39484d205397fb9350d3b17f2fbdde6f11ce47517da942608a1
+  data.tar.gz: db26dddd97fba3b9f3471d408e0f80750375d0ab18111d36d20d3b603e447daf
 SHA512:
-  metadata.gz: 1edd85873a8c84fda1bd7829e47a7da67a917b50279204956ea29309f31174fb90825b06e298489d69dc88f11f2d9f68ec1abdb45ed96fb29200ef7e54304fab
-  data.tar.gz: 9876280ad0dbd7cb2cfeea241155f2538df6b65f37ecdd8ab4d4b6406de9c841bce52c4b23b2043b27cf047aef3919bc94da185139789013c246f0a9ecdbb2f5
+  metadata.gz: 5eb44d4bd05b130cfc4fb3f0c59325df601230e3c7be1e1e6b40f608f9ff4202bc0a99ee51a0fff177a2db71aba9e8ecb1dccad2fc7bf1b2a8a747f15a7c0d53
+  data.tar.gz: 6887090edc5bf94a7c7aa8d07878738da08ac009d498e18115e65952b2598fb2ec6a98610cf80f976fdecd66d996610874bb74fb81be6c581de7a7bf3973d35f

data/lib/wisco/commands/exec.rb

@@ -16,7 +16,7 @@ module Wisco
       def run(path_arg, target_dir, input: nil, pagination: true, verbose: false, debug: false,
               extended: true, closure: nil, config_fields: nil, continue: nil,
               extended_input_schema: nil, extended_output_schema: nil,
-              summary: true, summary_lines: 20)
+              summary: true, summary_lines: 20, auto_refresh: true)
         target_dir = File.expand_path(target_dir)
         config_path = Wisco.config_path(target_dir)
 
@@ -40,7 +40,8 @@ module Wisco
 
         # ── connection test short-circuit ──────────────────────────────────
         if path_arg == 'test'
-          run_test(target_dir, connector_full_path, connection, verbose: verbose, debug: debug)
+          run_test(target_dir, connector_full_path, connection, verbose: verbose, debug: debug,
+                   auto_refresh: auto_refresh)
           return
         end
 
@@ -68,7 +69,8 @@ module Wisco
                           closure: closure, config_fields: config_fields, continue: continue,
                           extended_input_schema: extended_input_schema,
                           extended_output_schema: extended_output_schema, debug: debug,
-                          summary: summary, summary_lines: summary_lines, batch: batch)
+                          summary: summary, summary_lines: summary_lines, batch: batch,
+                          auto_refresh: auto_refresh)
             else
               Wisco::TerminalOutput.emit_warning("  Warning: No ready input files found in #{fixture_dir_output}")
               input_template = File.join(fixtures_dir, 'execute_input.json')
@@ -87,14 +89,16 @@ module Wisco
                                   extended: extended, closure: closure, config_fields: config_fields,
                                   continue: continue, extended_input_schema: extended_input_schema,
                                   extended_output_schema: extended_output_schema, debug: debug,
-                                  summary: summary, summary_lines: summary_lines, batch: batch)
+                                  summary: summary, summary_lines: summary_lines, batch: batch,
+                                  auto_refresh: auto_refresh)
             else
               execute_one(section, key, input_file, fixtures_dir,
                           connector_full_path, connection, pagination: pagination, verbose: verbose,
                           extended: extended, closure: closure, config_fields: config_fields,
                           continue: continue, extended_input_schema: extended_input_schema,
                           extended_output_schema: extended_output_schema, debug: debug,
-                          summary: summary, summary_lines: summary_lines, batch: batch)
+                          summary: summary, summary_lines: summary_lines, batch: batch,
+                          auto_refresh: auto_refresh)
             end
           end
         end
@@ -153,7 +157,8 @@ module Wisco
         File.dirname(value) == '.' ? File.join(fixtures_dir, value) : value
       end
 
-      def run_test(target_dir, connector_full_path, connection, verbose: false, debug: false)
+      def run_test(target_dir, connector_full_path, connection, verbose: false, debug: false,
+                   auto_refresh: true)
         puts "Testing connection"
         fixtures_dir = File.join(target_dir, 'fixtures', 'connection', 'test')
         FileUtils.mkdir_p(fixtures_dir)
@@ -174,6 +179,7 @@ module Wisco
 
         begin
           cmd = Workato::CLI::ExecCommand.new(path: 'test', options: options)
+          apply_auto_refresh(cmd) if auto_refresh
           cmd.call
         rescue StandardError => e
           File.write(error_file, "#{e.class}: #{e.message}\n\n#{e.backtrace.join("\n")}\n")
@@ -194,7 +200,7 @@ module Wisco
                       pagination: true, verbose: false, debug: false,
                       extended: true, closure: nil, config_fields: nil, continue: nil,
                       extended_input_schema: nil, extended_output_schema: nil,
-                      summary: true, summary_lines: 20, batch: false)
+                      summary: true, summary_lines: 20, batch: false, auto_refresh: true)
         stem        = input_file ? File.basename(input_file, '.*') : 'execute'
         output_file = File.join(fixtures_dir, "output_#{stem}.json")
         error_file  = File.join(fixtures_dir, "error_#{stem}.txt")
@@ -265,6 +271,7 @@ module Wisco
 
         begin
           cmd = Workato::CLI::ExecCommand.new(path: exec_path, options: options)
+          apply_auto_refresh(cmd) if auto_refresh
           cmd.call
         rescue StandardError => e
           FileUtils.rm_f(output_file)
@@ -295,7 +302,7 @@ module Wisco
                               pagination: true, verbose: false, debug: false,
                               extended: true, closure: nil, config_fields: nil, continue: nil,
                               extended_input_schema: nil, extended_output_schema: nil,
-                              summary: true, summary_lines: 20, batch: false)
+                              summary: true, summary_lines: 20, batch: false, auto_refresh: true)
         subdir      = File.join(fixtures_dir, File.basename(script_path, '.rb'))
         FileUtils.mkdir_p(subdir)
         input_file  = File.join(subdir, 'input.json')
@@ -379,6 +386,7 @@ module Wisco
         # Step 3: invoke ExecCommand against the generated input
         begin
           cmd = Workato::CLI::ExecCommand.new(path: exec_path, options: options)
+          apply_auto_refresh(cmd) if auto_refresh
           cmd.call
         rescue StandardError => e
           FileUtils.rm_f(input_file)
@@ -471,6 +479,14 @@ module Wisco
         str.length > max ? "#{str[0, max - 1]}…" : str
       end
 
+      # Overrides ask() on the ExecCommand singleton so the SDK's token-refresh
+      # prompt ("Updated settings file with new connection attributes? (Yes or No)")
+      # is answered "y" automatically. The refresh lambda captures self (the
+      # ExecCommand instance), so the singleton method wins over Thor::Shell::Basic.
+      def apply_auto_refresh(cmd)
+        cmd.define_singleton_method(:ask) { |*| 'y' }
+      end
+
       # ── SDK array-args normalisation ───────────────────────────────────────
       # The Workato SDK's InvokePath#invoke_method applies Array.wrap(args.last).flatten(1)
       # when the last parameter is *args, which incorrectly unwraps array-valued positional

data/lib/wisco/commands/settings.rb

@@ -0,0 +1,363 @@
+require 'json'
+require_relative '../config'
+require_relative '../connector'
+require_relative '../settings_store'
+require_relative '../terminal_output'
+
+module Wisco
+  module Commands
+    class Settings < Thor
+      def self.exit_on_failure?
+        true
+      end
+
+      desc 'list', 'List connection sets in the settings file'
+      option :format, type: :string, enum: %w[json], desc: 'Machine-readable output (json = array of set names)'
+      def list
+        store = settings_store
+        data  = read_settings!(store)
+        names = Wisco::SettingsStore.set_names(data)
+
+        if options[:format] == 'json'
+          puts JSON.generate(names)
+          return
+        end
+
+        case Wisco::SettingsStore.detect_structure(data)
+        when :nested, :mixed
+          active = active_connection
+          puts "Connection sets (#{store.filename}):\n\n"
+          width = names.map(&:length).max || 0
+          names.each do |n|
+            marker = n == active ? '*' : ' '
+            puts "  #{marker} #{n.ljust(width)}"
+          end
+          if active && !active.empty?
+            puts
+            puts "Active connection (from #{Wisco::WISCO_DIR}/#{Wisco::CONFIG_FILENAME}): #{active}"
+          end
+        when :flat
+          puts "#{store.filename} contains a single, unnamed connection set."
+          puts "No named connection sets are defined. Use 'wisco settings add <name>' to create named sets."
+        when :none
+          puts "No settings file found in #{store.connector_path}."
+          puts "Run 'wisco settings add <name>' to create one, or 'workato edit' to create an encrypted file."
+        end
+      end
+
+      desc 'set CONNECTION', "Set the project's active connection set"
+      def set(connection)
+        store = settings_store
+        names = begin
+          Wisco::SettingsStore.set_names(store.read_all)
+        rescue Wisco::SettingsStore::MissingKeyError
+          nil
+        end
+
+        if names.nil?
+          Wisco::TerminalOutput.emit_warning("Warning: could not read #{store.filename} to validate (no master key).")
+          Wisco::TerminalOutput.emit_warning('         Config updated anyway.')
+        elsif !names.include?(connection)
+          Wisco::TerminalOutput.emit_warning("Warning: \"#{connection}\" is not currently defined in #{store.filename}.")
+          Wisco::TerminalOutput.emit_warning("         Defined sets: #{names.empty? ? '(none)' : names.join(', ')}")
+          Wisco::TerminalOutput.emit_warning("         Config updated anyway. Run 'wisco settings add #{connection}' to create it.")
+        end
+
+        cfg = config
+        cfg['connection'] = connection
+        Wisco::Config.save_config(config_path, cfg)
+        puts "Active connection set to \"#{connection}\" in #{Wisco::WISCO_DIR}/#{Wisco::CONFIG_FILENAME}."
+      end
+
+      desc 'add CONNECTION', 'Scaffold a new connection set from connector.connection.fields'
+      long_desc <<~DESC
+        Reads connection.fields from the connector and writes a new named connection
+        set with those field names and blank values. Fill the values in afterwards
+        with 'workato edit'. If the settings file currently holds a single unnamed
+        (flat) connection set, you are prompted to name it so the file can be
+        converted to the named (nested) format.
+      DESC
+      def add(connection)
+        field_names = connection_field_names!
+        if field_names.empty?
+          Wisco::TerminalOutput.emit_error('Error: The connector defines no connection.fields to scaffold.')
+          exit 1
+        end
+        new_set = field_names.each_with_object({}) { |n, h| h[n] = '' }
+
+        store = settings_store
+        data  = read_settings!(store)
+        structure = Wisco::SettingsStore.detect_structure(data)
+
+        if Wisco::SettingsStore.set_names(data).include?(connection)
+          Wisco::TerminalOutput.emit_error("Error: Connection set \"#{connection}\" already exists in #{store.filename}.")
+          Wisco::TerminalOutput.emit_error("       Use 'wisco settings show #{connection}' to view it, or edit it with 'workato edit'.")
+          exit 1
+        end
+
+        target =
+          case structure
+          when :nested
+            data.merge(connection => new_set)
+          when :none
+            { connection => new_set }
+          when :flat
+            migrate_flat(data, store).merge(connection => new_set)
+          when :mixed
+            Wisco::TerminalOutput.emit_error("Error: #{store.filename} mixes flat keys and named sets; resolve it with 'workato edit' before adding.")
+            exit 1
+          end
+
+        # A brand-new file is written plaintext; existing files keep their form.
+        encrypted = structure != :none && store.encrypted?
+        written   = encrypted ? Wisco::SettingsStore::ENCRYPTED_FILENAME : Wisco::SettingsStore::PLAINTEXT_FILENAME
+        store.write_all(target, encrypted: encrypted)
+
+        puts "Added connection set \"#{connection}\" to #{written} with #{field_names.length} blank field(s):"
+        puts "  #{field_names.join(', ')}"
+        puts "Fill in the values with 'workato edit', then run 'wisco settings set #{connection}'."
+      end
+
+      desc 'show [CONNECTION]', "Show a connection set's field values (passwords masked)"
+      option :format, type: :string, enum: %w[json], desc: 'Machine-readable output (json = connection fields with current values)'
+      def show(connection = nil)
+        store = settings_store
+        data  = read_settings!(store)
+
+        name, set =
+          case Wisco::SettingsStore.detect_structure(data)
+          when :none
+            Wisco::TerminalOutput.emit_error("Error: No settings file found in #{store.connector_path}. Nothing to show.")
+            exit 1
+          when :flat
+            if connection
+              Wisco::TerminalOutput.emit_error("Error: #{store.filename} has a single unnamed connection set; there is no named set \"#{connection}\".")
+              exit 1
+            end
+            [nil, data]
+          when :nested, :mixed
+            names = Wisco::SettingsStore.set_names(data)
+            if connection.nil?
+              Wisco::TerminalOutput.emit_warning('Warning: This settings file has multiple connection sets; specify which one to show.')
+              Wisco::TerminalOutput.emit_warning("         Defined sets: #{names.join(', ')}")
+              return
+            end
+            unless names.include?(connection)
+              Wisco::TerminalOutput.emit_error("Error: Connection set \"#{connection}\" not found in #{store.filename}.")
+              Wisco::TerminalOutput.emit_error("       Defined sets: #{names.join(', ')}")
+              exit 1
+            end
+            [connection, data[connection]]
+          end
+
+        if options[:format] == 'json'
+          render_set_json(set)
+        else
+          render_set(name, set, store)
+        end
+      end
+
+      desc 'current', 'Show which connection set the project points at'
+      def current
+        active = active_connection.to_s.strip
+        store  = settings_store
+        data   = begin
+          store.read_all
+        rescue Wisco::SettingsStore::MissingKeyError
+          nil
+        end
+        names = data ? Wisco::SettingsStore.set_names(data) : []
+
+        if active.empty?
+          puts 'This project has no named connection selected (config.json has no "connection" key).'
+          puts "The connector will use the single connection set in #{store.filename}."
+          return
+        end
+
+        puts "This project uses connection set: #{active}"
+        if data.nil?
+          Wisco::TerminalOutput.emit_warning("  Could not read #{store.filename} to verify (no master key).")
+        elsif names.include?(active)
+          puts "  Defined in: #{store.filename}  ✓"
+        else
+          puts "  Not found in #{store.filename}. Run 'wisco settings add #{active}' to create it."
+        end
+      end
+
+      desc 'fields', 'List the connector connection fields'
+      option :format, type: :string, enum: %w[json], desc: 'Machine-readable output (json)'
+      def fields
+        raw = connection_fields!
+
+        if options[:format] == 'json'
+          puts JSON.pretty_generate(raw)
+          return
+        end
+
+        if raw.empty?
+          puts 'Connector defines no connection fields.'
+          return
+        end
+
+        rows = raw.map do |f|
+          [
+            field_attr(f, :name).to_s,
+            field_attr(f, :label).to_s,
+            (field_attr(f, :control_type) || '(default)').to_s,
+            field_attr(f, :optional) ? 'no' : 'yes'
+          ]
+        end
+
+        headers = %w[Name Label Type Required]
+        widths  = headers.each_index.map do |i|
+          ([headers[i]] + rows.map { |r| r[i] }).map(&:length).max
+        end
+
+        puts "Connection fields (from #{connector_file_basename}):\n\n"
+        puts "  #{headers.each_with_index.map { |h, i| h.ljust(widths[i]) }.join('  ')}"
+        rows.each do |r|
+          puts "  #{r.each_with_index.map { |c, i| c.ljust(widths[i]) }.join('  ')}"
+        end
+      end
+
+      no_commands do
+        def target_dir
+          Dir.pwd
+        end
+
+        def config_path
+          Wisco.config_path(target_dir)
+        end
+
+        def config
+          @config ||= begin
+            unless File.exist?(config_path)
+              Wisco::TerminalOutput.emit_error("Error: No #{Wisco::WISCO_DIR}/#{Wisco::CONFIG_FILENAME} found in #{target_dir}.")
+              Wisco::TerminalOutput.emit_error("       Run 'wisco init' first.")
+              exit 1
+            end
+            Wisco::Config.load_config(config_path)
+          end
+        end
+
+        def connector_path
+          path = config.dig('connector', 'path')
+          if path.nil?
+            Wisco::TerminalOutput.emit_error("Error: #{Wisco::WISCO_DIR}/#{Wisco::CONFIG_FILENAME} is missing connector path. Run 'wisco init' again.")
+            exit 1
+          end
+          path
+        end
+
+        def connector_file_basename
+          config.dig('connector', 'file') || 'connector.rb'
+        end
+
+        def active_connection
+          config['connection']
+        end
+
+        def settings_store
+          Wisco::SettingsStore.new(connector_path)
+        end
+
+        # Reads the settings file, converting a missing master key into a clean
+        # error+exit (used by commands that cannot proceed without the contents).
+        def read_settings!(store)
+          store.read_all
+        rescue Wisco::SettingsStore::MissingKeyError => e
+          Wisco::TerminalOutput.emit_error("Error: #{e.message}")
+          exit 1
+        end
+
+        # connection.fields array from the connector (symbol-keyed hashes).
+        # Exits with the connector's load error if it cannot be loaded.
+        def connection_fields!
+          connector = Wisco::Connector.load_connector_from_config(target_dir)
+          Array(connector.is_a?(Hash) ? connector.dig(:connection, :fields) : nil)
+        rescue StandardError => e
+          Wisco::TerminalOutput.emit_error("Error: #{e.message.strip}")
+          exit 1
+        end
+
+        def connection_field_names!
+          connection_fields!.map { |f| field_attr(f, :name).to_s }.reject(&:empty?)
+        end
+
+        # Password field names for masking. Degrades gracefully (returns []) if
+        # the connector cannot be loaded, so `show` still works.
+        def password_field_names
+          connector = Wisco::Connector.load_connector_from_config(target_dir)
+          fields = Array(connector.is_a?(Hash) ? connector.dig(:connection, :fields) : nil)
+          fields.select { |f| field_attr(f, :control_type).to_s == 'password' }
+                .map { |f| field_attr(f, :name).to_s }
+        rescue SystemExit, StandardError
+          Wisco::TerminalOutput.emit_warning('Warning: could not load connector to identify password fields; showing all values unmasked.')
+          []
+        end
+
+        def field_attr(field, key)
+          return nil unless field.is_a?(Hash)
+
+          field[key] || field[key.to_s]
+        end
+
+        def render_set(name, set, store)
+          passwords = password_field_names
+          header    = name || '(single/unnamed)'
+          puts "Connection set: #{header}   (#{store.filename})\n\n"
+
+          if set.nil? || set.empty?
+            puts '  (no fields)'
+            return
+          end
+
+          width = set.keys.map { |k| k.to_s.length }.max
+          set.each do |k, v|
+            display =
+              if v.to_s.empty?
+                '(blank)'
+              elsif passwords.include?(k.to_s)
+                mask(v.to_s)
+              else
+                v.to_s
+              end
+            puts "  #{k.to_s.ljust(width)}  #{display}"
+          end
+        end
+
+        def mask(value)
+          return '****' if value.length <= 4
+
+          "****#{value[-4..]}"
+        end
+
+        # Machine-readable form of a connection set: the connector's
+        # connection.fields array, each field augmented with a `value` key holding
+        # the current stored value (null when the field is unset or blank). Values
+        # are unmasked — this output is for tooling, not display.
+        def render_set_json(set)
+          set ||= {}
+          out = connection_fields!.map do |f|
+            raw   = set[field_attr(f, :name).to_s]
+            value = raw.nil? || raw.to_s.empty? ? nil : raw
+            f.merge(value: value)
+          end
+          puts JSON.pretty_generate(out)
+        end
+
+        def migrate_flat(flat_data, store)
+          puts "#{store.filename} currently holds a single unnamed connection set."
+          puts 'Adding a named set requires converting the file to the named (nested) format.'
+          print 'Enter a name for the existing connection set (or press Enter to skip): '
+          name = $stdin.gets.to_s.strip
+          if name.empty?
+            Wisco::TerminalOutput.emit_error('Aborted: mixing flat and named connection sets is not supported.')
+            exit 1
+          end
+          { name => flat_data }
+        end
+      end
+    end
+  end
+end

data/lib/wisco/settings_store.rb

@@ -0,0 +1,133 @@
+require 'yaml'
+require 'active_support/encrypted_configuration'
+require 'workato/connector/sdk'
+require_relative 'terminal_output'
+
+module Wisco
+  # Read/write wrapper over the Workato SDK settings file (settings.yaml /
+  # settings.yaml.enc) living in a connector directory. Handles encrypted vs
+  # plaintext auto-detection, master-key resolution, and flat-vs-nested
+  # connection-set detection. See doc-specs/wisco-10-settings.md.
+  class SettingsStore
+    PLAINTEXT_FILENAME  = 'settings.yaml'.freeze
+    ENCRYPTED_FILENAME  = 'settings.yaml.enc'.freeze
+    MASTER_KEY_FILENAME = 'master.key'.freeze
+    MASTER_KEY_ENV      = 'WORKATO_CONNECTOR_MASTER_KEY'.freeze
+
+    class MissingKeyError < StandardError; end
+
+    attr_reader :connector_path
+
+    def initialize(connector_path)
+      @connector_path = File.expand_path(connector_path)
+    end
+
+    def plaintext_path
+      File.join(@connector_path, PLAINTEXT_FILENAME)
+    end
+
+    def encrypted_path
+      File.join(@connector_path, ENCRYPTED_FILENAME)
+    end
+
+    def master_key_path
+      File.join(@connector_path, MASTER_KEY_FILENAME)
+    end
+
+    # :encrypted (settings.yaml.enc present), :plaintext (settings.yaml present),
+    # or :none. Encrypted takes precedence when both exist.
+    def form
+      if File.exist?(encrypted_path)
+        :encrypted
+      elsif File.exist?(plaintext_path)
+        :plaintext
+      else
+        :none
+      end
+    end
+
+    def encrypted?
+      form == :encrypted
+    end
+
+    def exist?
+      form != :none
+    end
+
+    # Basename for user-facing messages; falls back to the plaintext name when
+    # no file exists yet (that is the form `add` would create).
+    def filename
+      encrypted? ? ENCRYPTED_FILENAME : PLAINTEXT_FILENAME
+    end
+
+    def master_key_available?
+      !ENV[MASTER_KEY_ENV].to_s.strip.empty? || File.exist?(master_key_path)
+    end
+
+    # Reads the entire settings file (all sets) as a plain string-keyed Hash.
+    # Returns {} when no file exists. Raises MissingKeyError if the file is
+    # encrypted and no master key is available.
+    def read_all
+      case form
+      when :none
+        {}
+      when :plaintext
+        parsed = YAML.safe_load(File.read(plaintext_path), permitted_classes: [::Symbol])
+        parsed.is_a?(Hash) ? parsed : {}
+      when :encrypted
+        require_master_key!
+        raw = Workato::Connector::Sdk::Settings.from_encrypted_file(encrypted_path, master_key_path)
+        raw.respond_to?(:to_hash) ? raw.to_hash : {}
+      end
+    end
+
+    # Replaces the whole settings file with `data`. When `encrypted:` is true the
+    # content is encrypted with the resolved master key; otherwise a plaintext
+    # settings.yaml is written. Rewriting wholesale (rather than the SDK's
+    # merge-only #update) is what lets `add` migrate a flat file to nested form.
+    def write_all(data, encrypted:)
+      if encrypted
+        require_master_key!
+        config = ActiveSupport::EncryptedConfiguration.new(
+          config_path:          encrypted_path,
+          key_path:             master_key_path,
+          env_key:              MASTER_KEY_ENV,
+          raise_if_missing_key: true
+        )
+        config.write(YAML.dump(data))
+      else
+        File.write(plaintext_path, YAML.dump(data))
+      end
+    end
+
+    def require_master_key!
+      return if master_key_available?
+
+      raise MissingKeyError,
+            "#{ENCRYPTED_FILENAME} is encrypted but no master key was found.\n" \
+            "       Set #{MASTER_KEY_ENV} or provide a #{MASTER_KEY_FILENAME} file in #{@connector_path}."
+    end
+
+    # :none, :flat (all top-level values scalar), :nested (all Hash), or :mixed.
+    def self.detect_structure(data)
+      return :none if data.nil? || data.empty?
+
+      values = data.values
+      if values.all? { |v| v.is_a?(Hash) }
+        :nested
+      elsif values.none? { |v| v.is_a?(Hash) }
+        :flat
+      else
+        :mixed
+      end
+    end
+
+    # Names of the named (nested) connection sets — the top-level keys whose
+    # value is a Hash. Empty for flat/none files.
+    def self.set_names(data)
+      return [] if data.nil?
+
+      data.select { |_k, v| v.is_a?(Hash) }.keys
+    end
+  end
+end

data/lib/wisco/version.rb

@@ -1,3 +1,3 @@
 module Wisco
-  VERSION = '0.4.2'
+  VERSION = '0.4.4'
 end

data/lib/wisco.rb

@@ -25,6 +25,7 @@ require_relative 'wisco/commands/pull'
 require_relative 'wisco/commands/push'
 require_relative 'wisco/commands/schema'
 require_relative 'wisco/commands/profile'
+require_relative 'wisco/commands/settings'
 require_relative 'wisco/commands/status'
 
 module Wisco
@@ -103,6 +104,7 @@ module Wisco
     option :debug,         type: :boolean, default: false, desc: 'Print ExecCommand call details'
     option :summary,       type: :boolean, default: true,  desc: 'Show output summary after execution (use --no-summary to disable)'
     option :'summary-lines', type: :numeric, default: 20,  desc: 'Max output lines to display in full before switching to summary-only'
+    option :'auto-refresh', type: :boolean, default: true,  desc: 'Automatically confirm token refresh prompts (use --no-auto-refresh to disable)'
     def exec(path_arg, target_dir = nil)
       Wisco::Commands::Exec.run(
         path_arg,
@@ -118,7 +120,8 @@ module Wisco
         extended_output_schema: options[:extended_output_schema],
         debug:                  options[:debug],
         summary:                options[:summary],
-        summary_lines:          options[:'summary-lines']
+        summary_lines:          options[:'summary-lines'],
+        auto_refresh:           options[:'auto-refresh']
       )
     end
 
@@ -215,6 +218,18 @@ module Wisco
     DESC
     subcommand 'profile', Wisco::Commands::Profile
 
+    desc 'settings SUBCOMMAND ...ARGS', 'Manage the connector settings file (credential sets)'
+    long_desc <<~DESC
+      Subcommands:
+        list                 List connection sets (--format=json for a JSON array of names)
+        set <connection>     Set the project's active connection set
+        add <connection>     Scaffold a new connection set from connector.connection.fields
+        show [<connection>]  Show a connection set's field values (passwords masked)
+        current              Show which connection set the project points at
+        fields               List the connector's connection fields (--format=json for JSON)
+    DESC
+    subcommand 'settings', Wisco::Commands::Settings
+
     desc 'schema INPUT_FILE [TARGET_DIR]', 'Generate a schema from a JSON or CSV sample file'
     long_desc <<~DESC
       Calls the Workato API to generate a schema from a sample JSON or CSV file.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wisco
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.4
 platform: ruby
 authors:
 - mbillington
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-15 00:00:00.000000000 Z
+date: 2026-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -75,12 +75,14 @@ files:
 - lib/wisco/commands/pull.rb
 - lib/wisco/commands/push.rb
 - lib/wisco/commands/schema.rb
+- lib/wisco/commands/settings.rb
 - lib/wisco/commands/status.rb
 - lib/wisco/config.rb
 - lib/wisco/connector.rb
 - lib/wisco/exec_script.rb
 - lib/wisco/path_utils.rb
 - lib/wisco/profile.rb
+- lib/wisco/settings_store.rb
 - lib/wisco/terminal_output.rb
 - lib/wisco/version.rb
 - lib/wisco/workato_api.rb