wisco 0.3.4 → 0.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce64641188dfbd354a2279042c813975e03a309f78e289b8d1fc72a33e748d6f
-  data.tar.gz: c3b602c65d2a4c7e8eb45664a063c863834978309d8e831d81b316f245eb62ad
+  metadata.gz: dc712af30ea2647f51bf72fac2bcf59f57105efcd8382d831afcadceee912f5c
+  data.tar.gz: b49f08a071f353521d09469452e8508e31b78f4108545b6e723083e816ecc67d
 SHA512:
-  metadata.gz: 7960efd667edfc41ada2e9ec7e646004e83f81270a12669ba2281b25c1d9f6d179da449137b811f616f9c413e8273bf973cf74bf0f3dbfeafe2e85cbc8980048
-  data.tar.gz: 688ee858d3d5245d41e0c78dbfd5766b3d6e82561f052af3a7726e343f9b64cbf7113d81fe72cf11e745dd9b75480d7a4d4ffca6e5fd4eb806286f5e1eac3841
+  metadata.gz: 4029281c6717dc8eeef9b9b3d86018998c5846dea82d5703d10229b84bf990c8beb6d8c73928315804878b8c9ab6a5bc541b9e46b34ddef7d601c2590e354331
+  data.tar.gz: 7a4161111ce339ffe212cacdd08365f9464b79d02a729b492e04925ed2d2a9f10687fdcd79d0eef0fcadc321cf37c9a5fb05eca57f63f3d7da747b3438204e14

data/lib/wisco/assets/.gitignore

@@ -4,7 +4,9 @@
 # Workato SDK files
 master.key
 
-# Exclude error files from fixtures
+# wisco fixtures
+fixtures/connection/test/output_test.json
+fixtures/actions/*/execute*.json 
 fixtures/*/*/error*.txt
 
 # Exclude local working data

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/commands/schema.rb

