wisco 0.1.7

data/lib/wisco/commands/pull.rb

@@ -0,0 +1,176 @@
+require 'fileutils'
+require 'base64'
+require 'json'
+require_relative '../config'
+require_relative '../connector'
+require_relative '../workato_api'
+
+module Wisco
+  module Commands
+    module Pull
+      VALID_WHAT   = %w[all logo code versions meta].freeze
+      LOGO_FILENAME = 'logo.png'.freeze
+      VERSION_KEYS = %w[latest_version latest_version_note latest_released_version
+                        latest_released_version_note latest_shared_version
+                        latest_shared_version_note oem_shared_version
+                        oem_shared_at recent_released_versions].freeze
+
+      module_function
+
+      def run(target_dir, what:, title:, debug:)
+        target_dir  = File.expand_path(target_dir)
+        config_path = Wisco.config_path(target_dir)
+
+        unless File.exist?(config_path)
+          warn "Error: No #{Wisco::WISCO_DIR}/#{Wisco::CONFIG_FILENAME} found in #{target_dir}."
+          warn "       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)
+        what_list = parse_what(what)
+        title   ||= derive_title(target_dir)
+
+        pull_dir = File.join(target_dir, Wisco::WISCO_DIR, 'pull')
+        FileUtils.mkdir_p(pull_dir)
+
+        api = Wisco::WorkatoApi.new(
+          hostname:  config.dig('workato_developer_api', 'hostname'),
+          api_token: config.dig('workato_developer_api', 'api_token'),
+          debug:     debug
+        )
+
+        datetime = Time.now.localtime.strftime('%Y%m%d_%H%M%S')
+
+        # Step 1: Search
+        warn "[pull] Searching for connector: #{title}" if debug
+        status, search_data, raw_body = api.search_connector(title: title)
+        handle_http_error(status, 'search', title, body: raw_body)
+
+        connector   = extract_single(search_data, title)
+        maybe_save_title(connector, config, config_path)
+        search_file = File.join(pull_dir, 'meta.json')
+        write_json(search_file, search_data)
+        puts "Meta:        \t#{search_file}"
+
+        # Logo
+        if what_list.include?('logo') || what_list.include?('all')
+          connector_root = config.dig('connector', 'path')
+          root_logo      = File.join(connector_root, LOGO_FILENAME)
+          if File.exist?(root_logo)
+            logo_file = save_logo(pull_dir, connector['logo'])
+            puts "Logo:        \t#{logo_file}" if logo_file
+            puts "               (saved to pull dir — #{LOGO_FILENAME} already exists in connector root)"
+          else
+            logo_file = save_logo(connector_root, connector['logo'])
+            puts "Logo:        \t#{logo_file}" if logo_file
+          end
+        end
+
+        # Versions
+        if what_list.include?('versions') || what_list.include?('all')
+          versions_file = save_versions(pull_dir, connector)
+          puts "Versions:    \t#{versions_file}"
+        end
+
+        # Code
+        if what_list.include?('code') || what_list.include?('all')
+          warn "[pull] Fetching code for id=#{connector['id']}" if debug
+          status, code_data, raw_body = api.get_connector_code(id: connector['id'])
+          handle_http_error(status, 'code', connector['id'], body: raw_body)
+
+          rb_file = File.join(pull_dir, "#{connector['name']}.rb")
+          File.write(rb_file, code_data.dig('data', 'code').to_s)
+          puts "Code:        \t#{rb_file}"
+        end
+      end
+
+      # ── helpers ──────────────────────────────────────────────────────────
+
+      def derive_title(target_dir)
+        connector = Wisco::Connector.load_connector_from_config(target_dir)
+        title = connector[:title]
+        if title.nil? || title.strip.empty?
+          warn "Error: Could not derive connector title from connector file."
+          warn "       Use --title to specify it explicitly."
+          exit 1
+        end
+        title
+      end
+
+      def parse_what(what_str)
+        values  = what_str.to_s.split(',').map(&:strip).map(&:downcase)
+        invalid = values - VALID_WHAT
+        unless invalid.empty?
+          warn "Error: Invalid --what value(s): #{invalid.join(', ')}"
+          warn "       Valid values: #{VALID_WHAT.join(', ')}"
+          exit 1
+        end
+        values
+      end
+
+      def extract_single(data, title)
+        results = case data
+                  when Hash  then Array(data['data'] || data)
+                  when Array then data
+                  else []
+                  end
+
+        if results.empty?
+          warn "Error: No connector found matching '#{title}'."
+          warn "       Check the title and try again, or use --title with a different value."
+          exit 1
+        end
+
+        if results.size > 1
+          warn "Error: Multiple connectors matched '#{title}':"
+          results.each { |r| warn "  - #{r['title']} (id: #{r['id']}, name: #{r['name']})" }
+          warn "       Use --title with a more specific name."
+          exit 1
+        end
+
+        results.first
+      end
+
+      def handle_http_error(status, context, identifier, body: nil)
+        return if status == 200
+
+        warn "Error: #{context} request failed for '#{identifier}' (HTTP #{status})."
+        warn "       Response body: #{body}" unless body.nil? || body.strip.empty?
+        exit 1
+      end
+
+      def save_logo(pull_dir, base64_logo)
+        return nil if base64_logo.nil? || base64_logo.strip.empty?
+
+        logo_file = File.join(pull_dir, LOGO_FILENAME)
+        File.binwrite(logo_file, Base64.decode64(base64_logo))
+        logo_file
+      end
+
+      def save_versions(pull_dir, connector)
+        versions      = connector.select { |k, _| VERSION_KEYS.include?(k) }
+        versions_file = File.join(pull_dir, 'versions.json')
+        write_json(versions_file, versions)
+        versions_file
+      end
+
+      def maybe_save_title(connector, config, config_path)
+        stored = config.dig('connector', 'title')
+        return unless stored.nil? || stored.strip.empty?
+
+        api_title = connector['title']
+        return unless api_title && !api_title.strip.empty?
+
+        config['connector'] ||= {}
+        config['connector']['title'] = api_title
+        Wisco::Config.save_config(config_path, config)
+      end
+
+      def write_json(path, data)
+        File.write(path, JSON.pretty_generate(data) + "\n")
+      end
+    end
+  end
+end

