railsdocks 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: eae59bfa42a70c9c629c3d43d0af0b41f42ba79b492f68bdbfc0498e8513560d
+  data.tar.gz: 20f46b9fbc1ee330e278711e2d0784eee88674cd60fe92534f6f37b5298576c8
+SHA512:
+  metadata.gz: 4427a2ffaf198c320bcc9e1bf43effc58b71e80f68a37591d5eaefd3d3488b063de4f64cd954e900e7cda242f8bb57863df5a202b7513022e1f2e516e843668b
+  data.tar.gz: 5903433c21dc4ee9d5717672faae4db2e38ec41f91c1f79b94c6804bd65c0b76d17faf5ba11025a87ffd566ac478ac34fb052c80390474b57ded175a64d08ef4

data/exe/railsdocks

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "railsdocks"
+
+exit RailsDocks::CLI.start(ARGV)

data/lib/railsdocks/cli.rb

@@ -0,0 +1,762 @@
+# frozen_string_literal: true
+
+require "io/console"
+require "open3"
+
+module RailsDocks
+  class CLI
+    def self.start(arguments)
+      command = arguments.shift
+
+      case command
+      when "login"
+        login
+      when "setup"
+        setup
+      when "apps:create"
+        create(arguments)
+      when "apps:list"
+        apps_list
+      when "apps:destroy"
+        apps_destroy(arguments)
+      when "db:migrate"
+        database_command("migrate")
+      when "db:rollback"
+        database_command("rollback")
+      when "domains:list"
+        domains_list
+      when "domains:add"
+        domains_add(arguments)
+      when "domains:remove"
+        domains_remove(arguments)
+      when "version", "--version", "-v"
+        puts "RailsDocks #{RailsDocks::VERSION}"
+        0
+      when nil, "help", "--help", "-h"
+        help
+      else
+        warn "Unknown command: #{command}"
+        warn "Run `railsdocks help` for available commands."
+        1
+      end
+    end
+
+    def self.login
+      print "Email: "
+
+      email =
+        $stdin.gets&.chomp.to_s
+
+      print "Password: "
+
+      password =
+        $stdin.noecho(&:gets)&.chomp.to_s
+
+      puts
+
+      response =
+        Client.new.login(
+          email: email,
+          password: password
+        )
+
+      Config.save_login(
+        email:
+          response
+            .fetch("user")
+            .fetch("email"),
+        token:
+          response.fetch("token")
+      )
+
+      SSHConfig.configure
+
+      puts(
+        "Logged in as " \
+        "#{response.fetch("user").fetch("email")}."
+      )
+
+      puts "RailsDocks SSH configured."
+
+      0
+    rescue Client::Error => e
+      warn "Login failed: #{e.message}"
+      1
+    rescue SSHConfig::Error => e
+      warn(
+        "Login succeeded, but SSH setup failed: " \
+        "#{e.message}"
+      )
+      1
+    rescue KeyError
+      warn(
+        "Login failed: RailsDocks returned " \
+        "an unexpected response."
+      )
+      1
+    end
+
+    def self.setup
+      SSHConfig.configure
+
+      puts "RailsDocks SSH configured."
+      puts "You can now deploy with:"
+      puts
+      puts "  git push railsdocks main"
+
+      0
+    rescue SSHConfig::Error => e
+      warn "Setup failed: #{e.message}"
+      1
+    end
+
+    def self.create(arguments)
+      name = nil
+      no_db = false
+
+      until arguments.empty?
+        argument =
+          arguments.shift
+
+        case argument
+        when "--no-db", "-no-db"
+          no_db = true
+        else
+          if argument.start_with?("-")
+            warn "Unknown option: #{argument}"
+            return 1
+          end
+
+          if name
+            warn "Unexpected argument: #{argument}"
+            warn(
+              "Usage: railsdocks apps:create APP_NAME [--no-db]"
+            )
+            return 1
+          end
+
+          name = argument
+        end
+      end
+
+      if name.to_s.strip.empty?
+        warn(
+          "Usage: railsdocks apps:create APP_NAME [--no-db]"
+        )
+        return 1
+      end
+
+      unless Config.logged_in?
+        warn "You are not logged in."
+        warn "Run `railsdocks login` first."
+        return 1
+      end
+
+      SSHConfig.configure
+
+      response =
+        Client.new.create_app(
+          name: name,
+          token: Config.token,
+          no_db: no_db
+        )
+
+      app =
+        response.fetch("app")
+
+      git_url =
+        app.fetch("git_url")
+
+      puts "Created #{app.fetch("slug")}."
+
+      puts(
+        "Hostname: https://" \
+        "#{app.fetch("hostname")}"
+      )
+
+      if no_db
+        puts "Database: disabled"
+      else
+        puts "Database: PostgreSQL"
+      end
+
+      if inside_git_repository?
+        add_git_remote(git_url)
+      else
+        puts
+        puts "Not currently inside a Git repository."
+        puts "Add the RailsDocks remote when ready:"
+        puts
+        puts(
+          "  git remote add railsdocks #{git_url}"
+        )
+      end
+
+      0
+    rescue Client::Error => e
+      warn "Create failed: #{e.message}"
+      1
+    rescue SSHConfig::Error => e
+      warn "Create failed: #{e.message}"
+      1
+    rescue KeyError
+      warn(
+        "Create failed: RailsDocks returned " \
+        "an unexpected response."
+      )
+      1
+    end
+
+    def self.apps_list
+      unless Config.logged_in?
+        warn "You are not logged in."
+        warn "Run `railsdocks login` first."
+        return 1
+      end
+
+      response =
+        Client.new.apps(
+          token: Config.token
+        )
+
+      apps =
+        response.fetch("apps")
+
+      if apps.empty?
+        puts "No applications."
+        return 0
+      end
+
+      name_width =
+        [
+          "Name".length,
+          *apps.map {
+            |app|
+            app.fetch("name").length
+          }
+        ].max
+
+      hostname_width =
+        [
+          "Hostname".length,
+          *apps.map {
+            |app|
+            app.fetch("hostname").length
+          }
+        ].max
+
+      printf(
+        "%-#{name_width}s  %-#{hostname_width}s  %s\n",
+        "Name",
+        "Hostname",
+        "Database"
+      )
+
+      apps.each do |app|
+        database =
+          app.fetch("database_enabled") ?
+            "PostgreSQL" :
+            "None"
+
+        printf(
+          "%-#{name_width}s  %-#{hostname_width}s  %s\n",
+          app.fetch("name"),
+          app.fetch("hostname"),
+          database
+        )
+      end
+
+      0
+    rescue Client::Error => e
+      warn "Could not list applications: #{e.message}"
+      1
+    rescue KeyError
+      warn(
+        "Could not list applications: RailsDocks returned " \
+        "an unexpected response."
+      )
+      1
+    end
+
+    def self.apps_destroy(arguments)
+      slug =
+        arguments.shift.to_s.strip
+
+      if slug.empty? ||
+         !arguments.empty?
+        warn(
+          "Usage: railsdocks apps:destroy APP_NAME"
+        )
+
+        return 1
+      end
+
+      unless Config.logged_in?
+        warn "You are not logged in."
+        warn "Run `railsdocks login` first."
+        return 1
+      end
+
+      puts(
+        "Destroy #{slug}? This cannot be undone."
+      )
+
+      print "Type #{slug} to confirm: "
+
+      confirmation =
+        $stdin.gets&.chomp.to_s
+
+      unless confirmation == slug
+        puts "Cancelled."
+        return 1
+      end
+
+      response =
+        Client.new.destroy_app(
+          slug: slug,
+          confirm: confirmation,
+          token: Config.token
+        )
+
+      app =
+        response.fetch("app")
+
+      destroyed_slug =
+        app.fetch("slug")
+
+      unless app.fetch("destroyed") == true
+        raise KeyError,
+              "destroyed"
+      end
+
+      puts "Destroyed #{destroyed_slug}."
+
+      0
+    rescue Client::Error => e
+      warn "Destroy failed: #{e.message}"
+      1
+    rescue KeyError
+      warn(
+        "Destroy failed: RailsDocks returned "         "an unexpected response."
+      )
+      1
+    end
+
+    def self.database_command(operation)
+      unless Config.logged_in?
+        warn "You are not logged in."
+        warn "Run `railsdocks login` first."
+        return 1
+      end
+
+      slug =
+        current_app_slug
+
+      unless slug
+        warn(
+          "Could not determine the RailsDocks app."
+        )
+
+        warn(
+          "Run this command from a Git repository " \
+          "with a `railsdocks` remote."
+        )
+
+        return 1
+      end
+
+      display_name =
+        operation == "migrate" ?
+          "Migrating" :
+          "Rolling back"
+
+      puts "#{display_name} #{slug}..."
+
+      response =
+        Client.new.database_command(
+          slug: slug,
+          operation: operation,
+          token: Config.token
+        )
+
+      output =
+        response["output"].to_s.strip
+
+      puts output unless output.empty?
+
+      puts(
+        operation == "migrate" ?
+          "Migration complete." :
+          "Rollback complete."
+      )
+
+      0
+    rescue Client::Error => e
+      warn(
+        "Database command failed: #{e.message}"
+      )
+
+      1
+    end
+
+    def self.domains_list
+      unless Config.logged_in?
+        warn "You are not logged in."
+        warn "Run `railsdocks login` first."
+        return 1
+      end
+
+      response =
+        Client.new.domains(
+          token: Config.token
+        )
+
+      domains =
+        response.fetch("domains")
+
+      if domains.empty?
+        puts "No custom domains."
+        return 0
+      end
+
+      hostname_width =
+        [
+          "Domain".length,
+          *domains.map {
+            |domain|
+            domain.fetch("hostname").length
+          }
+        ].max
+
+      app_width =
+        [
+          "App".length,
+          *domains.map {
+            |domain|
+            domain.fetch("app").length
+          }
+        ].max
+
+      printf(
+        "%-#{hostname_width}s  %-#{app_width}s  %s\n",
+        "Domain",
+        "App",
+        "Status"
+      )
+
+      domains.each do |domain|
+        printf(
+          "%-#{hostname_width}s  %-#{app_width}s  %s\n",
+          domain.fetch("hostname"),
+          domain.fetch("app"),
+          domain.fetch("status")
+        )
+      end
+
+      0
+    rescue Client::Error => e
+      warn "Could not list domains: #{e.message}"
+      1
+    rescue KeyError
+      warn(
+        "Could not list domains: RailsDocks returned " \
+        "an unexpected response."
+      )
+      1
+    end
+
+    def self.domains_add(arguments)
+      unless Config.logged_in?
+        warn "You are not logged in."
+        warn "Run `railsdocks login` first."
+        return 1
+      end
+
+      hostname =
+        arguments.shift.to_s.strip
+
+      if hostname.empty?
+        warn(
+          "Usage: railsdocks domains:add DOMAIN " \
+          "[--app APP_NAME]"
+        )
+
+        return 1
+      end
+
+      app_slug = nil
+
+      until arguments.empty?
+        argument =
+          arguments.shift
+
+        case argument
+        when "--app"
+          app_slug =
+            arguments.shift.to_s.strip
+
+          if app_slug.empty?
+            warn "--app requires an application name."
+            return 1
+          end
+        else
+          warn "Unknown option: #{argument}"
+          return 1
+        end
+      end
+
+      app_slug ||=
+        current_app_slug
+
+      unless app_slug
+        warn(
+          "Could not determine the RailsDocks app."
+        )
+
+        warn(
+          "Use --app APP_NAME or run this command " \
+          "from a RailsDocks Git repository."
+        )
+
+        return 1
+      end
+
+      response =
+        Client.new.add_domain(
+          hostname: hostname,
+          app: app_slug,
+          token: Config.token
+        )
+
+      domain =
+        response.fetch("domain")
+
+      dns =
+        response.fetch("dns")
+
+      puts(
+        "Added #{domain.fetch("hostname")} " \
+        "to #{domain.fetch("app")}."
+      )
+
+      puts
+      puts "DNS configuration:"
+
+      puts(
+        "  #{dns.fetch("type")}  " \
+        "#{dns.fetch("name")}  " \
+        "#{dns.fetch("target")}"
+      )
+
+      puts
+
+      puts(
+        "Status: #{domain.fetch("status")}"
+      )
+
+      0
+    rescue Client::Error => e
+      warn "Could not add domain: #{e.message}"
+      1
+    rescue KeyError
+      warn(
+        "Could not add domain: RailsDocks returned " \
+        "an unexpected response."
+      )
+      1
+    end
+
+    def self.domains_remove(arguments)
+      unless Config.logged_in?
+        warn "You are not logged in."
+        warn "Run `railsdocks login` first."
+        return 1
+      end
+
+      hostname =
+        arguments.shift.to_s.strip
+
+      if hostname.empty? ||
+         !arguments.empty?
+        warn(
+          "Usage: railsdocks domains:remove DOMAIN"
+        )
+
+        return 1
+      end
+
+      response =
+        Client.new.remove_domain(
+          hostname: hostname,
+          token: Config.token
+        )
+
+      domain =
+        response.fetch("domain")
+
+      puts(
+        "Removed #{domain.fetch("hostname")} " \
+        "from #{domain.fetch("app")}."
+      )
+
+      0
+    rescue Client::Error => e
+      warn "Could not remove domain: #{e.message}"
+      1
+    rescue KeyError
+      warn(
+        "Could not remove domain: RailsDocks returned " \
+        "an unexpected response."
+      )
+      1
+    end
+
+    def self.inside_git_repository?
+      _output,
+        _error,
+        status =
+        Open3.capture3(
+          "git",
+          "rev-parse",
+          "--is-inside-work-tree"
+        )
+
+      status.success?
+    end
+
+    def self.current_app_slug
+      return nil unless inside_git_repository?
+
+      output,
+        _error,
+        status =
+        Open3.capture3(
+          "git",
+          "remote",
+          "get-url",
+          "railsdocks"
+        )
+
+      return nil unless status.success?
+
+      remote_url =
+        output.strip
+
+      match =
+        remote_url.match(
+          %r{
+            \A
+            git@deploy\.railsdocks\.com:
+            (?<slug>
+              [a-z0-9]
+              (?:[a-z0-9-]*[a-z0-9])?
+            )
+            \.git
+            \z
+          }x
+        )
+
+      match &&
+        match[:slug]
+    end
+
+    def self.add_git_remote(git_url)
+      _output,
+        _error,
+        status =
+        Open3.capture3(
+          "git",
+          "remote",
+          "get-url",
+          "railsdocks"
+        )
+
+      if status.success?
+        warn(
+          "Git remote `railsdocks` already exists."
+        )
+
+        return
+      end
+
+      _output,
+        error,
+        status =
+        Open3.capture3(
+          "git",
+          "remote",
+          "add",
+          "railsdocks",
+          git_url
+        )
+
+      unless status.success?
+        warn(
+          "Could not add Git remote: " \
+          "#{error.strip}"
+        )
+
+        return
+      end
+
+      puts "Git remote `railsdocks` added."
+    end
+
+    def self.help
+      puts <<~HELP
+        RailsDocks #{RailsDocks::VERSION}
+
+        Usage:
+          railsdocks COMMAND
+
+        Commands:
+          login
+              Log in to RailsDocks
+
+          setup
+              Configure RailsDocks SSH
+
+          apps:create APP_NAME [--no-db]
+              Create a RailsDocks application
+
+              --no-db
+                  Create the application without PostgreSQL
+
+          apps:list
+              List RailsDocks applications
+
+          apps:destroy APP_NAME
+              Permanently destroy a RailsDocks application
+
+          db:migrate
+              Run Rails database migrations
+
+          db:rollback
+              Roll back the last application migration
+
+          domains:list
+              List all custom domains
+
+          domains:add DOMAIN [--app APP_NAME]
+              Add a custom domain
+
+          domains:remove DOMAIN
+              Remove a custom domain
+
+          version
+              Show the RailsDocks CLI version
+
+          help
+              Show this help
+      HELP
+
+      0
+    end
+
+    private_class_method \
+      :inside_git_repository?,
+      :current_app_slug,
+      :add_git_remote,
+      :help
+  end
+end