@@ -0,0 +1,214 @@
+require 'rest-client'
+require 'json'
+require_relative '../config'
+require_relative '../terminal_output'
+
+module Wisco
+  module Commands
+    module Schema
+      API_GENERATE_SCHEMA_PATH = '/api/sdk/generate_schema'
+      KEY_ORDER                = %w[name label type of control_type convert_input convert_output].freeze
+      SYMBOL_VALUE_KEYS        = %w[type of].freeze
+
+      module_function
+
+      def run(input_file, target_dir, format:, ruby_options:, col_sep:, output:, debug:)
+        input_file = File.expand_path(input_file)
+        target_dir = File.expand_path(target_dir)
+
+        unless File.exist?(input_file)
+          Wisco::TerminalOutput.emit_error("Error: Input file not found: #{input_file}")
+          exit 1
+        end
+
+        ext = File.extname(input_file).downcase
+        unless %w[.json .csv].include?(ext)
+          Wisco::TerminalOutput.emit_error("Error: Unsupported file type '#{ext}'. Must be .json or .csv.")
+          exit 1
+        end
+
+        config_path = Wisco.config_path(target_dir)
+        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::CLI_NAME} init' first.")
+          exit 1
+        end
+
+        config    = Wisco::Config.load_config(config_path)
+        config    = Wisco::Config.ensure_api_config(config, config_path)
+        hostname  = config.dig('workato_developer_api', 'hostname')
+        api_token = config.dig('workato_developer_api', 'api_token')
+
+        schema = fetch_schema(input_file, hostname, api_token, col_sep: col_sep, debug: debug)
+
+        formatted = if format == 'json'
+                      format_json(schema)
+                    else
+                      format_ruby(schema, style: ruby_options.to_sym)
+                    end
+
+        output_path = resolve_output_path(output, input_file, format)
+
+        if output_path
+          File.write(output_path, formatted + "\n")
+          puts "Written: #{output_path}"
+        else
+          puts formatted
+        end
+      end
+
+      # Resolves the output file path from the --output option value.
+      #   nil    → no --output flag; return nil (print to stdout)
+      #   ''     → --output with no value; derive from input_file + format
+      #   other  → explicit path; expand and use as-is
+      def resolve_output_path(output, input_file, format)
+        return nil if output.nil?
+
+        if output.empty?
+          file_ext = format == 'json' ? '.json' : '.rb'
+          dir      = File.dirname(input_file)
+          base     = File.basename(input_file, '.*')
+          File.join(dir, "#{base}.schema#{file_ext}")
+        else
+          File.expand_path(output)
+        end
+      end
+
+      # ── API call ──────────────────────────────────────────────────────────
+
+      def fetch_schema(input_file, hostname, api_token, col_sep:, debug:)
+        ext    = File.extname(input_file).delete_prefix('.')  # 'json' or 'csv'
+        url    = "https://#{hostname}#{API_GENERATE_SCHEMA_PATH}/#{ext}"
+        sample = File.read(input_file)
+        sample = wrap_if_array(sample) if ext == 'json'
+
+        payload = { sample: sample }
+        payload[:col_sep] = col_sep if ext == 'csv'
+
+        if debug
+          warn "[schema] url:     #{url}"
+          warn "[schema] col_sep: #{col_sep}" if ext == 'csv'
+        end
+
+        response = RestClient.post(
+          url,
+          payload.to_json,
+          content_type:    :json,
+          accept:          :json,
+          'Authorization' => "Bearer #{api_token}"
+        )
+        JSON.parse(response.body)
+      rescue RestClient::ExceptionWithResponse => e
+        msg = begin
+                JSON.parse(e.response.body)['message']
+              rescue StandardError
+                e.message
+              end
+        Wisco::TerminalOutput.emit_error("Error generating schema: #{msg}")
+        exit 1
+      rescue StandardError => e
+        Wisco::TerminalOutput.emit_error("Error generating schema: #{e.message}")
+        exit 1
+      end
+
+      # If the JSON content is a top-level array, wrap it in {"input": [...]}
+      # so the Workato API accepts it (it requires a top-level object).
+      # Returns the (possibly modified) JSON string; never modifies the source file.
+      def wrap_if_array(json_content)
+        parsed = JSON.parse(json_content)
+        return json_content unless parsed.is_a?(Array)
+
+        Wisco::TerminalOutput.emit_info('[INFO] Input JSON is a top-level array.')
+        Wisco::TerminalOutput.emit_info('[INFO] Wrapping in {"input": [...]} for Workato API compatibility.')
+        JSON.generate({ 'input' => parsed })
+      rescue JSON::ParseError
+        json_content  # unparseable — send as-is and let the API report the error
+      end
+
+      # ── JSON output ───────────────────────────────────────────────────────
+
+      def format_json(schema)
+        JSON.pretty_generate(schema)
+      end
+
+      # ── Ruby output ───────────────────────────────────────────────────────
+
+      # Renders the top-level schema array as a Ruby literal.
+      def format_ruby(schema, style:)
+        indent = 4
+        items  = schema.map { |field| format_field(field, indent, style) }
+        inner  = items.map { |item| "#{' ' * indent}#{item}" }.join(",\n")
+        "[\n#{inner}\n]"
+      end
+
+      # Renders a single field hash. Recursively handles nested `properties`.
+      def format_field(field, base_indent, style)
+        # Reorder keys: KEY_ORDER first, then any extras; pull properties out separately
+        ordered = KEY_ORDER.select { |k| field.key?(k) }
+        extras  = field.keys - KEY_ORDER - ['properties']
+        pairs   = (ordered + extras).map { |k| [k, field[k]] }
+        props   = field['properties']
+
+        cont_indent = base_indent + 2  # continuation indent (aligns keys after "{ ")
+        prop_indent = base_indent + 4  # properties array indent
+
+        if style == :single_line
+          kv_str = pairs.map { |k, v| "#{k}: #{ruby_scalar(k, v)}" }.join(', ')
+
+          if props
+            prop_lines = format_ruby_array(props, prop_indent, style)
+            "{ #{kv_str}, properties:\n#{prop_lines}\n#{' ' * base_indent}}"
+          else
+            "{ #{kv_str}}"
+          end
+        else
+          # multi_line: first pair on same line as {, rest on new lines
+          kv_lines = pairs.map { |k, v| "#{k}: #{ruby_scalar(k, v)}" }
+          first    = kv_lines.shift
+
+          if kv_lines.empty? && !props
+            # Single pair, no properties
+            "{ #{first}}"
+          elsif props
+            rest      = kv_lines.map { |l| "#{' ' * cont_indent}#{l}" }
+            prop_line = "#{' ' * cont_indent}properties:"
+            prop_lines = format_ruby_array(props, prop_indent, style)
+            parts = ["{ #{first}"] + rest + [prop_line]
+            "#{parts.join(",\n")}\n#{prop_lines}\n#{' ' * base_indent}}"
+          else
+            rest  = kv_lines.map { |l| "#{' ' * cont_indent}#{l}" }
+            parts = ["{ #{first}"] + rest
+            "#{parts.join(",\n")}}"
+          end
+        end
+      end
+
+      # Renders a properties array (a list of nested fields) at the given indent.
+      # The opening/closing brackets sit at `indent` spaces; items are indented
+      # a further 4 spaces inside the brackets.
+      def format_ruby_array(fields, indent, style)
+        item_indent = indent + 4
+        items = fields.map { |f| format_field(f, item_indent, style) }
+        inner = items.map { |item| "#{' ' * item_indent}#{item}" }.join(",\n")
+        "#{' ' * indent}[\n#{inner}\n#{' ' * indent}]"
+      end
+
+      # Returns the Ruby literal string for a scalar value.
+      def ruby_scalar(key, value)
+        if SYMBOL_VALUE_KEYS.include?(key) && value.is_a?(String)
+          ":#{value}"
+        elsif value.is_a?(String)
+          "'#{value.gsub('\\', '\\\\\\\\').gsub("'", "\\\\'")}'"
+        elsif value.nil?
+          'nil'
+        elsif value == true || value == false
+          value.to_s
+        elsif value.is_a?(Numeric)
+          value.to_s
+        else
+          value.inspect
+        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/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.4'
+  VERSION = '0.3.6'
 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'
