wisco 0.3.5 → 0.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f7db313badb869b62a2bf9eab0b4558cecffe8946bb8acaa0664cb4d65e3641f
-  data.tar.gz: fa68ec90e00dec3934be909a3f9b5cb122bd93a8dac3801733eba4f066f2f4f4
+  metadata.gz: 942295e665d5ecea09078c736425531bb9846bfe29db26223bf52034ff4221b0
+  data.tar.gz: c56480bf18d42ac7797dd2b46f9d50146788f1590e673f4056bbe0ce55580347
 SHA512:
-  metadata.gz: be79dffcc14ff47e9333e175a0f6c967c28646045ba35094bde7740903b9d64a44a510c98f47ff676b4baf902c651de7bf4beda8b4e0d69f61bc03411e861b41
-  data.tar.gz: 5340d7f07bd891bc4ac456a576749cffe1cb948df63af61dbe0192e22d92393d4a61b4c3bdb5d642b99446a1af96a48df0d782394728f2b19fda78d4428ef75d
+  metadata.gz: 797b1ac153469a31d1edd1781510bac1ac7c05a7f7b2545de34a48d40540a79fcbffd189c851b85d830f9ca63424a5f9006f1a85915bdd9bd6da01f9fe2da392
+  data.tar.gz: 7133a41ae9da79285993f77ccd32e65ff49c3b3c0d203140c1f3c128bdfa8657c8cd882d435ab180b1bd51811103e3c51f16f8c49ee67150388e11a5062e1448

data/lib/wisco/commands/exec.rb

@@ -4,6 +4,7 @@ require 'workato/cli/exec_command'
 require_relative '../config'
 require_relative '../connector'
 require_relative '../path_utils'
+require_relative '../exec_script'
 
 module Wisco
   module Commands
@@ -54,7 +55,7 @@ module Wisco
             next
           end
 
-          input_files = resolve_input_files(input, fixtures_dir)
+          input_files = resolve_input_files(input, fixtures_dir, debug: debug)
 
           if input_files.empty?
             if %w[pick_lists methods].include?(section)
@@ -71,19 +72,32 @@ module Wisco
           end
 
           input_files.each do |input_file|
-            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)
+            if File.extname(input_file).downcase == '.rb'
+              execute_ruby_script(section, key, input_file, fixtures_dir, target_dir,
+                                  connector_full_path, connection, config,
+                                  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)
+            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)
+            end
           end
         end
       end
 
       # Resolve the list of input files to execute.
       # If an explicit input filename/path is given, use that (relative to fixtures_dir).
-      # Otherwise glob execute_* in fixtures_dir and exclude files still containing the sentinel.
-      def resolve_input_files(input, fixtures_dir)
+      # Otherwise glob execute_*.{json,rb} in fixtures_dir and exclude files still containing
+      # their respective sentinel.
+      #
+      # In debug mode, prints which candidate files were found and which were
+      # skipped (because they still contain a sentinel comment).
+      def resolve_input_files(input, fixtures_dir, debug: false)
         if input
           path = File.absolute_path?(input) ? input : File.join(fixtures_dir, input)
           unless File.exist?(path)
@@ -92,13 +106,28 @@ module Wisco
           end
           [path]
         else
-          Dir.glob(File.join(fixtures_dir, 'execute_*')).select do |f|
-            File.file?(f) && !file_has_sentinel?(f)
+          candidates = Dir.glob(File.join(fixtures_dir, 'execute_*.{json,rb}')).select { |f| File.file?(f) }
+          warn "[exec] candidate files: #{candidates.map { |f| File.basename(f) }}" if debug
+          candidates.reject do |f|
+            if file_has_sentinel?(f)
+              warn "[exec]   skipped (sentinel): #{File.basename(f)}" if debug
+              true
+            else
+              false
+            end
           end
         end
       end
 
+      # Returns true if the file should be skipped. Each input format has its own
+      # sentinel convention:
+      #   .json — first line exactly equals Wisco::Commands::Fixtures::SENTINEL
+      #   .rb   — first non-blank line matches `# WISCO_SKIP`
       def file_has_sentinel?(path)
+        if File.extname(path).downcase == '.rb'
+          return Wisco::ExecScript.sentinel?(path)
+        end
+
         first_line = begin
           File.open(path, &:readline).chomp
         rescue StandardError
@@ -223,6 +252,7 @@ module Wisco
           cmd = Workato::CLI::ExecCommand.new(path: exec_path, options: options)
           cmd.call
         rescue StandardError => e
+          FileUtils.rm_f(output_file)
           File.write(error_file, "#{e.class}: #{e.message}\n\n#{e.backtrace.join("\n")}\n")
           Wisco::TerminalOutput.emit_error("Error executing #{section}.#{key} with #{input_file ? File.basename(input_file) : 'no input'}: #{e.message}")
           Wisco::TerminalOutput.emit_error("  Details written to: #{error_file}")
@@ -237,6 +267,118 @@ module Wisco
         File.write(output_file, pretty + "\n")
         puts "  Written: #{output_file}"
       end
