opswalrus 1.0.4 → 1.0.6

data/README.md

@@ -2,6 +2,22 @@
 
 opswalrus is a tool that runs scripts against hosts. It's kind of like Ansible, but aims to be simpler to use.
 
+# Getting started
+
+You have two options:
+- Install via Rubygems
+- Install via Docker
+
+## Rubygems install
+
+## Docker install
+
+```shell
+alias ops='docker run --rm -it -v $HOME/.ssh:/root/.ssh -v /var/run/docker.sock:/var/run/docker.sock -v ${PWD}/:/workdir ghcr.io/opswalrus/ops'
+
+ops --version
+```
+
 # Examples
 
 ```bash

data/build.ops

@@ -0,0 +1,20 @@
+params:
+  version: string
+
+imports:
+  core: "https://github.com/opswalrus/core.git"
+...
+
+version = params.version
+
+template = <<TEMPLATE
+module OpsWalrus
+  VERSION = "{{ version }}"
+end
+TEMPLATE
+
+puts "Write version.rb for version #{version}"
+core.template.write(path: "./lib/opswalrus/version.rb", template: template, variables: {version: version})
+
+sh("Build gem") { 'gem build opswalrus.gemspec' }
+sh("Build docker image") { 'docker build -t opswalrus/ops:{{ version }} .' }

data/lib/opswalrus/app.rb

@@ -1,5 +1,4 @@
 require "citrus"
-require "git"
 require "io/console"
 require "json"
 require "random/formatter"
@@ -8,6 +7,7 @@ require "socket"
 require "stringio"
 require "yaml"
 require "pathname"
+require_relative "git"
 require_relative "host"
 require_relative "hosts_file"
 require_relative "operation_runner"
@@ -158,24 +158,11 @@ module OpsWalrus
       ops_file = OpsFile.new(self, ops_file_path)
 
       # if the ops file is part of a package, then set the package directory as the app's pwd
-      # puts "run1: #{ops_file.ops_file_path}"
       if ops_file.package_file && ops_file.package_file.dirname.to_s !~ /#{Bundler::BUNDLE_DIR}/
-        # puts "set pwd: #{ops_file.package_file.dirname}"
-        set_pwd(ops_file.package_file.dirname)
-        rebased_ops_file_relative_path = ops_file.ops_file_path.relative_path_from(ops_file.package_file.dirname)
-        # note: rebased_ops_file_relative_path is a relative path that is relative to ops_file.package_file.dirname
-        # puts "rebased path: #{rebased_ops_file_relative_path}"
-        absolute_ops_file_path = ops_file.package_file.dirname.join(rebased_ops_file_relative_path)
-        # puts "absolute path: #{absolute_ops_file_path}"
-        ops_file = OpsFile.new(self, absolute_ops_file_path)
+        ops_file = set_pwd_to_ops_file_package_directory(ops_file)
       end
-      # puts "run2: #{ops_file.ops_file_path}"
 
       op = OperationRunner.new(self, ops_file)
-      # if op.requires_sudo?
-      #   prompt_sudo_password unless sudo_password
-      # end
-      # exit_status, out, err, script_output_structure = op.run(operation_kv_args, params_json_hash: @params, verbose: @verbose)
       result = op.run(operation_kv_args, params_json_hash: @params, verbose: @verbose)
       exit_status = result.exit_status
 
@@ -183,14 +170,7 @@ module OpsWalrus
         puts "Op exit_status"
         puts exit_status
 
-        # puts "Op stdout"
-        # puts out
-
-        # puts "Op stderr"
-        # puts err
-
         puts "Op output"
-        # puts script_output_structure ? JSON.pretty_generate(script_output_structure) : nil.inspect
         puts JSON.pretty_generate(result.value)
       end
 
@@ -203,6 +183,19 @@ module OpsWalrus
       FileUtils.remove_entry(tmp_dir) if tmp_dir
     end
 
+    # sets the App's pwd to the ops file's package directory and
+    # returns a new OpsFile that points at the revised pathname with considered as relative to the package file's directory
+    def set_pwd_to_ops_file_package_directory(ops_file)
+      # puts "set pwd: #{ops_file.package_file.dirname}"
+      set_pwd(ops_file.package_file.dirname)
+      rebased_ops_file_relative_path = ops_file.ops_file_path.relative_path_from(ops_file.package_file.dirname)
+      # note: rebased_ops_file_relative_path is a relative path that is relative to ops_file.package_file.dirname
+      # puts "rebased path: #{rebased_ops_file_relative_path}"
+      absolute_ops_file_path = ops_file.package_file.dirname.join(rebased_ops_file_relative_path)
+      # puts "absolute path: #{absolute_ops_file_path}"
+      OpsFile.new(self, absolute_ops_file_path)
+    end
+
     # package_operation_and_args can take one of the following forms:
     # - ["github.com/davidkellis/my-package", "operation1", "arg1:val1", "arg2:val2", "arg3:val3"]
     # - ["foo.zip", "foo/myfile.ops", "arg1:val1", "arg2:val2", "arg3:val3"]
@@ -244,7 +237,7 @@ module OpsWalrus
 
         # operation_kv_args = package_operation_and_args
         [ops_file_path, operation_kv_args, tmp_dir]
-      when repo_url = git_repo?(package_or_ops_file_reference)
+      when repo_url = Git.repo?(package_or_ops_file_reference)
         destination_package_path = bundler.download_git_package(repo_url)
 
         ops_file_path, operation_kv_args = find_entry_point_ops_file_in_dir(destination_package_path, package_operation_and_args)
@@ -301,22 +294,6 @@ module OpsWalrus
       [ops_file_path, operation_kv_args]
     end
 
-    # git_repo?("davidkellis/arborist") -> "https://github.com/davidkellis/arborist"
-    # returns the repo URL
-    def git_repo?(repo_reference)
-      candidate_repo_references = [
-        repo_reference,
-        repo_reference =~ /(\.(com|net|org|dev|io|local))\// && "https://#{repo_reference}",
-        repo_reference !~ /github\.com\// && repo_reference =~ /^[a-z\d](?:[a-z\d]|-(?=[a-z\d])){0,38}\/([\w\.@\:\-~]+)$/i && "https://github.com/#{repo_reference}"    # this regex is from https://www.npmjs.com/package/github-username-regex and https://www.debuggex.com/r/H4kRw1G0YPyBFjfm
-      ].compact
-      working_repo_reference = candidate_repo_references.find {|reference| Git.ls_remote(reference) rescue nil }
-      working_repo_reference
-    end
-
-    # def is_dir_git_repo?(dir_path)
-    #   Git.ls_remote(reference) rescue nil
-    # end
-
     def bundle_status
     end
 

data/lib/opswalrus/bundler.rb

@@ -22,8 +22,8 @@ module OpsWalrus
       @bundle_dir
     end
 
-    def ensure_package_bundle_directory_exists
-      FileUtils.mkdir_p(@bundle_dir)
+    def ensure_pwd_bundle_directory_exists
+      FileUtils.mkdir_p(@bundle_dir) unless @bundle_dir.exist?
     end
 
     # # returns the OpsFile within the bundle directory that represents the given ops_file (which is outside of the bundle directory)
@@ -50,7 +50,7 @@ module OpsWalrus
     # end
 
     def update
-      ensure_package_bundle_directory_exists
+      ensure_pwd_bundle_directory_exists
 
       package_yaml_files = pwd.glob("./**/package.yaml") - pwd.glob("./**/#{BUNDLE_DIR}/**/package.yaml")
       package_files_within_pwd = package_yaml_files.map {|path| PackageFile.new(path.realpath) }
@@ -83,7 +83,7 @@ module OpsWalrus
 
     # returns the self_pkg directory within the bundle directory
     # def include_directory_in_bundle_as_self_pkg(dirname = pwd)
-    #   ensure_package_bundle_directory_exists
+    #   ensure_pwd_bundle_directory_exists
 
     #   destination_package_path = @bundle_dir.join("self_pkg")
 
@@ -103,7 +103,7 @@ module OpsWalrus
     # This method downloads a package_url that is a dependency referenced in the specified package_file
     # returns the destination directory that the package was downloaded to
     def download_package(package_file, package_reference)
-      ensure_package_bundle_directory_exists
+      ensure_pwd_bundle_directory_exists
 
       local_name = package_reference.local_name
       package_url = package_reference.package_uri
@@ -144,19 +144,26 @@ module OpsWalrus
     end
 
     def download_git_package(package_url, version = nil, destination_package_path = nil)
-      destination_package_path ||= begin
-        package_reference_dirname = sanitize_path(package_url)
-        bundle_dir.join(package_reference_dirname)
-      end
-      FileUtils.remove_dir(destination_package_path) if File.exist?(destination_package_path)
+      ensure_pwd_bundle_directory_exists
+
+      destination_package_path ||= dynamic_package_path_for_git_package(package_url, version)
+
+      return destination_package_path if destination_package_path.exist?
+
       if version
-        Git.clone(package_url, destination_package_path, branch: version, config: ['submodule.recurse=true'])
+        ::Git.clone(package_url, destination_package_path, branch: version, config: ['submodule.recurse=true'])
       else
-        Git.clone(package_url, destination_package_path, config: ['submodule.recurse=true'])
+        ::Git.clone(package_url, destination_package_path, config: ['submodule.recurse=true'])
       end
+
       destination_package_path
     end
 
+    def dynamic_package_path_for_git_package(package_url, version = nil)
+      package_reference_dirname = sanitize_path(package_url)
+      bundle_dir.join(package_reference_dirname)
+    end
+
     def sanitize_path(path)
       # found this at https://apidock.com/rails/v5.2.3/ActiveStorage/Filename/sanitized
       path.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: "�").strip.tr("\u{202E}%$|:;/\t\r\n\\", "-")

data/lib/opswalrus/git.rb

@@ -0,0 +1,22 @@
+require "git"
+
+module OpsWalrus
+  class Git
+    # repo?("davidkellis/arborist") -> "https://github.com/davidkellis/arborist"
+    # returns the repo URL or directory path
+    def self.repo?(repo_reference)
+      if Dir.exist?(repo_reference)
+        ::Git.ls_remote(repo_reference) && repo_reference rescue nil
+      else
+        candidate_repo_references = [
+          repo_reference,
+          repo_reference =~ /(\.(com|net|org|dev|io|local))\// && "https://#{repo_reference}",
+          repo_reference !~ /github\.com\// && repo_reference =~ /^[a-z\d](?:[a-z\d]|-(?=[a-z\d])){0,38}\/([\w\.@\:\-~]+)$/i && "https://github.com/#{repo_reference}"    # this regex is from https://www.npmjs.com/package/github-username-regex and https://www.debuggex.com/r/H4kRw1G0YPyBFjfm
+        ].compact
+        working_repo_reference = candidate_repo_references.find {|reference| ::Git.ls_remote(reference) rescue nil }
+        working_repo_reference
+      end
+    end
+
+  end
+end

data/lib/opswalrus/host.rb

@@ -27,6 +27,10 @@ module OpsWalrus
       cmd = block.call if block
       cmd ||= desc_or_cmd
 
+      cmd = WalrusLang.render(cmd, block.binding) if block && cmd =~ /{{.*}}/
+
+      #cmd = Shellwords.escape(cmd)
+
       if self.alias
         print "[#{self.alias} | #{host}] "
       else
@@ -35,11 +39,8 @@ module OpsWalrus
       print "#{description}: " if description
       puts cmd
 
-      cmd = WalrusLang.render(cmd, block.binding) if block && cmd =~ /{{.*}}/
       return unless cmd && !cmd.strip.empty?
 
-      #cmd = Shellwords.escape(cmd)
-
       # puts "shell: #{cmd}"
       # puts "shell: #{cmd.inspect}"
       # puts "sudo_password: #{sudo_password}"

data/lib/opswalrus/operation_runner.rb

@@ -72,7 +72,7 @@ module OpsWalrus
         Invocation::Error.new(e)
       end
 
-      if verbose && result.failure?
+      if verbose == 2 && result.failure?
         puts "Ops script error details:"
         puts "Error: #{result.value}"
         puts "Status code: #{result.exit_status}"

data/lib/opswalrus/ops_file.rb

@@ -1,5 +1,6 @@
 require 'pathname'
 require 'yaml'
+require_relative 'git'
 require_relative 'ops_file_script'
 
 module OpsWalrus
@@ -91,12 +92,16 @@ module OpsWalrus
         imports_hash.map do |local_name, yaml_import_reference|
           local_name = local_name.to_s
           import_reference = case yaml_import_reference
+
+          # when the imports line says:
+          # imports:
+          #   my_package: my_package
           in String => import_str
             case
             when package_reference = package_file&.dependency(import_str)     # package dependency reference
               # in this context, import_str is the local package name documented in the package's dependencies
               PackageDependencyReference.new(local_name, package_reference)
-            when import_str.to_pathname.exist?            # path reference
+            when import_str.to_pathname.exist?                                # path reference
               path = import_str.to_pathname
               case
               when path.directory?
@@ -106,13 +111,26 @@ module OpsWalrus
               else
                 raise Error, "Unknown import reference: #{local_name} -> #{import_str.inspect}"
               end
+            when Git.repo?(import_str)                                        # ops file has imported an ad-hoc git repo
+              package_uri = import_str
+              destination_package_path = app.bundler.dynamic_package_path_for_git_package(package_uri)
+              # puts "DynamicPackageImportReference: #{local_name} -> #{destination_package_path}"
+              DynamicPackageImportReference.new(local_name, DynamicPackageReference.new(local_name, package_uri, nil))
+            else
+              raise Error, "Unknown import reference: #{local_name}: #{yaml_import_reference.inspect}"
             end
-          # in Hash
+
+          # when the imports line says:
+          # imports:
+          #   my_package:
+          #     url: https://...
+          #     version: 2.1
+          # in Hash => package_defn
           #   url = package_defn["url"]
           #   version = package_defn["version"]
           #   PackageReference.new(local_name, url, version&.to_s)
           else
-            raise Error, "Unknown package reference: #{package_defn.inspect}"
+            raise Error, "Unknown import reference: #{local_name}: #{yaml_import_reference.inspect}"
           end
           [local_name, import_reference]
         end.to_h
@@ -205,36 +223,5 @@ module OpsWalrus
       dirname.glob("*").select(&:directory?)
     end
 
-
-
-
-
-
-
-
-    def supporting_library_include_dir_and_require_lib
-      if Dir.exist?(ops_file_helper_library_directory)
-        [ops_file_helper_library_directory, ops_file_helper_library_basename]
-      elsif File.exist?(ops_file_sibling_helper_library_file)
-        [dirname, ops_file_helper_library_basename]
-      else
-        [nil, nil]
-      end
-    end
-
-    def ops_file_helper_library_basename
-      basename.sub_ext(".rb")
-    end
-
-    # "/home/david/sync/projects/ops/ops/core/host/info.ops" => "/home/david/sync/projects/ops/ops/core/host/info"
-    def ops_file_helper_library_directory
-      File.join(dirname, basename)
-    end
-
-    # "/home/david/sync/projects/ops/ops/core/host/info.ops" => "/home/david/sync/projects/ops/ops/core/host/info.rb"
-    def ops_file_sibling_helper_library_file
-      "#{ops_file_helper_library_directory}.rb"
-    end
-
   end
 end

data/lib/opswalrus/ops_file_script.rb

@@ -20,6 +20,9 @@ module OpsWalrus
     def [](index, *args, **kwargs, &block)
       @obj.method(:[]).call(index, *args, **kwargs, &block)
     end
+    def respond_to_missing?(method, *)
+      @obj.is_a?(Hash) && @obj.respond_to?(method)
+    end
     def method_missing(name, *args, **kwargs, &block)
       case @obj
       when Array
@@ -214,6 +217,9 @@ module OpsWalrus
       end
     end
 
+    # currently, import may only be used to import a package that is referenced in the script's package file
+    # I may decide to extend this to work with dynamic package references
+    #
     # local_package_name is the local package name defined for the package dependency that is attempting to be referenced
     def import(local_package_name)
       local_package_name = local_package_name.to_s
@@ -224,12 +230,12 @@ module OpsWalrus
       @runtime_env.resolve_import_reference(@ops_file_script.ops_file, import_reference)
     end
 
-    def params(*keys)
+    def params(*keys, default: nil)
       keys = keys.map(&:to_s)
       if keys.empty?
         @params
       else
-        @params.dig(*keys)
+        @params.dig(*keys) || default
       end
     end
 
@@ -254,17 +260,18 @@ module OpsWalrus
       cmd = block.call if block
       cmd ||= desc_or_cmd
 
+      cmd = WalrusLang.render(cmd, block.binding) if block && cmd =~ /{{.*}}/
+
+      #cmd = Shellwords.escape(cmd)
+
       # puts "shell! self: #{self.inspect}"
 
       print "[#{@runtime_env.local_hostname}] "
       print "#{description}: " if description
       puts cmd
 
-      cmd = WalrusLang.render(cmd, block.binding) if block && cmd =~ /{{.*}}/
       return unless cmd && !cmd.strip.empty?
 
-      #cmd = Shellwords.escape(cmd)
-
       sudo_password = @runtime_env.sudo_password
       sudo_password &&= sudo_password.gsub(/\n+$/,'')     # remove trailing newlines from sudo_password
 

data/lib/opswalrus/package_file.rb

@@ -5,6 +5,7 @@ require_relative 'bundler'
 
 module OpsWalrus
 
+  # these are static package references defined ahead of time in the package file
   class PackageReference
     attr_accessor :local_name
     attr_accessor :package_uri
@@ -23,7 +24,7 @@ module OpsWalrus
       path.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: "�").strip.tr("\u{202E}%$|:;/\t\r\n\\", "-")
     end
 
-    # important: the dirname implemented as the local_name is critical because Bundler#download_package downloads
+    # important: the import_resolution_dirname implemented as the local_name is critical because Bundler#download_package downloads
     # package dependencies to the name that this method returns, which must match the package reference's local name
     # so that later, when the package is being looked up on the load path (in LoadPath#resolve_import_reference),
     # the package reference's referenced git repo or file path may not exist or be available, and so the package
@@ -32,12 +33,20 @@ module OpsWalrus
     # If this implementation changes, then Bundler#download_package and LoadPath#resolve_import_reference must also
     # change in order for the three things to reconcile with respect to one another, since all three bits of logic are
     # what make bundling package dependencies and loading them function properly.
-    def dirname
+    def import_resolution_dirname
       local_name
     end
 
   end
 
+  # these are dynamic package references defined at runtime when an OpsFile's imports are being evaluated.
+  # this will usually be the case when an ops file does not belong to a package
+  class DynamicPackageReference < PackageReference
+    def import_resolution_dirname
+      sanitized_package_uri
+    end
+  end
+
   class PackageFile
     attr_accessor :package_file_path
     attr_accessor :yaml

data/lib/opswalrus/runtime_environment.rb

@@ -32,6 +32,14 @@ module OpsWalrus
     end
   end
 
+  class DynamicPackageImportReference < ImportReference
+    attr_accessor :package_reference
+    def initialize(local_name, package_reference)
+      super(local_name)
+      @package_reference = package_reference
+    end
+  end
+
   class OpsFileReference < ImportReference
     attr_accessor :ops_file_path
     def initialize(local_name, ops_file_path)
@@ -86,6 +94,8 @@ module OpsWalrus
       @dir = dir
       @root_namespace = build_symbol_resolution_tree(@dir)
       @path_map = build_path_map(@root_namespace)
+
+      @dynamic_package_additions_memo = {}
     end
 
     # returns a tree of Namespace -> {Namespace* -> {Namespace* -> ..., OpsFile*}, OpsFile*}
@@ -129,6 +139,19 @@ module OpsWalrus
       path_map
     end
 
+    def dynamically_add_new_package_dir(new_package_dir)
+      # patch the symbol resolution (namespace) tree
+      dir_basename = new_package_dir.basename
+      unless @root_namespace.resolve_symbol(dir_basename)
+        new_child_namespace = build_symbol_resolution_tree(new_package_dir)
+        @root_namespace.add(dir_basename, new_child_namespace)
+
+        # patch the path map
+        new_partial_path_map = build_path_map(new_child_namespace)
+        @path_map.merge!(new_partial_path_map)
+      end
+    end
+
     # returns a Namespace
     def lookup_namespace(ops_file)
       @path_map[ops_file.dirname]
@@ -144,7 +167,16 @@ module OpsWalrus
       case import_reference
       when PackageDependencyReference
         # puts "root namespace: #{@root_namespace.symbol_table}"
-        @root_namespace.resolve_symbol(import_reference.package_reference.local_name)   # returns the Namespace associated with the bundled package dirname (i.e. the local name)
+        @root_namespace.resolve_symbol(import_reference.package_reference.import_resolution_dirname)   # returns the Namespace associated with the bundled package dirname (i.e. the local name)
+      when DynamicPackageImportReference
+        dynamic_package_reference = import_reference.package_reference
+        @dynamic_package_additions_memo[dynamic_package_reference] ||= begin
+          # puts "Downloading dynamic package: #{dynamic_package_reference.inspect}"
+          dynamically_added_package_dir = @runtime_env.app.bundler.download_git_package(dynamic_package_reference.package_uri, dynamic_package_reference.version)
+          dynamically_add_new_package_dir(dynamically_added_package_dir)
+          dynamically_added_package_dir
+        end
+        @root_namespace.resolve_symbol(import_reference.package_reference.import_resolution_dirname)   # returns the Namespace associated with the bundled package dirname (i.e. the sanitized package uri)
       when DirectoryReference
         @path_map[import_reference.dirname]
       when OpsFileReference
@@ -244,7 +276,7 @@ module OpsWalrus
       case import_reference
 
       # we know we're dealing with a package dependency reference, so we want to do the lookup in the bundle load path, where package dependencies live
-      when PackageDependencyReference
+      when PackageDependencyReference, DynamicPackageImportReference
         @bundle_load_path.resolve_import_reference(origin_ops_file, import_reference)
 
       # we know we're dealing with a directory reference or OpsFile reference outside of the bundle dir, so we want to do the lookup in the app load path

data/lib/opswalrus/version.rb

@@ -1,3 +1,3 @@
 module OpsWalrus
-  VERSION = "1.0.4"
+  VERSION = "1.0.6"
 end

data/lib/opswalrus/walrus_lang.rb

@@ -1,4 +1,5 @@
 require "citrus"
+require "ostruct"
 require "stringio"
 
 module WalrusLang
@@ -54,9 +55,17 @@ module WalrusLang
 
   Citrus.eval(Grammar)
 
-  def self.render(template, binding)
+  # binding_obj : Binding | Hash
+  def self.render(template, binding_obj)
+    binding_obj = binding_obj.to_binding if binding_obj.respond_to?(:to_binding)
     ast = WalrusLang::Parser.parse(template)
-    ast.render(binding)
+    ast.render(binding_obj)
+  end
+end
+
+class Hash
+  def to_binding
+    OpenStruct.new(self).instance_eval { binding }
   end
 end
 

data/opswalrus.gemspec

@@ -3,17 +3,18 @@
 require_relative "lib/opswalrus/version"
 
 Gem::Specification.new do |spec|
-  spec.name = "opswalrus"
-  spec.version = OpsWalrus::VERSION
-  spec.authors = ["David Ellis"]
-  spec.email = ["david@conquerthelawn.com"]
-
-  spec.summary = "opswalrus is a tool that runs scripts against a fleet of hosts"
-  spec.description = "opswalrus is a tool that runs scripts against a fleet of hosts hosts. It's kind of like Ansible, but aims to be simpler to use."
-  spec.homepage = "https://github.com/opswalrus/opswalrus"
+  spec.name                  = "opswalrus"
+  spec.version               = OpsWalrus::VERSION
+  spec.authors               = ["David Ellis"]
+  spec.email                 = ["david@conquerthelawn.com"]
+
+  spec.summary               = "opswalrus is a tool that runs scripts against a fleet of hosts"
+  spec.description           = "opswalrus is a tool that runs scripts against a fleet of hosts hosts. It's kind of like Ansible, but aims to be simpler to use."
+  spec.homepage              = "https://github.com/opswalrus/opswalrus"
+  spec.license               = "EPL-2.0"
   spec.required_ruby_version = ">= 2.6.0"
 
-  # spec.metadata["allowed_push_host"] = "TODO: Set to your gem server 'https://example.com'"
+  # spec.metadata["allowed_push_host"] = "TODO: Set to your gem server - https://example.com"
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = "https://github.com/opswalrus/opswalrus"
@@ -31,14 +32,14 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   # gem dependencies
-  spec.add_dependency "citrus"
-  spec.add_dependency "gli"
-  spec.add_dependency "git"
-  spec.add_dependency "rubyzip"
-
-  spec.add_dependency "bcrypt_pbkdf"
-  spec.add_dependency "ed25519"
-  spec.add_dependency "sshkit"
+  spec.add_dependency "citrus", "~> 3.0"
+  spec.add_dependency "gli", "~> 2.21"
+  spec.add_dependency "git", "~> 1.18"
+  spec.add_dependency "rubyzip", "~> 2.3"
+
+  spec.add_dependency "bcrypt_pbkdf", "~> 1.1"
+  spec.add_dependency "ed25519", "~> 1.3"
+  spec.add_dependency "sshkit", "~> 1.21"
 
   # For more information and examples about making a new gem, check out our
   # guide at: https://bundler.io/guides/creating_gem.html