shippy 0.2.5 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c8514e699c44724105cd11bc6b9034e7fe36c992403642bba781a16e7c74aac
-  data.tar.gz: 5356c87f5316dff2637f5f78a0271a8fdcce4a41bfbd6fb128e3aca654087452
+  metadata.gz: e9ad6a9811193f1cba32cbbbb3caaadbe7baabd6cdeedd7b9d3462af3a311e41
+  data.tar.gz: 68c148787b05aaa7bd3cea51bad53ab73638c592d0dd1967329fcda427d64466
 SHA512:
-  metadata.gz: e25771e02e107140eebaf7f8f0f90c66974040d3ebdb0258e819da8a508060d9e297d37e2e2b2e9a4d355f2f4f5491963aa7bd5440c45ca6751170d241fafc72
-  data.tar.gz: ea3feb9af3d644ef5e82149d09da0479cb46f010e07cdb1422dd73a58d90afac106c0db47f3b7e59b5732dc310b8876491848263c0b228fdbb4b1866d71689f2
+  metadata.gz: 926e9d0c76ff27f776ff16917b4c6142c3446961f2f4b343e15ad88096a8bcdbd1e53de6e699686f058c6c51b506da9ad4608c1fc143af282bb68d981c90c1c6
+  data.tar.gz: dbf4e8d28ac653c354effda9ec3ec1ff901c4d3c1554e41db644d92b226c98c840fbf1f963b876f182f91861d2ff248f7854560374d28a6af3bcff847c6ef9e4

data/lib/shippy/builder.rb

@@ -0,0 +1,32 @@
+require "minitar"
+require "zlib"
+require "fileutils"
+
+module Shippy
+  class Builder
+    attr_reader :archive_path
+
+    def initialize(app)
+      @app = app
+      @archive_path = "/tmp/v#{Time.now.to_i}.tar.gz"
+    end
+
+    def compile
+      Shippy::Compiler.new(@app, config: SHIPPY.config).compile
+    end
+
+    def archive
+      FileUtils.cd("builds/apps") do
+        File.open(@archive_path, "wb") do |file|
+          zlib = Zlib::GzipWriter.new(file)
+          Minitar.pack(@app.name, zlib)
+        end
+      end
+      @archive_path
+    end
+
+    def cleanup
+      FileUtils.rm_f(@archive_path)
+    end
+  end
+end

data/lib/shippy/cli/app.rb

@@ -3,223 +3,62 @@ class Shippy::Cli::App < Shippy::Cli::Base
 
   def initialize(...)
     super
-    load_app
-  end
-
-  desc "compile", "compile application"
-  def compile
-    say "compiling #{app_name} on #{SHIPPY.host}...", :magenta
-
-    SHIPPY.compile
+    @remote_app = Shippy::Remote::App.new(SHIPPY.host, app_name)
+    @docker = Shippy::Docker::Client.new(SHIPPY.host)
   end
 
   desc "deploy", "Deploy application"
   def deploy
-    say "Deploying #{app_name} on #{SHIPPY.host}...", :magenta
-
-    SHIPPY.compile
-    archive
-    backup
-    upload
-    create_network
-    refresh
-    stop_old
-    pre_start_hooks
-    start
-    cleanup
-    status
+    Shippy::Deployer.new(
+      app_name: app_name,
+      host: SHIPPY.host,
+      ui: self
+    ).deploy
   end
 
   desc "refresh", "Pull new images"
   def refresh
-    say "Pulling images for #{app_name} on #{SHIPPY.host}...", :magenta
-
-    within_app do
-      execute :docker, "compose", "pull"
-    end
+    say "Pulling images...", :magenta
+    @docker.compose_pull(@remote_app.current_path, stream: true)
   end
 
   desc "start", "Start application"
   def start
-    say "Starting #{app_name} on #{SHIPPY.host}...", :magenta
-
-    within_app do
-      execute :docker, "compose", "up", "-d", SHIPPY.app&.deploy_flags
-    end
+    say "Starting...", :magenta
+    app_config = Shippy::Repo.load_app(app_name)
+    @docker.compose_up(@remote_app.current_path, flags: app_config&.deploy_flags)
   end
 
   desc "restart", "Restart application"
