factor 0.5.15 → 0.5.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 569dc92eda75eb91dfaaacba2fdfdee5087137ed
-  data.tar.gz: c379ed9d1349d42aff4ee6705b7afecffba8a787
+  metadata.gz: 3df70093d41d893436a8b43a6d08f4ffe87249fb
+  data.tar.gz: 8b163aa8f9b1ebe4c9ddaf8c24f67d28917c2e10
 SHA512:
-  metadata.gz: 8eab23ca046a13ae752b270059d71c07b6b52870724c813d1550afe30f4631138a7e5b8686c47163a849ac72e5dceb79cde1441f5127da6945d7fd7218ac02bf
-  data.tar.gz: 9537cbbc57f1ce1ce52f353d4eb0c25dda422b570b1474c071fbf90bffc916f7b8e8dc3118fc5f7d91a3bd4adf0a1677d3c75cc021902e77ab8e0e87e115abb1
+  metadata.gz: 0e1d4fa2b2775bc2d34bc43acc8bed86f518d0b1865a56647679536454e1e0c52f0ee20db18d5cae137b256e4fafd8cf8f85b8c4c282eef88117482638c519cb
+  data.tar.gz: 29e9b70bf5ccf70e7cf1292c7ec4e8f11377c4a6efb1a96dc84c8b4939372a53151d486d73f9ee5464ee60b9a503f290b54ea56500101a240143f036d7ee6f87

data/lib/commands/base.rb

@@ -0,0 +1,123 @@
+# encoding: UTF-8
+
+require 'colored'
+require 'configatron'
+require 'yaml'
+require 'fileutils'
+
+module Factor
+  module Commands
+    # Base command with common methods used by all commands
+    class Command
+      DEFAULT_FILENAME = {
+        connectors:   File.expand_path('./connectors.yml'),
+        credentials:  File.expand_path('./credentials.yml')
+      }
+
+      attr_accessor :destination_stream
+
+      def info(options = {})
+        log_line :info, options
+      end
+
+      def error(options = {})
+        log_line :error, options
+      end
+
+      def warn(options = {})
+        log_line :warn, options
+      end
+
+      def success(options = {})
+        log_line :success, options
+      end
+
+      def exception(message, exception)
+        error 'message' => message
+        error 'message' => "  #{exception.message}"
+        exception.backtrace.each do |line|
+          error 'message' => "    #{line}"
+        end
+      end
+
+      def load_config(options = {})
+        load_config_data :credentials, options
+        load_config_data :connectors, options
+      end
+
+      def save_config(options={})
+        credentials_relative_path = options[:credentials] || DEFAULT_FILENAME[:credentials]
+        credentials_absolute_path = File.expand_path(credentials_relative_path)
+        connectors_relative_path = options[:connectors] || DEFAULT_FILENAME[:connectors]
+        connectors_absolute_path = File.expand_path(connectors_relative_path)
+
+        connectors  = Hash[stringify(configatron.connectors.to_h).sort]
+        credentials = Hash[stringify(configatron.credentials.to_h).sort]
+
+        File.write(connectors_absolute_path,YAML.dump(connectors))
+        File.write(credentials_absolute_path,YAML.dump(credentials))
+      end
+
+      private
+
+      def stringify(hash)
+        hash.inject({}) do |options, (key, value)|
+          options[key.to_s] = value.is_a?(Hash) ? stringify(value) : value
+          options
+        end
+      end
+
+      def load_config_data(config_type, options = {})
+        relative_path = options[config_type] || DEFAULT_FILENAME[config_type]
+        absolute_path = File.expand_path(relative_path)
+        begin
+          data = YAML.load(File.read(absolute_path))
+        rescue
+          data = {}
+        end
+        configatron[config_type].configure_from_hash(data)
+      rescue => ex
+        exception "Couldn't load #{config_type} from #{absolute_path}", ex
+      end
+
+      def log_line(section, options = {})
+        options       = { message: options } if options.is_a?(String)
+        tag           = tag(options)
+        message       = options['message'] || options[:message]
+        section_text  = format_section(section)
+        write "[ #{section_text} ] [#{time}]#{tag} #{message}" if message
+      end
+
+      def format_section(section)
+        formated_section = section.to_s.upcase.center(10)
+        case section
+        when :error then formated_section.red
+        when :info then formated_section.bold
+        when :warn then formated_section.yellow
+        when :success then formated_section.green
+        else formated_section
+        end
+      end
+
+      def tag(options)
+        primary = options['service_id'] || options['instance_id']
+        secondary = if options['service_id'] && options['instance_id']
+                      ":#{options['instane_id']}"
+                    else
+                      ''
+                    end
+        primary ? "[#{primary}#{secondary}]" : ''
+      end
+
+      def time
+        Time.now.localtime.strftime('%m/%d/%y %T.%L')
+      end
+
+      def write(message)
+        stream = @destination_stream || $stdout
+        stream.puts(message)
+        stream.flush
+      end
+    end
+  end
+end