+
+      # Handles `execute_*.rb` scripts: evaluates the script to produce dynamic
+      # input, writes it to <subdir>/input.json, runs the connector item via
+      # ExecCommand, and writes <subdir>/output.json or <subdir>/error.txt.
+      # The subdirectory is named after the script (without .rb), e.g.
+      # execute_input.rb -> execute_input/.
+      def execute_ruby_script(section, key, script_path, fixtures_dir, target_dir,
+                              connector_full_path, connection, config,
+                              pagination: true, verbose: true, debug: false,
+                              extended: true, closure: nil, config_fields: nil, continue: nil,
+                              extended_input_schema: nil, extended_output_schema: nil)
+        subdir      = File.join(fixtures_dir, File.basename(script_path, '.rb'))
+        FileUtils.mkdir_p(subdir)
+        input_file  = File.join(subdir, 'input.json')
+        output_file = File.join(subdir, 'output.json')
+        error_file  = File.join(subdir, 'error.txt')
+
+        # Step 1: evaluate the script to obtain dynamic input
+        connection_name = config['connection'] || 'default'
+
+        begin
+          generated = Wisco::ExecScript.evaluate(
+            script_path:         script_path,
+            connector_full_path: connector_full_path,
+            target_dir:          target_dir,
+            connection_name:     connection_name
+          )
+        rescue StandardError => e
+          FileUtils.rm_f(input_file)
+          FileUtils.rm_f(output_file)
+          File.write(error_file, "#{e.class}: #{e.message}\n\n#{Array(e.backtrace).join("\n")}\n")
+          Wisco::TerminalOutput.emit_error("Error evaluating #{File.basename(script_path)}: #{e.message}")
+          Wisco::TerminalOutput.emit_error("  Details written to: #{error_file}")
+          return
+        end
+
+        File.write(input_file, JSON.pretty_generate(generated) + "\n")
+        puts "  Generated: #{input_file}"
+
+        # Step 2: build ExecCommand options (mirrors execute_one)
+        use_args  = %w[pick_lists methods].include?(section)
+        exec_path = if use_args
+                      "#{section}.#{key}"
+                    elsif section == 'triggers'
+                      pagination ? "#{section}.#{key}.poll" : "#{section}.#{key}.poll_page"
+                    else
+                      "#{section}.#{key}.execute"
+                    end
+
+        options = { connector: connector_full_path, output: output_file }
+        options[:connection] = connection if connection
+        options[:verbose]    = verbose
+        if use_args
+          options[:args] = input_file
+        else
+          options[:input] = input_file
+        end
+
+        options[:closure]       = resolve_option_path(closure,       fixtures_dir) if closure
+        options[:config_fields] = resolve_option_path(config_fields, fixtures_dir) if config_fields
+        options[:continue]      = resolve_option_path(continue,      fixtures_dir) if continue
+
+        # extended schema files still live at the item's fixtures_dir (not the subdir)
+        unless use_args
+          eis = if extended_input_schema
+                  resolve_option_path(extended_input_schema, fixtures_dir)
+                elsif extended
+                  f = File.join(fixtures_dir, 'input_fields.json')
+                  File.exist?(f) ? f : nil
+                end
+          options[:extended_input_schema] = eis if eis
+
+          eos = if extended_output_schema
+                  resolve_option_path(extended_output_schema, fixtures_dir)
+                elsif extended
+                  f = File.join(fixtures_dir, 'output_fields.json')
+                  File.exist?(f) ? f : nil
+                end
+          options[:extended_output_schema] = eos if eos
+        end
+
+        if debug
+          warn "[exec.rb] script:      #{script_path}"
+          warn "[exec.rb] subdir:      #{subdir}"
+          warn "[exec.rb] path:        #{exec_path}"
+          warn "[exec.rb] connector:   #{connector_full_path}"
+          warn "[exec.rb] connection:  #{connection.inspect}"
+          warn "[exec.rb] #{use_args ? 'args' : 'input'}:       #{input_file}"
+          warn "[exec.rb] output:      #{output_file}"
+        end
+
+        # Step 3: invoke ExecCommand against the generated input
+        begin
+          cmd = Workato::CLI::ExecCommand.new(path: exec_path, options: options)
+          cmd.call
+        rescue StandardError => e
+          FileUtils.rm_f(input_file)
+          FileUtils.rm_f(output_file)
+          File.write(error_file, "#{e.class}: #{e.message}\n\n#{e.backtrace.join("\n")}\n")
+          Wisco::TerminalOutput.emit_error("Error executing #{section}.#{key} with #{File.basename(script_path)}: #{e.message}")
+          Wisco::TerminalOutput.emit_error("  Details written to: #{error_file}")
+          return
+        end
+
+        FileUtils.rm_f(error_file)
+
+        return unless File.exist?(output_file)
+
+        pretty = JSON.pretty_generate(JSON.parse(File.read(output_file)))
+        File.write(output_file, pretty + "\n")
+        puts "  Written: #{output_file}"
+      end
     end
   end
 end

data/lib/wisco/commands/fixtures.rb

@@ -8,11 +8,34 @@ require_relative '../path_utils'
 module Wisco
   module Commands
     module Fixtures
-      SENTINEL = '# Remove this comment before updating. Files that include this line will be overwritten.'
+      SENTINEL    = '# Remove this comment before updating. Files that include this line will be overwritten.'
+      RB_SENTINEL = '# WISCO_SKIP'
+
+      RB_TEMPLATE = <<~RUBY
+        # WISCO_SKIP
+        # Remove the WISCO_SKIP line above once this script is ready to run.
+        #
+        # The last expression in this file becomes the input passed to the connector item.
+        # Helper methods available inside the script:
+        #   call_method(:name, *args)     — invoke a methods: entry on the connector
+        #   call_pick_list(:name, *args)  — invoke a pick_lists: entry on the connector
+        #   connection                     — Hash of decrypted settings.yaml(.enc)
+        #
+        # Example:
+        #   require 'securerandom'
+        #   {
+        #     order_number: "ORD-\#{SecureRandom.hex(4).upcase}",
+        #     created_at:   Time.now.iso8601
+        #   }
+
+        {
+          # TODO: fill in fields
+        }
+      RUBY
 
       module_function
 
-      def run(path_arg, target_dir, overwrite: false, debug: false)
+      def run(path_arg, target_dir, overwrite: false, ruby: false, debug: false)
         target_dir = File.expand_path(target_dir)
         config_path = Wisco.config_path(target_dir)
 
@@ -44,8 +67,10 @@ module Wisco
 
           if section == 'pick_lists'
             process_pick_list(key, connector, fixtures_dir, overwrite: overwrite)
+            generate_execute_input_rb(fixtures_dir, overwrite: overwrite) if ruby
           elsif section == 'methods'
             process_method(key, connector, fixtures_dir, overwrite: overwrite)