data/lib/wisco/commands/push.rb

@@ -0,0 +1,129 @@
+require 'workato/cli/push_command'
+require_relative '../config'
+require_relative '../connector'
+
+module Wisco
+  module Commands
+    module Push
+      REQUIRED_ASSETS = [
+        ->(connector_path, connector_file) { File.join(connector_path, connector_file) },
+        ->(connector_path, _)              { File.join(connector_path, 'logo.png') },
+        ->(connector_path, _)              { File.join(connector_path, 'README.md') }
+      ].freeze
+
+      module_function
+
+      def run(target_dir, title:, notes:, folder:, verbose:, debug:)
+        target_dir  = File.expand_path(target_dir)
+        config_path = Wisco.config_path(target_dir)
+
+        unless File.exist?(config_path)
+          warn "Error: No #{Wisco::WISCO_DIR}/#{Wisco::CONFIG_FILENAME} found in #{target_dir}."
+          warn "       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)
+
+        connector_path = config.dig('connector', 'path')
+        connector_file = config.dig('connector', 'file')
+
+        if connector_path.nil? || connector_file.nil?
+          warn "Error: #{Wisco::WISCO_DIR}/#{Wisco::CONFIG_FILENAME} is missing connector path/file. Run '#{Wisco::CLI_NAME} init' again."
+          exit 1
+        end
+
+        # Check all required assets exist before attempting the push
+        check_assets(connector_path, connector_file)
+
+        # Resolve title — save to config if obtained from option or prompt
+        title = resolve_title(title, config, config_path, target_dir)
+
+        # Resolve notes — prompt if not provided via --notes
+        notes = resolve_notes(notes)
+
+        options = {
+          environment: "https://#{config.dig('workato_developer_api', 'hostname')}",
+          api_token:   config.dig('workato_developer_api', 'api_token'),
+          connector:   connector_file,
+          title:       title,
+          notes:       notes,
+          verbose:     verbose
+        }
+        options[:folder] = folder if folder
+
+        if debug
+          warn "[push] environment: #{options[:environment]}"
+          warn "[push] connector:   #{options[:connector]}"
+          warn "[push] title:       #{options[:title]}"
+          warn "[push] notes:       #{options[:notes]}"
+          warn "[push] folder:      #{folder.inspect}"
+          warn "[push] verbose:     #{verbose}"
+        end
+
+        Dir.chdir(connector_path) do
+          Workato::CLI::PushCommand.new(options: options).call
+        end
+      end
+
+      # ── helpers ──────────────────────────────────────────────────────────
+
+      def check_assets(connector_path, connector_file)
+        missing = REQUIRED_ASSETS
+                  .map { |fn| fn.call(connector_path, connector_file) }
+                  .reject { |path| File.exist?(path) }
+
+        return if missing.empty?
+
+        missing.each { |path| warn "Error: Required asset not found: #{path}" }
+        exit 1
+      end
+
+      def resolve_title(title, config, config_path, target_dir)
+        # 1. Explicit --title option
+        if title
+          save_title(title, config, config_path)
+          return title
+        end
+
+        # 2. Stored in config
+        stored = config.dig('connector', 'title')
+        return stored if stored && !stored.strip.empty?
+
+        # 3. From connector code
+        connector = Wisco::Connector.load_connector_from_config(target_dir)
+        code_title = connector[:title]
+        return code_title if code_title && !code_title.strip.empty?
+
+        # 4. Prompt user
+        print 'Connector title not found. Enter a title: '
+        title = $stdin.gets.strip
+        if title.empty?
+          warn 'Error: A connector title is required.'
+          exit 1
+        end
+        save_title(title, config, config_path)
+        title
+      end
+
+      def save_title(title, config, config_path)
+        config['connector'] ||= {}
+        config['connector']['title'] = title
+        Wisco::Config.save_config(config_path, config)
+      end
+
+      def resolve_notes(notes)
+        return notes if notes && !notes.strip.empty?
+
+        loop do
+          print 'Version notes (required): '
+          value = $stdin.gets.strip
+          return value unless value.empty?
+
+          warn 'Version notes cannot be blank.'
+        end
+      end
+    end
+  end
+end