data/lib/commands/registry.rb

@@ -0,0 +1,186 @@
+# encoding: UTF-8
+
+require 'yaml'
+require 'rest-client'
+require 'erubis'
+require 'json'
+
+require 'commands/base'
+
+module Factor
+  module Commands
+    # Workflow is a Command to start the factor runtime from the CLI
+    class Registry < Factor::Commands::Command
+
+      def workflows(args, options)
+        list = get_yaml_data 'https://raw.githubusercontent.com/factor-io/index/master/workflows.yml'
+
+        list.each do |id, values|
+          puts "#{values['name'].bold} (#{id}): #{values['description']}"
+        end
+      end
+
+      def connectors(args, options)
+        list = get_yaml_data 'https://raw.githubusercontent.com/factor-io/index/master/connectors.yml'
+
+        list.each do |id, values|
+          puts "#{values['name'].bold} (#{id})"
+        end
+      end
+
+      def add_connector(args, options)
+        puts "Workflow ID is required (factor registry connector add --help)".red unless args[0]
+
+        setup_connector args[0].to_s, options if args[0]
+      end
+
+      def add_workflow(args, options)
+        begin
+          list          = get_yaml_data 'https://raw.githubusercontent.com/factor-io/index/master/workflows.yml'
+        rescue
+          puts "Couldn't connect to the server to get connector information".red
+          exit
+        end
+
+        unless args[0]
+          puts "Workflow ID is required".red
+          exit
+        end
+
+        begin
+          workflow_id   = args[0].to_s
+          workflow_info = list[workflow_id]
+          config_url    = workflow_info['config']
+          workflow_name = workflow_info['name']
+        rescue
+          puts "Couldn't find information for #{workflow_id}".red
+          exit
+        end
+
+        load_config(credentials:options.credentials, connectors:options.connectors)
+
+        begin
+          config = get_json_data(config_url)
+        rescue
+          puts "Couldn't pull up configuration information from #{config_url}".red
+          exit
+        end
+
+        if !config['required-connectors'] || !config['required-connectors'].is_a?(Array) || !config['variables'] || !config['variables'].is_a?(Hash)
+          puts "Configuration information for the workflow is missing information"
+          exit
+        end
+
+        config['required-connectors'].each do |connector_id|
+          if configatron.credentials.to_hash[connector_id.to_sym]
+            puts "#{connector_id} already configured".green
+          else
+            setup_connector(connector_id,options)
+          end
+        end
+
+        variables = {}
+        config['variables'].each do |var_id,var_info|
+          puts var_info['description'] if var_info['description']
+          values = begin
+            JSON.parse(options.values)
+          rescue 
+            {}
+          end
+          variables[var_id] = values[var_id]
+          variables[var_id] ||= ask("#{var_info['name'].bold}#{' (optional)' if var_info['optional']}: ").to_s
+        end
+
+        begin
+          template = RestClient.get(config['template'])
+        rescue
+          puts "Couldn't find a template at #{config['template']}".red
+          exit
+        end
+
+        begin
+          eruby = Erubis::Eruby.new(template)
+          workflow_content = eruby.result(variables)
+        rescue
+          puts "Failed to generate template".red
+          exit
+        end
+
+        workflow_filename = "workflow-#{workflow_id}.rb"
+        begin
+          File.write(workflow_filename, workflow_content)
+        rescue
+          puts "Failed to write the file to disk. Check permissions.".red
+          exit
+        end
+
+
+        puts "Created #{workflow_name} successfully".green
+      end
+    
+      private
+
+      def setup_connector(connector_id, options)
+        begin
+          list = get_yaml_data 'https://raw.githubusercontent.com/factor-io/index/master/connectors.yml'
+        rescue
+          puts "Couldn't connect to the server to get connector information".red
+          exit
+        end
+
+
+        begin
+          connector_info = list[connector_id]
+          connector_name = connector_info['name']
+          new_connectors = connector_info['connectors']
+          required_credentials = connector_info['credentials']
+        rescue
+          puts "Couldn't find information for '#{connector_id}'".red
+          exit
+        end
+
+        unless connector_name && new_connectors && required_credentials
+          puts "Couldn't find information for '#{connector_id}'".red
+          exit
+        end
+
+        load_config(credentials:options.credentials, connectors:options.connectors)
+        connectors =  configatron.connectors.to_hash
+        credentials = configatron.credentials.to_hash
+        
+        connectors[connector_id] = new_connectors
+        
+        required_credentials.each do |credential_id, credential_info|
+          puts credential_info['description'] if credential_info['description']
+          credentials[connector_id] ||= {}
+          values = begin
+            JSON.parse(options.values)
+          rescue 
+            {}
+          end
+          credentials[connector_id][credential_id.to_s] = values[credential_id.to_s]
+          credentials[connector_id][credential_id.to_s] ||= ask("#{connector_name.bold} #{credential_info['name'].bold}#{' (optional)' if credential_info['optional']}: ").to_s
+        end
+
+        configatron[:credentials].configure_from_hash(credentials)
+        configatron[:connectors].configure_from_hash(connectors)
+
+        save_config(credentials:options.credentials, connectors:options.connectors)
+
+        puts "Setup #{connector_name} successfully".green
+      end
+
+      def get_yaml_data(url)
+        raw_content = RestClient.get(url)
+        list = YAML.parse(raw_content).to_ruby
+        list
+      end
+
+      def get_json_data(url)
+        raw_content = RestClient.get(url)
+        data = JSON.parse(raw_content)
+        data
+      end
+    end
+  end
+end