+            generate_execute_input_rb(fixtures_dir, overwrite: overwrite) if ruby
           else
             # ── config_fields pre-check ──────────────────────────────────────
             item   = connector[section.to_sym]&.[](key.to_sym)
@@ -76,6 +101,7 @@ module Wisco
             )
 
             generate_execute_input(input_fields_file, fixtures_dir, overwrite: overwrite, debug: debug)
+            generate_execute_input_rb(fixtures_dir, overwrite: overwrite) if ruby
 
             # ── output_fields ────────────────────────────────────────────────
             output_fields_file = File.join(fixtures_dir, 'output_fields.json')
@@ -133,6 +159,35 @@ module Wisco
         puts "  Written: #{output_file}"
       end
 
+      # Writes an `execute_input.rb` template into `fixtures_dir`. The template
+      # is prefixed with `# WISCO_SKIP` so it is identifiable as unedited and
+      # will be skipped by `wisco exec` until the user removes that line.
+      #
+      # Overwrite rules mirror generate_execute_input:
+      #   - File absent                       -> write
+      #   - File present, # WISCO_SKIP on L1  -> overwrite (still a template)
+      #   - File present, no sentinel         -> skip (user-edited); force with --overwrite
+      def generate_execute_input_rb(fixtures_dir, overwrite: false)
+        output_file = File.join(fixtures_dir, 'execute_input.rb')
+
+        if File.exist?(output_file)
+          first_line = begin
+            File.open(output_file, &:readline).chomp
+          rescue StandardError
+            ''
+          end
+          has_sentinel = first_line.strip == RB_SENTINEL
+
+          unless has_sentinel || overwrite
+            puts "  Skipped (user-edited): #{output_file}"
+            return
+          end
+        end
+
+        File.write(output_file, RB_TEMPLATE)
+        puts "  Written: #{output_file}"
+      end
+
       # Recursively converts a Workato schema array into a template hash.
       # Scalars become "<type_value_required|optional>" placeholder strings.
       # Objects expand into a nested hash via their properties.

data/lib/wisco/commands/init.rb

@@ -2,22 +2,14 @@ require 'erb'
 require 'fileutils'
 require_relative '../config'
 require_relative '../connector'
+require_relative '../profile'
 
 module Wisco
   module Commands
     module Init
-      HOSTNAMES = [
-        { region: 'US Data Center', hostname: 'www.workato.com'    },
-        { region: 'EU Data Center', hostname: 'app.eu.workato.com' },
-        { region: 'JP Data Center', hostname: 'app.jp.workato.com' },
-        { region: 'SG Data Center', hostname: 'app.sg.workato.com' },
-        { region: 'AU Data Center', hostname: 'app.au.workato.com' },
-        { region: 'IL Data Center', hostname: 'app.il.workato.com' },
-      ].freeze
-
       module_function
 
-      def run(target_dir)
+      def run(target_dir, profile: nil)
         target_dir = File.expand_path(target_dir)
 
         unless Dir.exist?(target_dir)
@@ -46,7 +38,7 @@ module Wisco
         config['connector']['path'] = target_dir
         config['connector']['file'] = connector_file
 
-        prompt_hostname(config)
+        prompt_hostname(config, profile: profile)
 
         Wisco::Config.save_config(config_path, config)
         puts "Config written to #{config_path}"
@@ -56,32 +48,78 @@ module Wisco
         deploy_github_workflow(target_dir, connector_file, config)
       end
 
-      def prompt_hostname(config)
+      def prompt_hostname(config, profile: nil)
         api_cfg = config['workato_developer_api'] ||= {}
-        current = api_cfg['hostname']
 
-        if current && !current.strip.empty?
-          puts "Current Workato hostname: #{current}"
-          print 'Keep this? (y/n): '
-          return if $stdin.gets.strip.downcase == 'y'
+        # --profile flag: skip all prompts and attach the named profile
+        if profile
+          unless Wisco::Profiles.exists?(profile)
+            Wisco::TerminalOutput.emit_error("Error: Profile \"#{profile}\" not found in #{Wisco::Profiles.profiles_path}.")
+            Wisco::TerminalOutput.emit_error("       Run 'wisco profile list' to see available profiles.")
+            exit 1
+          end
+          api_cfg.delete('hostname')
+          api_cfg.delete('api_token')
+          api_cfg['profile'] = profile
+          puts "Using profile: #{profile}"
+          return
         end
 
-        puts 'Select your Workato instance:'
-        HOSTNAMES.each_with_index do |entry, i|
-          puts "  #{i + 1}. #{entry[:hostname]}  (#{entry[:region]})"
-        end
+        # If profiles exist, offer them alongside "enter manually"
+        existing_profiles = Wisco::Profiles.all
+        unless existing_profiles.empty?
+          current_profile = api_cfg['profile'].to_s.strip
+          current_host    = api_cfg['hostname'].to_s.strip
+
+          if !current_profile.empty?
+            puts "Current Workato profile: #{current_profile}"
+            print 'Keep this? (y/n): '
+            return if $stdin.gets.strip.downcase == 'y'
+          elsif !current_host.empty?
+            puts "Current Workato hostname: #{current_host} (inline credentials)"
+            print 'Keep this? (y/n): '
+            return if $stdin.gets.strip.downcase == 'y'
+          end
 