data/lib/railsdocks/client.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+module RailsDocks
+  class Client
+    DEFAULT_API_URL = "https://api.railsdocks.com"
+
+    class Error < StandardError
+    end
+
+    def initialize(
+      base_url: ENV.fetch(
+        "RAILSDOCKS_API_URL",
+        DEFAULT_API_URL
+      )
+    )
+      @base_url = base_url
+    end
+
+    def login(email:, password:)
+      post(
+        "/api/v1/login",
+        {
+          email: email,
+          password: password
+        }
+      )
+    end
+
+    def create_app(
+      name:,
+      token:,
+      no_db: false
+    )
+      post(
+        "/api/v1/apps",
+        {
+          name: name,
+          no_db: no_db
+        },
+        token: token
+      )
+    end
+
+    def database_command(
+      slug:,
+      operation:,
+      token:
+    )
+      post(
+        "/api/v1/apps/#{slug}/db/#{operation}",
+        {},
+        token: token
+      )
+    end
+
+    def apps(token:)
+      get(
+        "/api/v1/apps",
+        token: token
+      )
+    end
+
+    def destroy_app(
+      slug:,
+      confirm:,
+      token:
+    )
+      encoded_slug =
+        URI.encode_www_form_component(
+          slug
+        )
+
+      delete(
+        "/api/v1/apps/#{encoded_slug}",
+        {
+          confirm: confirm
+        },
+        token: token
+      )
+    end
+
+    def domains(token:)
+      get(
+        "/api/v1/domains",
+        token: token
+      )
+    end
+
+    def add_domain(
+      hostname:,
+      app:,
+      token:
+    )
+      post(
+        "/api/v1/domains",
+        {
+          hostname: hostname,
+          app: app
+        },
+        token: token
+      )
+    end
+
+    def remove_domain(
+      hostname:,
+      token:
+    )
+      delete(
+        "/api/v1/domains",
+        {
+          hostname: hostname
+        },
+        token: token
+      )
+    end
+
+    private
+
+    attr_reader :base_url
+
+    def get(path, token: nil)
+      request(
+        Net::HTTP::Get,
+        path,
+        token: token
+      )
+    end
+
+    def post(
+      path,
+      body,
+      token: nil
+    )
+      request(
+        Net::HTTP::Post,
+        path,
+        body: body,
+        token: token
+      )
+    end
+
+    def delete(
+      path,
+      body,
+      token: nil
+    )
+      request(
+        Net::HTTP::Delete,
+        path,
+        body: body,
+        token: token
+      )
+    end
+
+    def request(
+      request_class,
+      path,
+      body: nil,
+      token: nil
+    )
+      uri =
+        URI.join(
+          base_url,
+          path
+        )
+
+      http_request =
+        request_class.new(uri)
+
+      http_request["Accept"] =
+        "application/json"
+
+      if body
+        http_request["Content-Type"] =
+          "application/json"
+
+        http_request.body =
+          JSON.generate(body)
+      end
+
+      if token
+        http_request["Authorization"] =
+          "Bearer #{token}"
+      end
+
+      response =
+        Net::HTTP.start(
+          uri.hostname,
+          uri.port,
+          use_ssl: uri.scheme == "https"
+        ) do |http|
+          http.request(http_request)
+        end
+
+      parsed_body =
+        if response.body.to_s.strip.empty?
+          {}
+        else
+          JSON.parse(response.body)
+        end
+
+      if response.is_a?(
+        Net::HTTPSuccess
+      )
+        return parsed_body
+      end
+
+      message =
+        if parsed_body["error"]
+          parsed_body["error"]
+        elsif parsed_body["errors"]
+          Array(
+            parsed_body["errors"]
+          ).join(", ")
+        else
+          "RailsDocks API request failed"
+        end
+
+      raise Error,
+            message
+    rescue Errno::ECONNREFUSED
+      raise Error,
+            "Could not connect to RailsDocks at #{base_url}"
+    rescue JSON::ParserError
+      raise Error,
+            "RailsDocks returned an invalid response"
+    end
+  end
+end