data/lib/commands/workflows.rb

@@ -0,0 +1,112 @@
+# encoding: UTF-8
+
+require 'configatron'
+
+require 'commands/base'
+require 'runtime'
+
+module Factor
+  module Commands
+    # Workflow is a Command to start the factor runtime from the CLI
+    class Workflow < Factor::Commands::Command
+      def initialize
+        @workflows = {}
+      end
+
+      def server(_args, options)
+        config_settings = {}
+        config_settings[:credentials] = options.credentials
+        config_settings[:connectors]  = options.connectors
+        workflow_filename = File.expand_path(options.path || '.')
+        @destination_stream = File.new(options.log, 'w+') if options.log
+
+        load_config(config_settings)
+        load_all_workflows(workflow_filename)
+        block_until_interupt
+        log_message 'status' => 'info', 'message' => 'Good bye!'
+      end
+
+      private
+
+      def load_all_workflows(workflow_filename)
+        glob_ending = workflow_filename[-1] == '/' ? '' : '/'
+        glob = "#{workflow_filename}#{glob_ending}*.rb"
+        file_list = Dir.glob(glob)
+        if !file_list.all? { |file| File.file?(file) }
+          error "#{workflow_filename} is neither a file or directory"
+        elsif file_list.count == 0
+          error 'No workflows in this directory to run'
+        else
+          file_list.each { |filename| load_workflow(filename) }
+        end
+      end
+
+      def block_until_interupt
+        log_message 'status' => 'info', 'message' => 'Ctrl-c to exit'
+        begin
+          loop do
+            sleep 1
+          end
+        rescue Interrupt
+          log_message 'status' => 'info', 'message' => 'Exiting app...'
+        ensure
+          @workflows.keys.each { |filename| unload_workflow(filename) }
+        end
+      end
+
+      def load_workflow(filename)
+        workflow_filename = File.expand_path(filename)
+        log_message(
+          'status' => 'info',
+          'message' =>  "Loading workflow from #{workflow_filename}")
+        begin
+          workflow_definition = File.read(workflow_filename)
+        rescue => ex
+          exception "Couldn't read file #{workflow_filename}", ex
+          return
+        end
+
+        log_message(
+          'status' => 'info',
+          'message' =>  'Setting up workflow processor')
+        begin
+          connector_settings = configatron.connectors.to_hash
+          credential_settings = configatron.credentials.to_hash
+          runtime = Runtime.new(connector_settings, credential_settings)
+          runtime.logger = method(:log_message)
+        rescue => ex
+          message = "Couldn't setup workflow process for #{workflow_filename}"
+          exception message, ex
+        end
+
+        @workflows[workflow_filename] = fork do
+          begin
+            log_message(
+              'status' => 'info',
+              'message' => "Starting #{workflow_filename}")
+            runtime.load(workflow_definition)
+          rescue => ex
+            exception "Couldn't load #{workflow_filename}", ex
+          end
+        end
+      end
+
+      def unload_workflow(filename)
+        workflow_filename = File.expand_path(filename)
+        log_message(
+          'status' => 'info',
+          'message' =>  "Stopping #{workflow_filename}")
+        Process.kill('SIGINT', @workflows[workflow_filename])
+      end
+
+      def log_message(message_info)
+        case message_info['status']
+        when 'info' then info message_info
+        when 'success' then success message_info
+        when 'warn' then warn message_info
+        else error message_info
+        end
+      end
+    end
+  end
+end