-        loop do
-          print "Enter number (1-#{HOSTNAMES.size}): "
-          input = $stdin.gets.strip
-          index = input.to_i
-          if index >= 1 && index <= HOSTNAMES.size
-            api_cfg['hostname'] = HOSTNAMES[index - 1][:hostname]
-            puts "Hostname set to: #{api_cfg['hostname']}"
-            return
+          puts 'Workato API credentials'
+          name_width = existing_profiles.keys.map(&:length).max
+          existing_profiles.each_with_index do |(prof_name, p), i|
+            puts "  #{i + 1}. #{prof_name.ljust(name_width)}  (#{p['hostname']})"
+          end
+          manual_index = existing_profiles.size + 1
+          puts "  #{manual_index}. Enter credentials manually"
+          loop do
+            print "Select an option (1-#{manual_index}): "
+            input = $stdin.gets.strip
+            index = input.to_i
+            if index >= 1 && index < manual_index
+              chosen = existing_profiles.keys[index - 1]
+              api_cfg.delete('hostname')
+              api_cfg.delete('api_token')
+              api_cfg['profile'] = chosen
+              puts "Using profile: #{chosen}"
+              return
+            elsif index == manual_index
+              break # fall through to manual hostname prompt below
+            else
+              warn "Invalid selection. Please enter a number between 1 and #{manual_index}."
+            end
+          end
+        else
+          # No profiles — check for existing inline hostname
+          current = api_cfg['hostname']
+          if current && !current.strip.empty?
+            puts "Current Workato hostname: #{current}"
+            print 'Keep this? (y/n): '
+            return if $stdin.gets.strip.downcase == 'y'
           end
-          warn "Invalid selection. Please enter a number between 1 and #{HOSTNAMES.size}."
         end
+
+        # Manual hostname selection
+        hostname = Wisco::Profiles.prompt_hostname_selection
+        api_cfg.delete('profile')
+        api_cfg['hostname'] = hostname
+        puts "Hostname set to: #{hostname}"
       end
 
       def update_gitignore(target_dir)
@@ -128,7 +166,12 @@ module Wisco
           end
         end
 
-        hostname         = config.dig('workato_developer_api', 'hostname')
+        api_cfg  = config['workato_developer_api'] || {}
+        hostname = if api_cfg['profile'].to_s.strip != ''
+                     Wisco::Profiles.get(api_cfg['profile'])&.dig('hostname')
+                   else
+                     api_cfg['hostname']
+                   end
         workato_base_url = "https://#{hostname}"
         connector_name   = connector_file
 

data/lib/wisco/commands/profile.rb