data/lib/wisco/config.rb

@@ -0,0 +1,43 @@
+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.
+    def ensure_api_config(config, config_path)
+      api_cfg = config['workato_developer_api'] ||= {}
+
+      if api_cfg['hostname'].nil? || api_cfg['hostname'].strip.empty?
+        print 'Workato API hostname not configured. Enter hostname (e.g. app.au.workato.com): '
+        api_cfg['hostname'] = $stdin.gets.strip
+      end
+
+      if api_cfg['api_token'].nil? || api_cfg['api_token'].strip.empty?
+        print 'Workato API token not configured. Enter your API token: '
+        api_cfg['api_token'] = $stdin.gets.strip
+      end
+
+      save_config(config_path, config)
+      config
+    end
+
+    def load_config(path)
+      return {} unless File.exist?(path)
+
+      begin
+        JSON.parse(File.read(path))
+      rescue JSON::ParserError => e
+        warn "Warning: Existing #{Wisco::WISCO_DIR}/#{Wisco::CONFIG_FILENAME} contains invalid JSON (#{e.message})."
+        warn '         Connector section will be overwritten; other content may be lost.'
+        {}
+      end
+    end
+
+    def save_config(path, config)
+      File.write(path, JSON.pretty_generate(config) + "\n")
+    rescue SystemCallError => e
+      warn "Error: Could not write #{Wisco::WISCO_DIR}/#{Wisco::CONFIG_FILENAME}: #{e.message}"
+      exit 1
+    end
+  end
+end