data/lib/factor.rb

@@ -0,0 +1,54 @@
+# encoding: UTF-8
+
+require 'commander/import'
+
+require 'factor/version'
+require 'commands/workflows'
+require 'commands/registry'
+
+program :name, 'Factor.io Server'
+program :version, Factor::VERSION
+program :description, 'Factor.io Server to run workflows'
+
+command 'server' do |c|
+  c.syntax = 'factor server [options]'
+  c.description = 'Start the Factor.io Server in the current local directory'
+  c.option '--log FILE', String, 'Log file path. Default is stdout.'
+  c.option '--credentials FILE', String, 'credentials.yml file path.'
+  c.option '--connectors FILE', String, 'connectors.yml file path'
+  c.option '--path FILE', String, 'Path to workflows'
+  c.when_called Factor::Commands::Workflow, :server
+end
+
+command 'registry workflows' do |c|
+  c.syntax = 'factor registry workflows'
+  c.description = 'Get list of available workflow jumpstarts'
+  c.when_called Factor::Commands::Registry, :workflows
+end
+
+command 'registry workflows add' do |c|
+  c.syntax = 'factor registry workflow add <id>'
+  c.description = 'Get list of available workflows'
+  c.option '--credentials FILE', String, 'credentials.yml file path.'
+  c.option '--connectors FILE', String, 'connectors.yml file path'
+  c.option '--values \'{"api_key":"foo"}\'', String, "{}"
+  c.when_called Factor::Commands::Registry, :add_workflow
+end
+
+command 'registry connectors' do |c|
+  c.syntax = 'factor registry connectors'
+  c.description = 'Get list of available connectors'
+  c.when_called Factor::Commands::Registry, :connectors
+end
+
+command 'registry connector add' do |c|
+  c.syntax = 'factor registry connector add <id>'
+  c.description = 'Get list of available connectors'
+  c.option '--credentials FILE', String, 'credentials.yml file path.'
+  c.option '--connectors FILE', String, 'connectors.yml file path'
+  c.option '--values \'{"api_key":"foo"}\'', String, "{}"
+  c.when_called Factor::Commands::Registry, :add_connector
+end
+
+alias_command 's', 'server'
+alias_command 'r', 'registry'

data/lib/factor/version.rb

@@ -0,0 +1,6 @@
+# encoding: UTF-8
+
+# Primary Factor.io module
+module Factor
+  VERSION = '0.5.16'
+end

data/lib/listener.rb

@@ -0,0 +1,26 @@
+# encoding: UTF-8
+
+require 'websocket_manager'
+
+module Factor
+  # Class Listener for integrating with connector service
+  class Listener
+    def initialize(url)
+      @url = url
+    end
+
+    def listener(listener_id)
+      listen("#{@url}/listeners/#{listener_id}")
+    end
+
+    def action(action_id)
+      listen("#{@url}/actions/#{action_id}")
+    end
+
+    private
+
+    def listen(uri_path)
+      WebSocketManager.new(uri_path)
+    end
+  end
+end

data/lib/runtime.rb