@@ -0,0 +1,236 @@
+require_relative '../profile'
+require_relative '../config'
+require_relative '../terminal_output'
+
+module Wisco
+  module Commands
+    class Profile < Thor
+      def self.exit_on_failure?
+        true
+      end
+
+      desc 'add [NAME]', 'Create a new connection profile'
+      long_desc <<~DESC
+        Prompts for hostname and API token and saves a named profile in ~/.wisco/profiles.yaml.
+        If NAME is omitted, a name is suggested based on the selected datacenter.
+      DESC
+      def add(name = nil)
+        hostname = Wisco::Profiles.prompt_hostname_selection
+        puts "Hostname: #{hostname}"
+
+        api_token = Wisco::Profiles.prompt_token('API token (input hidden): ')
+
+        if name.nil?
+          suggestion = Wisco::Profiles.suggest_name(hostname)
+          name = Wisco::Profiles.prompt_name(suggestion: suggestion)
+        end
+
+        if Wisco::Profiles.exists?(name)
+          Wisco::TerminalOutput.emit_error("Error: Profile \"#{name}\" already exists. Use 'wisco profile edit #{name}' to update it.")
+          exit 1
+        end
+
+        Wisco::Profiles.set(name, hostname, api_token)
+        puts "Profile \"#{name}\" saved to #{Wisco::Profiles.profiles_path}."
+      end
+
+      desc 'list', 'List all connection profiles'
+      def list
+        profiles = Wisco::Profiles.all
+        if profiles.empty?
+          puts "No profiles found. Run 'wisco profile add' to create one."
+          return
+        end
+        puts "Profiles (from #{Wisco::Profiles.profiles_path}):\n\n"
+        name_width = profiles.keys.map(&:length).max
+        profiles.each do |prof_name, p|
+          puts "  #{prof_name.ljust(name_width)}  #{p['hostname']}"
+        end
+      end
+
+      desc 'show NAME', 'Show details of a profile'
+      def show(name)
+        profile = Wisco::Profiles.get(name)
+        if profile.nil?
+          Wisco::TerminalOutput.emit_error("Error: Profile \"#{name}\" not found.")
+          Wisco::TerminalOutput.emit_error("       Run 'wisco profile list' to see available profiles.")
+          exit 1
+        end
+        puts "Profile: #{name}"
+        puts "  hostname:  #{profile['hostname']}"
+        puts "  api_token: #{Wisco::Profiles.mask_token(profile['api_token'])}"
+      end
+
+      desc 'edit NAME', 'Update the hostname and/or API token for a profile'
+      long_desc 'Re-prompts for hostname and API token. Press Enter to keep the current value.'
+      def edit(name)
+        profile = Wisco::Profiles.get(name)
+        if profile.nil?
+          Wisco::TerminalOutput.emit_error("Error: Profile \"#{name}\" not found.")
+          Wisco::TerminalOutput.emit_error("       Run 'wisco profile list' to see available profiles.")
+          exit 1
+        end
+
+        puts "Editing profile \"#{name}\":"
+        puts "  Current hostname:  #{profile['hostname']}"
+        puts "  Current api_token: #{Wisco::Profiles.mask_token(profile['api_token'])}"
+        puts
+
+        selected = Wisco::Profiles.prompt_hostname_selection(allow_skip: true)
+        hostname = selected || profile['hostname']
+        puts "Hostname: #{hostname}"
+
+        raw = Wisco::Profiles.prompt_token('New API token (input hidden, Enter to keep current): ')
+        api_token = raw.empty? ? profile['api_token'] : raw
+
+        Wisco::Profiles.set(name, hostname, api_token)
+        puts "Profile \"#{name}\" updated."
+      end
+
+      desc 'remove NAME', 'Remove a connection profile'
+      def remove(name)
+        unless Wisco::Profiles.exists?(name)
+          Wisco::TerminalOutput.emit_error("Error: Profile \"#{name}\" not found.")
+          exit 1
+        end
+        print "Remove profile \"#{name}\"? (y/n): "
+        unless $stdin.gets.strip.downcase == 'y'
+          puts 'Aborted.'
+          return
+        end
+        Wisco::Profiles.delete(name)
+        puts "Profile \"#{name}\" removed."
+      end
+
+      desc 'use NAME', 'Attach a profile to the current connector project'
+      def use(name)
+        unless Wisco::Profiles.exists?(name)
+          Wisco::TerminalOutput.emit_error("Error: Profile \"#{name}\" not found in #{Wisco::Profiles.profiles_path}.")
+          Wisco::TerminalOutput.emit_error("       Run 'wisco profile list' to see available profiles.")
+          exit 1
+        end
+
+        config_path = Wisco.config_path(Dir.pwd)
+        unless File.exist?(config_path)
+          Wisco::TerminalOutput.emit_error("Error: No #{Wisco::WISCO_DIR}/#{Wisco::CONFIG_FILENAME} found in #{Dir.pwd}.")
+          Wisco::TerminalOutput.emit_error("       Run 'wisco init' first.")
+          exit 1
+        end
+
+        config  = Wisco::Config.load_config(config_path)
+        api_cfg = config['workato_developer_api'] ||= {}
+        has_inline = !api_cfg['hostname'].to_s.strip.empty? || !api_cfg['api_token'].to_s.strip.empty?
+
+        if has_inline
+          print "This project has inline credentials configured.\nReplace with a reference to profile \"#{name}\"? (y/n): "
+          unless $stdin.gets.strip.downcase == 'y'
+            puts 'Aborted.'
+            return
+          end
+          api_cfg.delete('hostname')
+          api_cfg.delete('api_token')
+        end
+
+        api_cfg['profile'] = name
+        Wisco::Config.save_config(config_path, config)
+        puts "Project config updated to use profile \"#{name}\"."
+      end
+
+      desc 'extract [NAME]', "Save this project's inline credentials as a named profile"
+      long_desc <<~DESC
+        Reads the inline hostname and api_token from this project's .wisco/config.json,
+        saves them as a named profile in ~/.wisco/profiles.yaml, then updates config.json
+        to reference the profile instead of storing inline credentials.
+
+        If NAME is omitted, a name is suggested based on the project's configured hostname.
+      DESC
+      def extract(name = nil)
+        config_path = Wisco.config_path(Dir.pwd)
+        unless File.exist?(config_path)
+          Wisco::TerminalOutput.emit_error("Error: No #{Wisco::WISCO_DIR}/#{Wisco::CONFIG_FILENAME} found in #{Dir.pwd}.")
+          Wisco::TerminalOutput.emit_error("       Run 'wisco init' first.")
+          exit 1
+        end
+
+        config    = Wisco::Config.load_config(config_path)
+        api_cfg   = config['workato_developer_api'] || {}
+        hostname  = api_cfg['hostname'].to_s.strip
+        api_token = api_cfg['api_token'].to_s.strip
+
+        if hostname.empty? || api_token.empty?
+          Wisco::TerminalOutput.emit_error('Error: This project does not have inline credentials to extract.')
+          Wisco::TerminalOutput.emit_error("       Use 'wisco profile use <name>' to attach an existing profile.")
+          exit 1
+        end
+
+        duplicate = Wisco::Profiles.find_duplicate(hostname, api_token)
+        if duplicate
+          puts "A profile with these credentials already exists: #{duplicate} (#{hostname})"
+          print 'Reference existing profile instead of creating a new one? (y/n): '
+          if $stdin.gets.strip.downcase == 'y'
+            api_cfg.delete('hostname')
+            api_cfg.delete('api_token')
+            api_cfg['profile'] = duplicate
+            Wisco::Config.save_config(config_path, config)
+            puts "Project config updated to reference profile \"#{duplicate}\"."
+            return
+          end
+        end
+
+        if name.nil?
+          suggestion = Wisco::Profiles.suggest_name(hostname)
+          name = Wisco::Profiles.prompt_name(suggestion: suggestion)
+        end
+
+        if Wisco::Profiles.exists?(name)
+          Wisco::TerminalOutput.emit_error("Error: Profile \"#{name}\" already exists. Choose a different name or use 'wisco profile edit #{name}'.")
+          exit 1
+        end
+
+        Wisco::Profiles.set(name, hostname, api_token)
+        puts "Profile \"#{name}\" created in #{Wisco::Profiles.profiles_path}."
+
+        api_cfg.delete('hostname')
+        api_cfg.delete('api_token')
+        api_cfg['profile'] = name
+        Wisco::Config.save_config(config_path, config)
+        puts "Project config updated to reference profile \"#{name}\"."
+      end
+
+      desc 'current', 'Show which profile or credentials this project is using'
+      def current
+        config_path = Wisco.config_path(Dir.pwd)
+        unless File.exist?(config_path)
+          Wisco::TerminalOutput.emit_error("Error: No #{Wisco::WISCO_DIR}/#{Wisco::CONFIG_FILENAME} found in #{Dir.pwd}.")
+          Wisco::TerminalOutput.emit_error("       Run 'wisco init' first.")
+          exit 1
+        end
+
+        config    = Wisco::Config.load_config(config_path)
+        api_cfg   = config['workato_developer_api'] || {}
+        prof_name = api_cfg['profile'].to_s.strip
+        hostname  = api_cfg['hostname'].to_s.strip
+        api_token = api_cfg['api_token'].to_s.strip
+
+        if !prof_name.empty?
+          profile = Wisco::Profiles.get(prof_name)
+          if profile.nil?
+            Wisco::TerminalOutput.emit_error("This project references profile \"#{prof_name}\" which does not exist.")
+            Wisco::TerminalOutput.emit_error("Run 'wisco profile list' to see available profiles.")
+            exit 1
+          end
+          puts "This project uses profile: #{prof_name}"
+          puts "  hostname:  #{profile['hostname']}"
+          puts "  api_token: #{Wisco::Profiles.mask_token(profile['api_token'])}"
+        elsif !hostname.empty?
+          puts 'This project uses inline credentials (no profile).'
+          puts "  hostname:  #{hostname}"
+          puts "  api_token: #{Wisco::Profiles.mask_token(api_token)}"
+        else
+          puts 'This project has no Workato API credentials configured.'
+          puts "Run 'wisco init' or 'wisco profile use <name>' to configure."
+        end
+      end
+    end
+  end
+end