data/lib/wisco/connector.rb

@@ -0,0 +1,91 @@
+require_relative 'config'
+
+module Wisco
+  module Connector
+    module_function
+
+    def detect_connector(dir)
+      candidates = candidate_files(dir)
+
+      if candidates.empty?
+        warn "  No .rb files found in #{dir}"
+        return nil
+      end
+
+      candidates.each do |filename|
+        puts "  Checking #{filename}..."
+        return filename if valid_connector?(File.join(dir, filename))
+      end
+
+      nil
+    end
+
+    def load_connector_from_config(target_dir)
+      target_dir = File.expand_path(target_dir)
+      config_path = Wisco.config_path(target_dir)
+
+      unless File.exist?(config_path)
+        warn "Error: No #{Wisco::WISCO_DIR}/#{Wisco::CONFIG_FILENAME} found in #{target_dir}."
+        warn "       Run '#{Wisco::CLI_NAME} init' first."
+        exit 1
+      end
+
+      config = Wisco::Config.load_config(config_path)
+      connector_file = config.dig('connector', 'file')
+      connector_path = config.dig('connector', 'path')
+
+      if connector_file.nil? || connector_path.nil?
+        warn "Error: #{Wisco::WISCO_DIR}/#{Wisco::CONFIG_FILENAME} is missing connector path/file. Run '#{Wisco::CLI_NAME} init' again."
+        exit 1
+      end
+
+      full_path = File.join(connector_path, connector_file)
+      unless File.exist?(full_path)
+        warn "Error: Connector file not found: #{full_path}"
+        exit 1
+      end
+
+      code = File.read(full_path)
+      original_verbose = $VERBOSE
+      $VERBOSE = nil
+      begin
+        result = eval(code) # rubocop:disable Security/Eval
+      rescue Exception => e
+        raise "\nConnector contains errors:\n#{e.message}"
+        warn "Error: Failed to load connector: #{e.message}"
+        exit 1
+      ensure
+        $VERBOSE = original_verbose
+      end
+
+      result
+    end
+
+    def candidate_files(dir)
+      primary = 'connector.rb'
+      others = Dir.glob(File.join(dir, '*.rb'))
+                  .map { |f| File.basename(f) }
+                  .reject { |f| f == primary }
+                  .sort
+
+      result = []
+      result << primary if File.exist?(File.join(dir, primary))
+      result.concat(others)
+      result
+    end
+
+    def valid_connector?(path)
+      code = File.read(path)
+      original_verbose = $VERBOSE
+      $VERBOSE = nil
+      begin
+        result = eval(code) # rubocop:disable Security/Eval
+        result.is_a?(Hash) && result.key?(:title)
+      rescue Exception => e
+        false
+      ensure
+        $VERBOSE = original_verbose
+      end
+    end
+  end
+end

data/lib/wisco/path_utils.rb