@@ -0,0 +1,232 @@
+# encoding: UTF-8
+
+require 'json'
+require 'securerandom'
+require 'yaml'
+require 'eventmachine'
+require 'uri'
+require 'faye/websocket'
+require 'ostruct'
+
+require 'listener'
+require 'commands/base'
+
+module Factor
+  # Runtime class is the magic of the server
+  class Runtime
+    attr_accessor :logger, :name, :description, :id, :instance_id, :connectors, :credentials
+
+    def initialize(connectors, credentials)
+      @workflow_spec  = {}
+      @sockets        = []
+      @instance_id    = SecureRandom.hex(3)
+      @reconnect      = true
+
+      trap 'SIGINT' do
+        info "Exiting '#{@instance_id}'"
+        @reconnect = false
+        @sockets.each { |s| s.close }
+        exit
+      end
+
+      @connectors = {}
+      flat_hash(connectors).each do |key, connector_url|
+        @connectors[key] = Listener.new(connector_url)
+      end
+
+      @credentials = {}
+      credentials.each do |connector_id, credential_settings|
+        @credentials[connector_id] = credential_settings
+      end
+    end
+
+    def load(workflow_definition)
+      EM.run do
+        instance_eval(workflow_definition)
+      end
+    end
+
+    def listen(service_ref, params = {}, &block)
+      service_map = service_ref.split('::') 
+      service_id = service_map.first
+      listener_id = service_map.last
+      service_key = service_map[0..-2].map{|k| k.to_sym}
+
+      ws = @connectors[service_key].listener(listener_id)
+
+      handle_on_open(service_ref, 'Listener', ws, params)
+
+      ws.on :close do
+        error 'Listener disconnected'
+        if @reconnect
+          warn 'Reconnecting...'
+          sleep 3
+          ws.open
+        end
+      end
+
+      ws.on :message do |event|
+        listener_response = JSON.parse(event.data)
+        case listener_response['type']
+        when'start_workflow'
+          success "Workflow '#{service_id}::#{listener_id}' triggered"
+          error_handle_call(listener_response, &block)
+        when 'return'
+          success "Workflow '#{service_ref}' started"
+        when 'fail'
+          error "Workflow '#{service_ref}' failed to start"
+        when 'log'
+          listener_response['message'] = "  #{listener_response['message']}"
+          log_message(listener_response)
+        else
+          error "Unknown listener response: #{listener_response}"
+        end
+      end
+
+      ws.on :retry do |event|
+        warn event[:message]
+      end
+
+      ws.on :error do |event|
+        err = 'Error during WebSocket handshake: Unexpected response code: 401'
+        if event.message == err
+          error "Sorry but you don't have access to this listener,
+            | either because your token is invalid or your plan doesn't
+            | support this listener"
+        else
+          error 'Failure in WebSocket connection to connector service'
+        end
+      end
+
+      ws.open
+
+      @sockets << ws
+    end
+
+    def run(service_ref, params = {}, &block)
+      service_map = service_ref.split('::') 
+      service_id = service_map.first
+      action_id = service_map.last
+      service_key = service_map[0..-2].map{|k| k.to_sym}
+
+      ws = @connectors[service_key].action(action_id)
+
+      handle_on_open(service_ref, 'Action', ws, params)
+
+      ws.on :error do
+        error 'Connection dropped while calling action'
+      end
+
+      ws.on :message do |event|
+        action_response = JSON.parse(event.data)
+        case action_response['type']
+        when 'return'
+          ws.close
+          success "Action '#{service_ref}' responded"
+          error_handle_call(action_response, &block)
+        when 'fail'
+          ws.close
+          error "  #{action_response['message']}"
+          error "Action '#{service_ref}' failed"
+        when 'log'
+          action_response['message'] = "  #{action_response['message']}"
+          log_message(action_response)
+        else
+          error "Unknown action response: #{action_response}"
+        end
+      end
+
+      ws.open
+
+      @sockets << ws
+    end
+
+    private
+
+    class DeepStruct < OpenStruct
+      def initialize(hash=nil)
+        @table = {}
+        @hash_table = {}
+
+        if hash
+          hash.each do |k,v|
+            @table[k.to_sym] = (v.is_a?(Hash) ? self.class.new(v) : v)
+            @hash_table[k.to_sym] = v
+
+            new_ostruct_member(k)
+          end
+        end
+      end
+
+      def to_h
+        @hash_table
+      end
+
+      def [](idx)
+        hash = marshal_dump
+        hash[idx.to_sym]
+      end
+    end
+
+    def simple_object_convert(item)
+      if item.is_a?(Hash)
+        DeepStruct.new(item)
+      elsif item.is_a?(Array)
+        item.map do |i|
+          simple_object_convert(i)
+        end
+      else
+        item
+      end
+    end
+
+    def flat_hash(h,f=[],g={})
+      return g.update({ f=>h }) unless h.is_a? Hash
+      h.each { |k,r| flat_hash(r,f+[k],g) }
+      g
+    end
+
+    def handle_on_open(service_ref, dsl_type, ws, params)
+      service_map = service_ref.split('::') 
+      service_id = service_map.first
+
+      ws.on :open do
+        params.merge!(@credentials[service_id.to_sym] || {})
+        success "#{dsl_type.capitalize} '#{service_ref}' called"
+        ws.send(params.to_json)
+      end
+    end
+
+    def error_handle_call(listener_response, &block)
+      content = simple_object_convert(listener_response['payload'])
+      block.call(content) if block
+    rescue => ex
+      error "Error in workflow definition: #{ex.message}"
+      ex.backtrace.each do |line|
+        error "  #{line}"
+      end
+    end
+
+    def success(msg)
+      log_message('type' => 'log', 'status' => 'success', 'message' => msg)
+    end
+
+    def warn(msg)
+      log_message('type' => 'log', 'status' => 'warn', 'message' => msg)
+    end
+
+    def error(msg)
+      log_message('type' => 'log', 'status' => 'error', 'message' => msg)
+    end
+
+    def info(msg)
+      log_message('type' => 'log', 'status' => 'info', 'message' => msg)
+    end
+
+    def log_message(message_info)
+      message_info['instance_id'] = @instance_id
+      message_info['workflow_id'] = @id
+      @logger.call(message_info) if @logger
+    end
+  end
+end