-  option :service, aliases: "-S", type: :string, desc: "Restart only a SERVICE"
+  option :service, aliases: "-S", type: :string
   def restart
-    say "Restarting #{app_name} on #{SHIPPY.host}...", :magenta
-    restart_options = options[:service] ? ["--", options[:service]] : []
-
-    within_app do
-      execute :docker, "compose", "restart", *restart_options
-    end
+    say "Restarting...", :magenta
+    services = options[:service] ? [options[:service]] : []
+    @docker.compose_restart(@remote_app.current_path, services)
   end
 
   desc "stop", "Stop application"
   def stop
-    say "Stopping #{app_name} on #{SHIPPY.host}...", :magenta
-
-    within_app do
-      execute :docker, "compose", "down", "--remove-orphans"
-    end
+    say "Stopping...", :magenta
+    @docker.compose_down(@remote_app.current_path)
   end
 
   desc "logs", "Show app logs"
+  option :follow, aliases: "-f", type: :boolean
   def logs
-    within_app do
-      puts capture(:docker, "compose", "logs", verbosity: Logger::INFO)
-    end
+    @docker.logs(@remote_app.current_path, follow: options[:follow])
   end
 
   desc "status", "Show app status"
   def status
-    say "Status for #{app_name} on #{SHIPPY.host}...", :magenta
-
-    within_app do
-      puts capture(:docker, "compose", "ps", "-a")
-    end
-  end
-
-  private
-
-  def load_app
-    with_app do
-      SHIPPY.app = Shippy::Repo.load_app(app_name)
-    end
-  end
-
-  def archive
-    FileUtils.cd("builds/apps") do
-      Minitar.pack(app_name, Zlib::GzipWriter.new(File.open(archive_path, "wb")))
-    end
-  end
-
-  def prepare_directory
-    on(SHIPPY.host) do
-      execute :mkdir, "-p", SHIPPY.current_app_path
-    end
-  end
-
-  def backup
-    backups_path = self.backups_path
-
-    on(SHIPPY.host) do
-      if test("[ -d #{SHIPPY.current_app_path} ]")
-        execute :mkdir, "-p", backups_path
-        execute :mv, SHIPPY.current_app_path, backups_path
-      end
-    end
-  end
-
-  def stop_old
-    backup_path = backups_path.join(app_name)
-
-    on(SHIPPY.host) do
-      if test("[ -f #{backup_path.join("docker-compose.yml")} ]")
-        within backup_path do
-          execute :docker, "compose", "down", "--remove-orphans"
-        end
-      end
-    end
-  end
-
-  def upload
-    source_path = SHIPPY.current_app_path.join("..").expand_path
-    archive_path = self.archive_path
-    prepare_directory
-
-    on(SHIPPY.host) do
-      tmp = capture "mktemp"
-      upload! archive_path, tmp
-
-      execute :tar, "-xzpf", tmp, "-C", source_path
-      execute :rm, tmp
-    end
-  end
-
-  def cleanup
-    remove_archive
-    remove_old_releases
-  end
-
-  def remove_archive
-    archive_path = self.archive_path
-
-    run_locally do
-      execute :rm, archive_path
-    end
-  end
-
-  def remove_old_releases
-    app_backups_paths = backups_path.join("..").expand_path
-
-    on(SHIPPY.host) do
-      if test("[ -d #{app_backups_paths} ]")
-        releases = capture(:ls, "-x", app_backups_paths).split
-        directories = (releases - releases.last(SHIPPY.config.keep_releases)).map do |release|
-          app_backups_paths.join(release).to_s
-        end
-
-        if directories.any?
-          directories.each_slice(100) do |directories_batch|
-            execute :rm, "-rf", *directories_batch
-          end
-        end
-      end
-    end
-  end
-
-  def pre_start_hooks
-    say "Running #{app_name} hooks on #{SHIPPY.host}...", :magenta
-
-    within_app do
-      SHIPPY.app.each_hook do |service, options, command|
-        execute :docker, "compose", "run", "--rm", options, service, command
-      end
-    end
+    @docker.status(@remote_app.current_path)
   end
 