data/lib/wisco/config.rb

@@ -2,10 +2,32 @@ module Wisco
   module Config
     module_function
 
-    # Ensures workato_developer_api hostname and api_token are present in config.
-    # Prompts the user for any missing values and saves the updated config.
+    # Ensures workato_developer_api hostname and api_token are available in config.
+    # Resolves profile references, handles conflicts, and prompts for missing inline values.
+    # When a profile is used, credentials are injected into the in-memory config so all
+    # callers can continue to use config.dig('workato_developer_api', 'hostname') etc.
     def ensure_api_config(config, config_path)
-      api_cfg = config['workato_developer_api'] ||= {}
+      api_cfg     = config['workato_developer_api'] ||= {}
+      has_profile = !api_cfg['profile'].to_s.strip.empty?
+      has_inline  = !api_cfg['hostname'].to_s.strip.empty? && !api_cfg['api_token'].to_s.strip.empty?
+
+      if has_profile && has_inline
+        resolve_profile_conflict(api_cfg, config, config_path)
+        has_profile = !api_cfg['profile'].to_s.strip.empty?
+      end
+
+      if has_profile
+        profile_name = api_cfg['profile']
+        profile      = Wisco::Profiles.get(profile_name)
+        if profile.nil?
+          Wisco::TerminalOutput.emit_error("Error: Profile \"#{profile_name}\" not found in #{Wisco::Profiles.profiles_path}.")
+          Wisco::TerminalOutput.emit_error("       Run 'wisco profile list' to see available profiles.")
+          exit 1
+        end
+        api_cfg['hostname']  = profile['hostname']
+        api_cfg['api_token'] = profile['api_token']
+        return config
+      end
 
       if api_cfg['hostname'].nil? || api_cfg['hostname'].strip.empty?
         print 'Workato API hostname not configured. Enter hostname (e.g. app.au.workato.com): '
@@ -21,6 +43,34 @@ module Wisco
       config
     end
 
+    def resolve_profile_conflict(api_cfg, config, config_path)
+      Wisco::TerminalOutput.emit_warning('Warning: This project has both a profile reference and inline credentials.')
+      puts "  Profile:  #{api_cfg['profile']}"
+      puts "  Hostname: #{api_cfg['hostname']}"
+      puts
+      puts 'Which should be kept?'
+      puts "  1. Profile reference (\"#{api_cfg['profile']}\")"
+      puts '  2. Inline credentials'
+      loop do
+        print 'Enter 1 or 2: '
+        case $stdin.gets.strip
+        when '1'
+          api_cfg.delete('hostname')
+          api_cfg.delete('api_token')
+          save_config(config_path, config)
+          puts "Inline credentials removed. Using profile \"#{api_cfg['profile']}\"."
+          return
+        when '2'
+          api_cfg.delete('profile')
+          save_config(config_path, config)
+          puts 'Profile reference removed. Using inline credentials.'
+          return
+        else
+          warn 'Please enter 1 or 2.'
+        end
+      end
+    end
+
     def load_config(path)
       return {} unless File.exist?(path)
 

data/lib/wisco/exec_script.rb