data/lib/websocket_manager.rb

@@ -0,0 +1,94 @@
+# encoding: UTF-8
+
+require 'faye/websocket'
+require 'uri'
+
+module Factor
+  # class for managing the web socket connections
+  class WebSocketManager
+    attr_accessor :keep_open, :events, :state
+
+    def initialize(uri, headers = {})
+      u                     = URI(uri)
+      @uri                  = u.to_s
+      @settings             = { ping: 10, retry: 5 }
+      @settings[:headers]   = headers if headers && headers != {}
+      @state                = :closed
+      @events               = {}
+    end
+
+    def open
+      if closed?
+        @state = :opening
+        connect
+      end
+      @state
+    end
+
+    def close
+      if open?
+        @state = :closing
+        @ws.close
+      end
+      @state
+    end
+
+    def on(event, &block)
+      @events[event] = block
+    end
+
+    def open?
+      @state == :open
+    end
+
+    def opening?
+      @state == :opening
+    end
+
+    def closed?
+      @state == :closed
+    end
+
+    def closing?
+      @state == :closing
+    end
+
+    def send(msg)
+      @ws.send(msg)
+    end
+
+    private
+
+    def call_event(event, data)
+      @events[event].call(data) if @events[event]
+    end
+
+    def connect
+      EM.run do
+        begin
+          @ws = Faye::WebSocket::Client.new(@uri, nil, @settings)
+
+          @ws.on :close do |event|
+            @state = :closed
+            call_event :close, event
+          end
+
+          @ws.on :message do |msg|
+            call_event :message, msg
+          end
+
+          @ws.on :open do |event|
+            @state = :open
+            call_event :open, event
+          end
+
+          @ws.on :error do |event|
+            call_event :error, event
+          end
+        rescue => ex
+          call_event :fail, ex.message
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: factor
 version: !ruby/object:Gem::Version
-  version: 0.5.15
+  version: 0.5.16
 platform: ruby
 authors:
 - Maciej Skierkowski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-21 00:00:00.000000000 Z
+date: 2014-10-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: commander
@@ -150,6 +150,14 @@ files:
 - "./spec/spec_helper.rb"
 - "./spec/workflow_spec.rb"
 - bin/factor
+- lib/commands/base.rb
+- lib/commands/registry.rb
+- lib/commands/workflows.rb
+- lib/factor.rb
+- lib/factor/version.rb
+- lib/listener.rb
+- lib/runtime.rb
+- lib/websocket_manager.rb
 homepage: https://factor.io
 licenses: []
 metadata: {}