@@ -0,0 +1,57 @@
+module Wisco
+  module PathUtils
+    VALID_SECTIONS = %w[actions triggers].freeze
+
+    module_function
+
+    # Returns an array of [section, key] pairs derived from path_arg.
+    #
+    # Accepted forms:
+    #   "section.key"  — one specific key in a known section
+    #   "section"      — all keys in that section
+    #   "key"          — auto-detect section; error if found in both or neither
+    def parse_path(path_arg, connector)
+      parts = path_arg.split('.', 2)
+
+      if parts.size == 2
+        section, key = parts
+        unless VALID_SECTIONS.include?(section)
+          warn "Error: Invalid section '#{section}'. Valid sections: #{VALID_SECTIONS.join(', ')}."
+          exit 1
+        end
+        items = connector[section.to_sym]
+        unless items&.key?(key.to_sym)
+          warn "Error: '#{key}' not found in #{section}."
+          exit 1
+        end
+        [[section, key]]
+
+      elsif VALID_SECTIONS.include?(path_arg)
+        section = path_arg
+        items = connector[section.to_sym]
+        if items.nil? || items.empty?
+          warn "Error: No keys found in #{section}."
+          exit 1
+        end
+        items.keys.map { |k| [section, k.to_s] }
+
+      else
+        key = path_arg
+        in_actions  = connector[:actions]&.key?(key.to_sym)  || false
+        in_triggers = connector[:triggers]&.key?(key.to_sym) || false
+
+        case [in_actions, in_triggers]
+        when [true, false]  then [['actions',  key]]
+        when [false, true]  then [['triggers', key]]
+        when [true, true]
+          warn "Error: '#{key}' exists in both actions and triggers."
+          warn "       Qualify with section, e.g. 'actions.#{key}'."
+          exit 1
+        else
+          warn "Error: '#{key}' not found in actions or triggers."
+          exit 1
+        end
+      end
+    end
+  end
+end

data/lib/wisco/version.rb

@@ -0,0 +1,3 @@
+module Wisco
+  VERSION = '0.1.7'
+end

data/lib/wisco/workato_api.rb

@@ -0,0 +1,75 @@
+require 'net/http'
+require 'uri'
+require 'cgi'
+require 'json'
+
+module Wisco
+  class WorkatoApi
+    def initialize(hostname:, api_token:, debug: false)
+      @hostname  = hostname
+      @api_token = api_token
+      @debug     = debug
+    end
+
+    # Returns [status_int, parsed_hash_or_nil, raw_body_string]
+    def search_connector(title:)
+      request(:get, '/api/custom_connectors/search', params: { title: title })
+    end
+
+    def get_connector_code(id:)
+      request(:get, "/api/custom_connectors/#{id}/code")
+    end
+
+    private
+
+    def request(_method, path, params: nil, body: nil)
+      # Use URI only for host/port; build path+query as a raw string so
+      # Net::HTTP sends it without any re-encoding by the URI class.
+      base_uri   = URI("https://#{@hostname}")
+      query      = params.map { |k, v| "#{k}=#{v.to_s.gsub(' ', '%20')}" }.join('&') if params
+      request_path = query ? "#{path}?#{query}" : path
+
+      req = Net::HTTP::Get.new(request_path)
+      req['Authorization'] = "Bearer #{@api_token}"
+      req['Accept']        = '*/*'
+      req['User-Agent']    = 'wisco'
+      if body
+        req['Content-Type'] = 'application/json'
+        req.body = body.to_json
+      end
+
+      if @debug
+        warn "[api] → GET https://#{@hostname}#{request_path}"
+        warn "[api]   Authorization: Bearer #{masked_token}"
+        warn "[api]   Accept: */*"
+        warn "[api]   User-Agent: wisco"
+        warn "[api]   Content-Type: application/json" if body
+        warn "[api]   Body: #{req.body}" if body
+      end
+
+      http         = Net::HTTP.new(base_uri.host, base_uri.port)
+      http.use_ssl = true
+      resp         = http.request(req)
+      raw_body     = resp.body.to_s
+
+      if @debug
+        warn "[api] ← #{resp.code} #{resp.message}"
+        warn "[api]   Body: #{raw_body}"
+      end
+
+      begin
+        parsed = JSON.parse(raw_body)
+      rescue JSON::ParserError
+        parsed = nil
+      end
+      [resp.code.to_i, parsed, raw_body]
+    end
+
+    def masked_token
+      return '(empty)' if @api_token.nil? || @api_token.empty?
+
+      visible = [@api_token.length, 6].min
+      "#{@api_token[0, visible]}..."
+    end
+  end
+end