@@ -0,0 +1,160 @@
+require 'workato/connector/sdk'
+require_relative 'terminal_output'
+
+module Wisco
+  # Evaluates an `execute_*.rb` script and returns the value of its last
+  # expression. The script is eval'd inside a binding that exposes helpers
+  # (`call_method`, `call_pick_list`, `connection`) so the script can build
+  # dynamic input that varies per run.
+  module ExecScript
+    SENTINEL_REGEX = /\A\s*#\s*WISCO_SKIP\b/.freeze
+
+    module_function
+
+    # Returns true if the file's first non-blank line is a `# WISCO_SKIP`
+    # comment, in which case the script should be skipped by `wisco exec`.
+    def sentinel?(path)
+      File.foreach(path) do |line|
+        stripped = line.strip
+        next if stripped.empty?
+        return SENTINEL_REGEX.match?(line)
+      end
+      false
+    rescue StandardError
+      false
+    end
+
+    # Evaluates the script at `script_path` and returns the value of its last
+    # expression. Raises StandardError subclasses on:
+    #   - syntax / runtime errors in the script
+    #   - invalid return value (must be a Hash or Array)
+    #
+    # `connector_full_path` — absolute path to connector.rb (used to build
+    #                          the SDK Connector for helper invocations).
+    # `target_dir`          — connector project root (used to find
+    #                          settings.yaml(.enc) + master.key).
+    # `connection_name`     — connection key inside settings.yaml; defaults to 'default'.
+    def evaluate(script_path:, connector_full_path:, target_dir:, connection_name: 'default')
+      host   = ScriptHost.new(connector_full_path, target_dir, connection_name)
+      source = File.read(script_path)
+      result = host.instance_eval(source, script_path, 1)
+
+      unless result.is_a?(Hash) || result.is_a?(Array)
+        raise InvalidReturn,
+              "Script must return a Hash (for actions/triggers) or Array/Hash (for methods/pick_lists). " \
+              "Got: #{result.class}"
+      end
+
+      result
+    end
+
+    class InvalidReturn < StandardError; end
+
+    # Host object that the script is eval'd against. Exposes the helper API.
+    # Defined as a class (not a Module) so `instance_eval` gives the script
+    # access to standard top-level Ruby plus our helpers, without polluting
+    # Object globally.
+    class ScriptHost
+      def initialize(connector_full_path, target_dir, connection_name)
+        @connector_full_path = connector_full_path
+        @target_dir          = target_dir
+        @connection_name     = connection_name || 'default'
+        @sdk_connector       = nil
+        @connection_loaded   = false
+        @connection_cached   = nil
+        @warned_settings     = false
+      end
+
+      # Hash of decrypted settings for the configured connection. Returns {}
+      # and emits a one-time warning if settings can't be loaded.
+      def connection
+        return @connection_cached if @connection_loaded
+
+        @connection_loaded = true
+        @connection_cached = load_connection
+      end
+
+      # Invoke a connector `methods:` entry. Args are forwarded to the lambda
+      # as-is. Returns the lambda's return value.
+      #
+      # Example:
+      #   call_method(:format_timestamp, Time.now)
+      def call_method(name, *args)
+        proxy = sdk_connector.methods
+        unless proxy.respond_to?(name.to_sym)
+          raise InvalidReturn, "No methods entry named '#{name}' found in connector."
+        end
+        proxy.public_send(name.to_sym, *args)
+      end
+
+      # Invoke a connector `pick_lists:` entry. `args` is a Hash of named
+      # arguments for dependent pick lists. The SDK supplies `connection` to
+      # the lambda automatically.
+      #
+      # Examples:
+      #   call_pick_list(:active_customers)
+      #   call_pick_list(:customer_orders, customer_id: 123)
+      def call_pick_list(name, **args)
+        proxy = sdk_connector.pick_lists
+        unless proxy.respond_to?(name.to_sym)
+          raise InvalidReturn, "No pick_lists entry named '#{name}' found in connector."
+        end
+        # SDK signature: pick_list_name(settings = nil, args = {})
+        # Passing nil for settings tells the SDK to reuse the connector's settings.
+        proxy.public_send(name.to_sym, nil, args)
+      end
+
+      private
+
+      def sdk_connector
+        @sdk_connector ||= Workato::Connector::Sdk::Connector.from_file(@connector_full_path, connection)
+      end
+
+      # Tries (in order): settings.yaml.enc + master.key, then settings.yaml.
+      # Uses Workato::Connector::Sdk::Settings so encryption is handled by the
+      # SDK's own loader (same path it uses for `wisco exec`). Returns {} and
+      # warns once on any failure.
+      def load_connection
+        enc_file  = File.join(@target_dir, 'settings.yaml.enc')
+        key_file  = File.join(@target_dir, 'master.key')
+        yaml_file = File.join(@target_dir, 'settings.yaml')
+
+        if File.exist?(enc_file) && File.exist?(key_file)
+          read_settings(enc_file) do |name|
+            Workato::Connector::Sdk::Settings.from_encrypted_file(enc_file, key_file, name)
+          end
+        elsif File.exist?(yaml_file)
+          read_settings(yaml_file) do |name|
+            Workato::Connector::Sdk::Settings.from_file(yaml_file, name)
+          end
+        else
+          warn_settings("No settings.yaml or settings.yaml.enc found in #{@target_dir}")
+          {}
+        end
+      end
+
+      # Reads settings using a Settings.from_* loader. Tries with the configured
+      # connection name first; if that key isn't present at the top level
+      # (KeyError), falls back to loading the whole file as a flat hash.
+      def read_settings(path)
+        hash = begin
+                 yield(@connection_name)
+               rescue KeyError
+                 yield(nil)
+               end
+        return {} unless hash.respond_to?(:to_h)
+
+        hash.to_h
+      rescue StandardError => e
+        warn_settings("Failed to load settings from #{path}: #{e.message}")
+        {}
+      end
+
+      def warn_settings(msg)
+        return if @warned_settings
+        @warned_settings = true
+        Wisco::TerminalOutput.emit_warning("[WARN] connection helper: #{msg}. Returning {}.")
+      end
+    end
+  end
+end

data/lib/wisco/profile.rb