data/lib/railsdocks/config.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+
+module RailsDocks
+  class Config
+    DIRECTORY = File.expand_path("~/.config/railsdocks")
+    FILE_PATH = File.join(DIRECTORY, "config.json")
+
+    def self.save_login(email:, token:)
+      FileUtils.mkdir_p(DIRECTORY)
+
+      File.write(
+        FILE_PATH,
+        JSON.pretty_generate(
+          email: email,
+          token: token
+        )
+      )
+
+      File.chmod(0o600, FILE_PATH)
+    end
+
+    def self.token
+      data.fetch("token")
+    rescue Errno::ENOENT, KeyError, JSON::ParserError
+      nil
+    end
+
+    def self.email
+      data.fetch("email")
+    rescue Errno::ENOENT, KeyError, JSON::ParserError
+      nil
+    end
+
+    def self.logged_in?
+      token.to_s != ""
+    end
+
+    def self.data
+      JSON.parse(File.read(FILE_PATH))
+    end
+
+    private_class_method :data
+  end
+end

data/lib/railsdocks/ssh_config.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module RailsDocks
+  class SSHConfig
+    class Error < StandardError
+    end
+
+    SSH_DIRECTORY = File.expand_path("~/.ssh")
+    CONFIG_PATH = File.join(SSH_DIRECTORY, "config")
+    IDENTITY_PATH = File.join(SSH_DIRECTORY, "id_ed25519_railsdocks")
+
+    BEGIN_MARKER = "# BEGIN RailsDocks"
+    END_MARKER = "# END RailsDocks"
+
+    def self.configure
+      new.configure
+    end
+
+    def configure
+      validate_identity!
+      prepare_directory!
+      write_config!
+
+      true
+    end
+
+    private
+
+    def validate_identity!
+      return if File.file?(IDENTITY_PATH)
+
+      raise Error,
+            "RailsDocks SSH key not found at #{IDENTITY_PATH}"
+    end
+
+    def prepare_directory!
+      FileUtils.mkdir_p(SSH_DIRECTORY)
+      File.chmod(0o700, SSH_DIRECTORY)
+    end
+
+    def write_config!
+      existing =
+        if File.exist?(CONFIG_PATH)
+          File.read(CONFIG_PATH)
+        else
+          ""
+        end
+
+      cleaned = remove_managed_block(existing)
+
+      content = ssh_block
+
+      unless cleaned.strip.empty?
+        content = "#{ssh_block}\n#{cleaned.lstrip}"
+      end
+
+      File.write(CONFIG_PATH, content)
+      File.chmod(0o600, CONFIG_PATH)
+    end
+
+    def remove_managed_block(content)
+      pattern = /
+        ^\Q#{BEGIN_MARKER}\E\n
+        .*?
+        ^\Q#{END_MARKER}\E\n?
+      /mx
+
+      content.gsub(pattern, "")
+    end
+
+    def ssh_block
+      <<~CONFIG
+        #{BEGIN_MARKER}
+        Host deploy.railsdocks.com
+          HostName deploy.railsdocks.com
+          User git
+          IdentityFile #{IDENTITY_PATH}
+          IdentitiesOnly yes
+        #{END_MARKER}
+      CONFIG
+    end
+  end
+end

data/lib/railsdocks/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RailsDocks
+  VERSION = "1.0.0"
+end

data/lib/railsdocks.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "railsdocks/version"
+require_relative "railsdocks/client"
+require_relative "railsdocks/config"
+require_relative "railsdocks/ssh_config"
+require_relative "railsdocks/cli"

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: railsdocks
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- John Nelson
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: Deploy and manage Ruby on Rails applications on RailsDocks.
+executables:
+- railsdocks
+extensions: []
+extra_rdoc_files: []
+files:
+- exe/railsdocks
+- lib/railsdocks.rb
+- lib/railsdocks/cli.rb
+- lib/railsdocks/client.rb
+- lib/railsdocks/config.rb
+- lib/railsdocks/ssh_config.rb
+- lib/railsdocks/version.rb
+homepage: https://railsdocks.com
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: Command-line interface for RailsDocks
+test_files: []