-  def create_network
-    on(SHIPPY.host) do
-      result = capture("docker", "network", "ls", "-q", "-f", "'name=lan_access'")
-
-      if result.empty?
-        execute :docker, "network", "create", "lan_access"
-      end
-    end
-  end
-
-  def archive_path
-    @archive_path ||= "/tmp/v#{Time.now.to_i}.tar.gz"
-  end
-
-  def backups_path
-    @backups_path ||= SHIPPY.deploy_path.join("backups", app_name, Time.now.to_i.to_s)
-  end
-
-  def with_app
-    path = Pathname.new("apps").join(app_name)
-
-    if path.exist?
-      yield
-    else
-      error_on_missing_app
-    end
-  end
-
-  def error_on_missing_app
-    raise "No app by the name of '#{app_name}'"
-  end
-
-  def within_app(&block)
-    on(SHIPPY.host) do
-      within(SHIPPY.current_app_path) do
-        instance_eval(&block)
-      end
-    end
+  desc "compile", "Compile application"
+  def compile
+    say "Compiling #{app_name}...", :magenta
+    # Load app config and pass to builder
+    app_config = Shippy::Repo.load_app(app_name)
+    Shippy::Builder.new(app_config).compile
   end
 end

data/lib/shippy/cli/init.rb

@@ -13,10 +13,6 @@ class Shippy::Cli::Init < Thor::Group
     copy_file "templates/config/shippy.yml", "config/shippy.yml"
   end
 
-  def create_secrets_file
-    copy_file "templates/config/secrets.yml", "config/secrets.yml"
-  end
-
   def init_gemfile
     return if ::File.exist?("Gemfile")
 
@@ -24,7 +20,9 @@ class Shippy::Cli::Init < Thor::Group
   end
 
   def add_shippy_to_gemfile
-    insert_into_file "Gemfile", "gem 'shippy', '~> #{Shippy::VERSION}'"
+    unless File.read("Gemfile").include?("shippy")
+      insert_into_file "Gemfile", "gem 'shippy', '~> #{Shippy::VERSION}'"
+    end
 
     run "bundle install", abort_on_failure: false
   end
@@ -46,5 +44,10 @@ class Shippy::Cli::Init < Thor::Group
     insert_into_file ".gitignore", "/.bundle/\n"
     insert_into_file ".gitignore", "/builds/\n"
     insert_into_file ".gitignore", "/config/secrets.yml\n"
+    insert_into_file ".gitignore", "/config/master.key\n"
+  end
+
+  def generate_secret!
+    Shippy::SecretsManager.new.ensure_key_exists!
   end
 end

data/lib/shippy/cli/prune.rb

@@ -1,21 +1,26 @@
 class Shippy::Cli::Prune < Shippy::Cli::Base
   desc "all", "Prune unused images and stopped containers"
   def all
-    containers
-    images
+    maintainer.clean_all
   end
 
-  desc "images", "Prune unused images older than 7 days"
+  desc "images", "Prune unused images"
+  option :hours, type: :numeric, desc: "Override default retention hours"
   def images
-    on(SHIPPY.host) do
-      execute :docker, :image, :prune, "--all", "--force", "--filter", "until=#{7.days.in_hours}h"
-    end
+    hours = options[:hours] || Shippy::Maintainer::IMAGE_RETENTION_HOURS
+    maintainer.clean_images(hours: hours)
   end
 
-  desc "containers", "Prune stopped containers older than 3 days"
+  desc "containers", "Prune stopped containers"
+  option :hours, type: :numeric, desc: "Override default retention hours"
   def containers
-    on(SHIPPY.host) do
-      execute :docker, :container, :prune, "--force", "--filter", "until=#{3.days.in_hours}h"
-    end
+    hours = options[:hours] || Shippy::Maintainer::CONTAINER_RETENTION_HOURS
+    maintainer.clean_containers(hours: hours)
+  end
+
+  private
+
+  def maintainer
+    @maintainer ||= Shippy::Maintainer.new(SHIPPY.host, ui: self)
   end
 end

data/lib/shippy/cli/templates/config/shippy.yml

@@ -5,3 +5,4 @@ wildcard_domain: 'local.homelab.com'
 local_domain: local
 deploy_to: '/var/lib/homelab'
 secrets_file: 'config/secrets.yml.enc'