@@ -0,0 +1,137 @@
+require 'yaml'
+require 'fileutils'
+require 'io/console'
+
+module Wisco
+  module Profiles
+    PROFILES_DIR      = File.join(Dir.home, '.wisco').freeze
+    PROFILES_FILENAME = 'profiles.yaml'.freeze
+
+    HOSTNAMES = [
+      { region: 'US Data Center', hostname: 'www.workato.com'    },
+      { region: 'EU Data Center', hostname: 'app.eu.workato.com' },
+      { region: 'JP Data Center', hostname: 'app.jp.workato.com' },
+      { region: 'SG Data Center', hostname: 'app.sg.workato.com' },
+      { region: 'AU Data Center', hostname: 'app.au.workato.com' },
+      { region: 'IL Data Center', hostname: 'app.il.workato.com' },
+    ].freeze
+
+    DATACENTER_NAMES = {
+      'www.workato.com'    => 'us',
+      'app.eu.workato.com' => 'eu',
+      'app.jp.workato.com' => 'jp',
+      'app.sg.workato.com' => 'sg',
+      'app.au.workato.com' => 'au',
+      'app.il.workato.com' => 'il',
+    }.freeze
+
+    module_function
+
+    def profiles_path
+      File.join(PROFILES_DIR, PROFILES_FILENAME)
+    end
+
+    def load_profiles
+      return {} unless File.exist?(profiles_path)
+
+      YAML.safe_load(File.read(profiles_path)) || {}
+    rescue Psych::SyntaxError => e
+      Wisco::TerminalOutput.emit_error("Error: Could not parse #{profiles_path}: #{e.message}")
+      exit 1
+    end
+
+    def save_profiles(data)
+      FileUtils.mkdir_p(PROFILES_DIR)
+      File.write(profiles_path, YAML.dump(data))
+    rescue SystemCallError => e
+      Wisco::TerminalOutput.emit_error("Error: Could not write #{profiles_path}: #{e.message}")
+      exit 1
+    end
+
+    def all
+      load_profiles.dig('workato_developer_api') || {}
+    end
+
+    def get(name)
+      all[name]
+    end
+
+    def set(name, hostname, api_token)
+      data = load_profiles
+      data['workato_developer_api'] ||= {}
+      data['workato_developer_api'][name] = { 'hostname' => hostname, 'api_token' => api_token }
+      save_profiles(data)
+    end
+
+    def delete(name)
+      data = load_profiles
+      data['workato_developer_api']&.delete(name)
+      save_profiles(data)
+    end
+
+    def exists?(name)
+      !get(name).nil?
+    end
+
+    def find_duplicate(hostname, api_token)
+      all.find { |_n, p| p['hostname'] == hostname && p['api_token'] == api_token }&.first
+    end
+
+    def suggest_name(hostname)
+      DATACENTER_NAMES[hostname]
+    end
+
+    def mask_token(token)
+      return '****' if token.nil? || token.length <= 4
+
+      "****#{token[-4..]}"
+    end
+
+    def prompt_token(prompt_text = 'API token (input hidden): ')
+      print prompt_text
+      token = $stdin.noecho(&:gets).strip
+      puts
+      token
+    rescue Errno::ENOTTY
+      # stdin is not a tty (e.g. piped input) — read plainly
+      print prompt_text
+      $stdin.gets.strip
+    end
+
+    def prompt_hostname_selection(allow_skip: false)
+      puts 'Select your Workato instance:'
+      HOSTNAMES.each_with_index do |entry, i|
+        puts "  #{i + 1}. #{entry[:hostname]}  (#{entry[:region]})"
+      end
+      skip_hint = allow_skip ? ', or Enter to keep current' : ''
+      loop do
+        print "Enter number (1-#{HOSTNAMES.size})#{skip_hint}: "
+        input = $stdin.gets.strip
+        return nil if allow_skip && input.empty?
+
+        index = input.to_i
+        if index >= 1 && index <= HOSTNAMES.size
+          return HOSTNAMES[index - 1][:hostname]
+        end
+
+        warn "Invalid selection. Please enter a number between 1 and #{HOSTNAMES.size}."
+      end
+    end
+
+    def prompt_name(suggestion: nil)
+      if suggestion
+        print "Profile name [#{suggestion}]: "
+        input = $stdin.gets.strip
+        input.empty? ? suggestion : input
+      else
+        loop do
+          print 'Profile name: '
+          input = $stdin.gets.strip
+          return input unless input.empty?
+
+          warn 'Name cannot be blank.'
+        end
+      end
+    end
+  end
+end

data/lib/wisco/version.rb

@@ -1,3 +1,3 @@
 module Wisco
-  VERSION = '0.3.5'
+  VERSION = '0.3.7'
 end

data/lib/wisco.rb

@@ -15,6 +15,7 @@ module Wisco
 end
 
 require_relative 'wisco/config'
+require_relative 'wisco/profile'
 require_relative 'wisco/connector'
 require_relative 'wisco/commands/init'
 require_relative 'wisco/commands/list'
@@ -23,6 +24,7 @@ require_relative 'wisco/commands/fixtures'
 require_relative 'wisco/commands/pull'
 require_relative 'wisco/commands/push'
 require_relative 'wisco/commands/schema'
+require_relative 'wisco/commands/profile'
 
 module Wisco
   class CLI < Thor
@@ -53,8 +55,9 @@ module Wisco
 
     desc 'init [PATH]', "Detect connector and initialise #{WISCO_DIR}/"
     long_desc "Searches PATH (default: current directory) for a valid connector file and writes #{WISCO_DIR}/#{CONFIG_FILENAME}."
+    option :profile, type: :string, desc: 'Attach a named connection profile instead of entering credentials manually'
     def init(path = nil)
-      Wisco::Commands::Init.run(path || Dir.pwd)
+      Wisco::Commands::Init.run(path || Dir.pwd, profile: options[:profile])
     end
 
     desc 'list [SUBCOMMAND] [PATH]', 'Show connector structure'
@@ -124,12 +127,15 @@ module Wisco
         get_users           auto-detect section
     DESC
     option :overwrite, type: :boolean, default: false, desc: 'Overwrite execute_input.json even if user-edited'
+    option :ruby,      type: :boolean, default: false,
+                       desc: 'Also scaffold an execute_input.rb template for dynamic input scripts'
     option :debug,     type: :boolean, default: false, desc: 'Print ExecCommand call details'
     def fixtures(path_arg, target_dir = nil)
       Wisco::Commands::Fixtures.run(
         path_arg,
         target_dir || Dir.pwd,
         overwrite: options[:overwrite],
+        ruby:      options[:ruby],
         debug:     options[:debug]
       )
     end
@@ -179,6 +185,20 @@ module Wisco
       )
     end
 
+    desc 'profile SUBCOMMAND ...ARGS', 'Manage connection profiles (~/.wisco/profiles.yaml)'
+    long_desc <<~DESC
+      Subcommands:
+        add [NAME]     Create a new profile
+        list           List all profiles
+        show NAME      Show profile details
+        edit NAME      Update a profile's hostname or API token
+        remove NAME    Remove a profile
+        use NAME       Attach a profile to this connector project
+        extract [NAME] Save this project's inline credentials as a profile
+        current        Show which profile this project is using
+    DESC
+    subcommand 'profile', Wisco::Commands::Profile
+
     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.3.5
+  version: 0.3.7
 platform: ruby
 authors:
 - mbillington
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-06 00:00:00.000000000 Z
+date: 2026-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -71,12 +71,15 @@ files:
 - lib/wisco/commands/fixtures.rb
 - lib/wisco/commands/init.rb
 - lib/wisco/commands/list.rb
+- lib/wisco/commands/profile.rb
 - lib/wisco/commands/pull.rb
 - lib/wisco/commands/push.rb
 - lib/wisco/commands/schema.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/terminal_output.rb
 - lib/wisco/version.rb
 - lib/wisco/workato_api.rb