@@ -22,6 +23,8 @@ require_relative 'wisco/commands/exec'
 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
@@ -52,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'
@@ -177,5 +181,51 @@ module Wisco
         debug: options[:debug]
       )
     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.
+      File type is auto-detected from the extension (.json or .csv).
+      Output defaults to Ruby hash format; use --format=json for raw JSON.
+
+      Requires workato_developer_api hostname and api_token in #{WISCO_DIR}/#{CONFIG_FILENAME}.
+      If not set, you will be prompted on first run.
+    DESC
+    option :format,        type: :string,  default: 'ruby',       enum: %w[ruby json],
+                           desc: 'Output format: ruby (default) or json'
+    option :ruby_options,  type: :string,  default: 'multi_line', enum: %w[single_line multi_line],
+                           desc: 'Ruby output style: single_line or multi_line (default)'
+    option :'col-sep',     type: :string,  default: 'comma',
+                           enum: %w[comma space tab colon semicolon pipe],
+                           desc: 'CSV column separator (default: comma)'
+    option :save,          type: :string,  lazy_default: '',
+                           desc: 'Save output to file. Omit value to auto-name from input file ' \
+                                 '(e.g. input.json → input.schema.rb / input.schema.json)'
+    option :debug,         type: :boolean, default: false,         desc: 'Show API call details'
+    def schema(input_file, target_dir = nil)
+      Wisco::Commands::Schema.run(
+        input_file,
+        target_dir || Dir.pwd,
+        format:       options[:format],
+        ruby_options: options[:ruby_options],
+        col_sep:      options[:col_sep],
+        output:       options[:save],
+        debug:        options[:debug]
+      )
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wisco
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.3.6
 platform: ruby
 authors:
 - mbillington
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-05-28 00:00:00.000000000 Z
+date: 2026-06-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -71,11 +71,14 @@ 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/path_utils.rb
+- lib/wisco/profile.rb
 - lib/wisco/terminal_output.rb
 - lib/wisco/version.rb
 - lib/wisco/workato_api.rb