+keep_releases: 10

data/lib/shippy/commander.rb

@@ -1,42 +1,39 @@
 module Shippy
   class Commander
-    attr_accessor :config_file, :verbosity, :repo, :app
+    attr_accessor :config_file, :verbosity
+
     delegate :host, :deploy_path, to: :config
 
     def initialize(config_file: nil, verbosity: :info)
-      @config_file, @verbosity = config_file, verbosity
+      @config_file = config_file
+      @verbosity = verbosity
     end
 
     def config
       @config ||= Shippy::Config
         .new(config_file)
-        .tap { |config| configure_sshkit_with(config) }
+        .tap { |c| configure_sshkit_with(c) }
     end
 
     def with_verbosity(level)
       old_level = verbosity
-
       self.verbosity = level
       SSHKit.config.output_verbosity = level
-
       yield
     ensure
       self.verbosity = old_level
       SSHKit.config.output_verbosity = old_level
     end
 
-    def compile
-      Shippy::Compiler.new(app, config: config).compile
-    end
-
-    def current_app_path
-      deploy_path.join("apps", app.name)
-    end
-
     private
 
     def configure_sshkit_with(config)
-      SSHKit::Backend::Netssh.configure { |ssh| ssh.ssh_options = config.ssh_options }
+      SSHKit::Backend::Netssh.configure do |ssh|
+        ssh.ssh_options = config.ssh_options
+        ssh.pty = true
+      end
+
+      # Map commands if they aren't standard on the remote
       SSHKit.config.command_map[:docker] = "docker"
       SSHKit.config.command_map[:docker_compose] = "docker-compose"
       SSHKit.config.output_verbosity = verbosity

data/lib/shippy/config.rb

@@ -12,15 +12,29 @@ module Shippy
     end
 
     def ssh_options
-      {user: ssh_user, auth_methods: ["publickey"]}.compact
+      options = {
+        user: ssh_user,
+        port: ssh_port,
+        keys: ssh_keys,
+        auth_methods: ["publickey"]
+      }
+
+      options.compact
     end
 
     def ssh_user
-      if data[:ssh].present?
-        data.dig(:ssh, :user) || "root"
-      else
-        "root"
-      end
+      data.dig(:ssh, :user) || "root"
+    end
+
+    def ssh_port
+      data.dig(:ssh, :port)
+    end
+
+    def ssh_keys
+      keys = data.dig(:ssh, :keys)
+      return if keys.nil?
+
+      Array(keys).map { |k| File.expand_path(k) }
     end
 
     def deploy_path

data/lib/shippy/deployer.rb

@@ -0,0 +1,60 @@
+module Shippy
+  class Deployer
+    def initialize(app_name:, host:, ui:)
+      @app_name = app_name
+      @ui = ui
+      @app_config = Shippy::Repo.load_app(app_name)
+      @builder = Shippy::Builder.new(@app_config)
+      @remote_app = Shippy::Remote::App.new(host, app_name)
+      @docker = Shippy::Docker::Client.new(host)
+    end
+
+    def deploy
+      @ui.say "Deploying #{@app_name}...", :magenta
+
+      @builder.compile
+      archive = @builder.archive
+
+      @ui.say "Backing up current version...", :blue
+      backup_path = @remote_app.backup_current_release
+
+      @ui.say "Uploading new version...", :blue
+      @remote_app.prepare_directories
+      @remote_app.upload_release(archive)
+
+      @docker.ensure_network("lan_access")
+
+      @ui.say "Pulling images...", :blue
+      @docker.compose_pull(@remote_app.current_path, stream: true)
+
+      if backup_path
+        @ui.say "Stopping old version...", :yellow
+        @docker.compose_down(backup_path)
+      end
+
+      run_hooks
+
+      @ui.say "Starting application...", :green
+      @docker.compose_up(@remote_app.current_path, flags: @app_config&.deploy_flags)
+
+      @builder.cleanup
+      @remote_app.prune_old_releases(keep: SHIPPY.config.keep_releases)
+
+      @docker.status(@remote_app.current_path)
+    rescue => e
+      @ui.error "Deployment failed: #{e.message}"
+      raise e
+    end
+
+    private
+
+    def run_hooks
+      return unless @app_config
+
+      @app_config.each_hook do |service, options, command|
+        @ui.say "Running hook: #{command}", :cyan
+        @docker.run_hook(@remote_app.current_path, service, options, command)
+      end
+    end
+  end
+end

data/lib/shippy/docker/client.rb

@@ -0,0 +1,95 @@
+require "sshkit"
+require "sshkit/dsl"
+
+module Shippy
+  module Docker
+    class Client
+      include SSHKit::DSL
+
+      def initialize(host)
+        @host = host
+      end
+
+      def ensure_network(name)
+        on(@host) do
+          if test("[ -z \"$(docker network ls -q -f name=#{name})\" ]")
+            execute :docker, :network, :create, name
+          end
+        end
+      end
+
+      def compose_up(path, flags: "")
+        on(@host) do
+          within(path) do
+            args = [:docker, :compose, :up, "-d"]
+            args.concat(Array(flags)) unless flags.nil? || flags.empty?
+            execute(*args)
+          end
+        end
+      end
+
+      def compose_down(path)
+        on(@host) do
+          if test("[ -f #{path.join("docker-compose.yml")} ]")
+            within(path) do
+              execute :docker, :compose, :down, "--remove-orphans"
+            end
+          end
+        end
+      end
+
+      def compose_pull(path, stream: false)
+        handler = stream ? Shippy::SshStreamHandler.new : nil
+        on(@host) do
+          within(path) do
+            execute :docker, :compose, :pull, interaction_handler: handler
+          end
+        end
+      end
+
+      def compose_restart(path, services = [])
+        on(@host) do
+          within(path) do
+            execute :docker, :compose, :restart, *services
+          end
+        end
+      end
+
+      def run_hook(path, service, options, command)
+        on(@host) do
+          within(path) do
+            # Ensure options are treated as args
+            args = [:docker, :compose, :run, "--rm"]
+            args << options if options && !options.empty?
+            args << service
+            args << command
+            execute(*args)
+          end
+        end
+      end
+
+      def logs(path, follow: false)
+        cmd_args = [:docker, "compose", "logs"]
+        cmd_args << "--follow" if follow
+
+        on(@host) do
+          within(path) do
+            if follow
+              execute(*cmd_args, interaction_handler: Shippy::SshStreamHandler.new)
+            else
+              puts capture(*cmd_args)
+            end
+          end
+        end
+      end
+
+      def status(path)
+        on(@host) do
+          within(path) do
+            puts capture(:docker, :compose, :ps, "-a")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shippy/docker/system.rb

@@ -0,0 +1,23 @@
+module Shippy
+  module Docker
+    class System
+      include SSHKit::DSL
+
+      def initialize(host)
+        @host = host
+      end
+
+      def prune_images(hours_until:)
+        on(@host) do
+          execute :docker, :image, :prune, "--all", "--force", "--filter", "until=#{hours_until}h"
+        end
+      end
+
+      def prune_containers(hours_until:)
+        on(@host) do
+          execute :docker, :container, :prune, "--force", "--filter", "until=#{hours_until}h"
+        end
+      end
+    end
+  end
+end

data/lib/shippy/maintainer.rb

@@ -0,0 +1,33 @@
+module Shippy
+  class Maintainer
+    IMAGE_RETENTION_HOURS = 24 * 7 # 7 days
+    CONTAINER_RETENTION_HOURS = 24 * 3 # 3 days
+
+    def initialize(host, ui: nil)
+      @host = host
+      @ui = ui
+      @docker = Shippy::Docker::System.new(host)
+    end
+
+    def clean_all
+      clean_containers
+      clean_images
+    end
+
+    def clean_images(hours: IMAGE_RETENTION_HOURS)
+      notify("Pruning images older than #{hours} hours...")
+      @docker.prune_images(hours_until: hours)
+    end
+
+    def clean_containers(hours: CONTAINER_RETENTION_HOURS)
+      notify("Pruning stopped containers older than #{hours} hours...")
+      @docker.prune_containers(hours_until: hours)
+    end
+
+    private
+
+    def notify(message)
+      @ui&.say(message, :yellow)
+    end
+  end
+end

data/lib/shippy/remote/app.rb

@@ -0,0 +1,75 @@
+require "sshkit"
+require "sshkit/dsl"
+
+module Shippy
+  module Remote
+    class App
+      include SSHKit::DSL
+
+      def initialize(host, app_name)
+        @host = host
+        @app_name = app_name
+      end
+
+      def prepare_directories
+        path = current_path
+        on(@host) { execute :mkdir, "-p", path }
+      end
+
+      def upload_release(local_archive_path)
+        source_dir = current_path.join("..")
+
+        on(@host) do
+          remote_tar = capture("mktemp").strip
+          upload! local_archive_path, remote_tar
+
+          execute :tar, "-xzpf", remote_tar, "-C", source_dir
+
+          execute :rm, remote_tar
+        end
+      end
+
+      def backup_current_release
+        ts = Time.now.to_i.to_s
+        timestamp_dir = backups_path.join(ts)
+        current = current_path
+
+        on(@host) do
+          if test("[ -d #{current} ]")
+            execute :mkdir, "-p", timestamp_dir
+            execute :mv, current, timestamp_dir
+          end
+        end
+
+        timestamp_dir.join(@app_name)
+      end
+
+      def prune_old_releases(keep: 5)
+        base = backups_path
+
+        on(@host) do
+          if test("[ -d #{base} ]")
+            releases = capture(:ls, "-1", base).split
+
+            if releases.count > keep
+              to_delete = releases - releases.last(keep)
+
+              if to_delete.any?
+                paths = to_delete.map { |r| base.join(r).to_s }
+                execute :rm, "-rf", *paths
+              end
+            end
+          end
+        end
+      end
+
+      def current_path
+        SHIPPY.deploy_path.join("apps", @app_name)
+      end
+
+      def backups_path
+        SHIPPY.deploy_path.join("backups", @app_name)
+      end
+    end
+  end
+end

data/lib/shippy/ssh_stream_handler.rb

@@ -0,0 +1,12 @@
+module Shippy
+  class SshStreamHandler
+    def on_data(command, stream_name, data, channel)
+      # command     : The SSHKit::Command object
+      # stream_name : :stdout or :stderr
+      # data        : The raw string chunk (e.g. "Pulling layer 1...\n")
+      # channel     : The SSH channel (can be used to send input back)
+
+      print data
+    end
+  end
+end

data/lib/shippy/version.rb

@@ -1,3 +1,3 @@
 module Shippy
-  VERSION = "0.2.5"
+  VERSION = "0.2.6"
 end

data/lib/shippy.rb

@@ -18,6 +18,13 @@ require_relative "shippy/compose"
 require_relative "shippy/service"
 require_relative "shippy/repo"
 require_relative "shippy/compiler"
+require_relative "shippy/builder"
+require_relative "shippy/deployer"
+require_relative "shippy/maintainer"
+require_relative "shippy/ssh_stream_handler"
+require_relative "shippy/remote/app"
+require_relative "shippy/docker/client"
+require_relative "shippy/docker/system"
 
 module Shippy
   class Error < StandardError; end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: shippy
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.2.6
 platform: ruby
 authors:
 - Marius Bobin
@@ -147,6 +147,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: irb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 email:
 - marius@mbobin.me
 executables:
@@ -158,6 +172,7 @@ files:
 - README.md
 - bin/shippy
 - lib/shippy.rb
+- lib/shippy/builder.rb
 - lib/shippy/cli.rb
 - lib/shippy/cli/app.rb
 - lib/shippy/cli/base.rb
@@ -175,10 +190,16 @@ files:
 - lib/shippy/compiler.rb
 - lib/shippy/compose.rb
 - lib/shippy/config.rb
+- lib/shippy/deployer.rb
+- lib/shippy/docker/client.rb
+- lib/shippy/docker/system.rb
+- lib/shippy/maintainer.rb
+- lib/shippy/remote/app.rb
 - lib/shippy/repo.rb
 - lib/shippy/secrets.rb
 - lib/shippy/secrets_manager.rb
 - lib/shippy/service.rb
+- lib/shippy/ssh_stream_handler.rb
 - lib/shippy/version.rb
 homepage: https://mbobin.me/shippy
 licenses: