deploio-cli 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eae3786b2b0c98a4d02b1ac9037e9536da6cfc90ab7120ce80d4e98a76df90d7
-  data.tar.gz: ac86804058048327a006cd3343839299408425dd4e3702fe99aafc571e8e372c
+  metadata.gz: 6111410969c71b44f6dc2296de35ca89d8f5435909b52c7c300a94bd1d71b558
+  data.tar.gz: a255219edc6349570f4e159f77461284d1feb08df1070a418ffaa827bacfc9fe
 SHA512:
-  metadata.gz: 9a6a68ed578e07a9d0026f1dd61f3971ddd5f5e6b2ec590e2960644bef88de65cf054c04c2255051e0b550061eaa965a521b5700bfaf139ae5e3d76bf1f1aa19
-  data.tar.gz: 36614043d839a6a59c7ecc761f6d47ce8b9ff05cf149a630f33b17cb10b45ed8e374c2d1293c3ef7b9d98324290eeeb9332c2c530aea90642e18878faa08b9c4
+  metadata.gz: b6734d4ec34d7021bfeba37492c64b9d4e7a7684739052698715c98e4bd7a587bed1c1027cd7d15c5d18e1a01285145963055db395245ba120fcaedb64dbd2a4
+  data.tar.gz: ad7acd6d33369947979936e9ff940683a495ad988619f08f95e38ebe0b23596e88f5fc9c499c9fcfaf3c0c0e384150761266a3b20a76b4b375829013768e9e84

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+# Changelog
+
+## 0.4.0 - 2026-11-04
+
+- Add `mysql` commands, including MySQL database backups ([#5](https://github.com/renuo/deploio-cli/pull/5))
+- Add bash completions ([#7](https://github.com/renuo/deploio-cli/pull/7))
+- Replace the fork installer with `bin/setup`, so the checkout runs from any directory
+  ([#8](https://github.com/renuo/deploio-cli/pull/8))

data/README.md

@@ -6,6 +6,7 @@ A CLI for [Deploio](https://www.deplo.io/) that wraps [`nctl`](https://github.co
 
 - Ruby 3.3+
 - nctl version 1.10.0 or higher
+- [rclone](https://rclone.org/) (`brew install rclone`) — only needed for `deploio pg backups` on economy-tier databases
 
 ## Installation
 
@@ -14,11 +15,13 @@ A CLI for [Deploio](https://www.deplo.io/) that wraps [`nctl`](https://github.co
 ```bash
 git clone https://github.com/renuo/deploio-cli.git
 cd deploio-cli
-bundle install
-bundle exec bin/deploio --help
+bin/setup
 ```
 
-### As a gem (coming soon)
+`bin/setup` installs the dependencies and puts `deploio` and `depl` binstubs into `~/.local/bin` (override with `INSTALL_DIR`), so this checkout runs from any directory.
+The binstubs are pinned to the Ruby that ran `bin/setup`; run it again after changing the Ruby version.
+
+### As a gem
 
 ```bash
 gem install deploio-cli
@@ -26,10 +29,14 @@ gem install deploio-cli
 
 ## Shell Completion
 
-Enable autocompletion by adding this to your `~/.zshrc` or `~/.bashrc`, or whatever you use:
+Enable autocompletion by adding the line for your shell to its rc file:
 
 ```bash
+# ~/.zshrc
 eval "$(deploio completion)"
+
+# ~/.bashrc
+eval "$(deploio completion --shell bash)"
 ```
 
 After setup, completions work for:
@@ -90,6 +97,13 @@ SERVICES
   deploio services -p PROJECT --connected-apps  Show which apps use each service (requires -p)
   deploio services --chf                    Show estimated monthly price (CHF) for each service
 
+POSTGRESQL
+  deploio pg                                  List all PostgreSQL databases
+  deploio pg:info NAME                        Show database details
+  deploio pg backups list NAME                List available backups
+  deploio pg backups download NAME            Download the latest backup
+  deploio pg backups capture NAME             Capture a new backup
+
 LOGS
   deploio logs -a APP             Show recent logs
   deploio logs -a APP --tail      Stream logs continuously
@@ -100,7 +114,8 @@ EXECUTION
   deploio run -a APP -- CMD       Alias for exec
 
 OTHER
-  deploio completion              Generate shell completion script
+  deploio completion              Generate zsh completion script
+  deploio completion -s bash      Generate bash completion script
   deploio version                 Show version
 
 FLAGS
@@ -214,20 +229,14 @@ gem build deploio-cli.gemspec
 
 ### Testing commands
 
-The best way to test the commands in the shell is to temporarly set:
+After `bin/setup`, `deploio` runs this checkout, so changes take effect immediately.
+After adding or changing commands or options, refresh the autocompletion options:
 
 ```shell
-export PATH="$PWD/bin:$PATH"
+eval "$(deploio completion)"               # zsh
+eval "$(deploio completion --shell bash)"  # bash
 ```
 
-to have the `deploio` command binded to the current one, and
-
-```shell
-eval "$(deploio completion)"
-```
-
-to refresh the autocompletion options.
-
 ## License
 
 MIT

data/deploio-cli.gemspec

@@ -14,7 +14,6 @@ Gem::Specification.new do |spec|
   spec.license = "MIT"
   spec.required_ruby_version = ">= 3.0.0"
 
-  spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = spec.homepage
   spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
 
@@ -23,6 +22,10 @@ Gem::Specification.new do |spec|
 
         eval "$(deploio completion)"
 
+    or this to your ~/.bashrc:
+
+        eval "$(deploio completion --shell bash)"
+
   MSG
 
   spec.files = Dir.chdir(__dir__) do

data/lib/deploio/bash_completion_generator.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require_relative "completion_generator"
+
+module Deploio
+  # Generates bash completion script from Thor command metadata.
+  # Completers are shell commands printing the candidates.
+  #
+  # @example With custom option completers
+  #   BashCompletionGenerator.new(MyCLI, option_completers: {
+  #     'env' => 'echo production staging development'
+  #   }).generate
+  #
+  class BashCompletionGenerator < CompletionGenerator
+    TEMPLATE_PATH = File.expand_path("templates/completion.bash.erb", __dir__)
+
+    ROOT_OPTIONS = {version: Thor::Option.new(:version, type: :boolean, aliases: "-v")}.freeze
+
+    # A command path ("" is the root, "pg:backups" a nested subcommand)
+    # with the candidates that can follow it.
+    Context = Struct.new(:path, :commands, :options, :positional, :passthrough, keyword_init: true)
+
+    private
+
+    def default_option_completers
+      {
+        "app" => "_#{program_name}_apps_list",
+        "size" => "echo micro mini standard",
+        "project" => "_#{program_name}_projects_list"
+      }
+    end
+
+    def default_positional_completers
+      {
+        "orgs:set" => "_#{program_name}_orgs_list",
+        "pg:info" => "_#{program_name}_pg_databases_list",
+        "pg:backups:capture" => "_#{program_name}_pg_databases_list",
+        "pg:backups:list" => "_#{program_name}_pg_databases_list",
+        "pg:backups:download" => "_#{program_name}_pg_databases_list"
+      }
+    end
+
+    def contexts
+      @contexts ||= [
+        Context.new(path: "", commands: main_commands.map(&:first), options: ROOT_OPTIONS),
+        *direct_commands.map { |name, options| leaf_context(name, all_options(options)) },
+        *passthrough_commands.map { |name, options| leaf_context(name, all_options(options), passthrough: true) },
+        *subcommands.flat_map do |name, commands, class_options, default_task, klass|
+          group_contexts(name, commands, class_options, default_task, klass.subcommand_classes)
+        end,
+        *nested_subcommands.flat_map do |name, commands, class_options|
+          group_contexts(name, commands, class_options)
+        end
+      ]
+    end
+
+    def group_contexts(name, commands, class_options, default_task = nil, nested = {})
+      default_options = commands.find { |cmd_name, _, _| cmd_name == default_task }&.last || {}
+      group = Context.new(path: name, commands: commands.map(&:first),
+        options: all_options(default_options, class_options))
+
+      leaves = commands.reject { |cmd_name, _, _| nested.key?(cmd_name) }.map do |cmd_name, _, options|
+        leaf_context("#{name}:#{cmd_name}", all_options(options, class_options))
+      end
+
+      [group, *leaves]
+    end
+
+    def leaf_context(path, options, passthrough: false)
+      Context.new(path: path, commands: [], options: options,
+        positional: positional_completers[path], passthrough: passthrough)
+    end
+
+    def all_options(method_options, class_options = {})
+      cli_class_options.merge(class_options).merge(method_options)
+    end
+
+    def flags(context)
+      context.options.flat_map { |name, opt| option_flags(name, opt) }.uniq
+    end
+
+    def value_flags(context)
+      context.options.reject { |_, opt| opt.type == :boolean }.flat_map { |name, opt| option_flags(name, opt) }.uniq
+    end
+
+    def option_value_completers
+      contexts.flat_map { |context| context.options.to_a }.uniq(&:first).filter_map do |name, opt|
+        completer = option_completers[name.to_s]
+        [option_flags(name, opt), completer] if completer
+      end
+    end
+
+    def option_flags(name, opt)
+      ["--#{name.to_s.tr("_", "-")}", *opt.aliases]
+    end
+  end
+end

data/lib/deploio/cli.rb

@@ -7,9 +7,13 @@ require_relative "commands/builds"
 require_relative "commands/orgs"
 require_relative "commands/projects"
 require_relative "commands/services"
+require_relative "helpers/backups_helper"
 require_relative "commands/postgresql_backups"
 require_relative "commands/postgresql"
+require_relative "commands/mysql_backups"
+require_relative "commands/mysql"
 require_relative "completion_generator"
+require_relative "bash_completion_generator"
 
 module Deploio
   class CLI < Thor
@@ -28,11 +32,13 @@ module Deploio
       case options[:shell].downcase
       when "zsh"
         puts CompletionGenerator.new.generate
-      when "bash", "fish"
-        Output.error("#{options[:shell]} completion is not yet supported. Only zsh is available.")
+      when "bash"
+        puts BashCompletionGenerator.new.generate
+      when "fish"
+        Output.error("#{options[:shell]} completion is not yet supported. Only zsh and bash are available.")
         exit 1
       else
-        Output.error("Unknown shell: #{options[:shell]}. Supported: zsh")
+        Output.error("Unknown shell: #{options[:shell]}. Supported: zsh, bash")
         exit 1
       end
     end
@@ -57,6 +63,9 @@ module Deploio
     desc "pg COMMAND", "PostgreSQL database management commands"
     subcommand "pg", Commands::PostgreSQL
 
+    desc "mysql COMMAND", "MySQL database management commands"
+    subcommand "mysql", Commands::MySQL
+
     # Shortcut for auth:login
     desc "login", "Authenticate with nctl (alias for auth:login)"
     def login
@@ -100,6 +109,8 @@ module Deploio
 
     private
 
+    # The aliases above hand off with Thor.start, which starts from a fresh
+    # option parse, so the shared class options have to be passed as arguments.
     def build_option_args
       args = []
       args << "--dry-run" if options[:dry_run]

data/lib/deploio/commands/mysql.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Deploio
+  module Commands
+    class MySQL < Thor
+      include SharedOptions
+
+      namespace "mysql"
+
+      class_option :json, type: :boolean, default: false, desc: "Output as JSON"
+
+      default_task :list
+
+      desc "list", "List all MySQL databases"
+      def list
+        setup_options
+        raw_dbs = @nctl.get_all_mysql_databases
+
+        if options[:json]
+          puts JSON.pretty_generate(raw_dbs)
+          return
+        end
+
+        if raw_dbs.empty?
+          Output.warning("No MySQL databases found") unless merged_options[:dry_run]
+          return
+        end
+
+        resolver = MysqlDatabaseResolver.new(nctl_client: @nctl)
+
+        rows = raw_dbs.map do |mysql_database|
+          kind = mysql_database["kind"] || ""
+          metadata = mysql_database["metadata"] || {}
+          spec = mysql_database["spec"] || {}
+          for_provider = spec["forProvider"] || {}
+          version = for_provider["version"]
+          namespace = metadata["namespace"] || ""
+          name = metadata["name"] || ""
+
+          [
+            resolver.short_name_for(namespace, name),
+            project_from_namespace(namespace, resolver.current_org),
+            presence(kind, default: "-"),
+            presence(version, default: "?")
+          ]
+        end
+
+        Output.table(rows, headers: ["NAME", "PROJECT", "KIND", "VERSION"])
+      end
+
+      desc "info NAME", "Show MySQL database details"
+      def info(name)
+        setup_options
+        resolver = MysqlDatabaseResolver.new(nctl_client: @nctl)
+        db_ref = resolver.resolve(database_name: name)
+        data = @nctl.get_mysql_database(db_ref)
+
+        if options[:json]
+          puts JSON.pretty_generate(data)
+          return
+        end
+
+        kind = data["kind"]
+        metadata = data["metadata"] || {}
+        spec = data["spec"] || {}
+        for_provider = spec["forProvider"] || {}
+        status = data["status"] || {}
+        at_provider = status["atProvider"] || {}
+
+        Output.header("MySQL Database: #{db_ref.full_name}")
+        puts
+
+        Output.header("General")
+        Output.table(
+          [
+            ["Name", presence(metadata["name"])],
+            ["Project", presence(metadata["namespace"])],
+            ["Kind", presence(kind, default: "-")],
+            ["Version", presence(for_provider["version"], default: "?")],
+            ["FQDN", presence(at_provider["fqdn"])],
+            ["Size", presence(at_provider["size"], default: "-")]
+          ]
+        )
+
+        puts
+
+        Output.header("Status")
+        conditions = status["conditions"] || []
+        ready_condition = conditions.find { |c| c["type"] == "Ready" }
+        synced_condition = conditions.find { |c| c["type"] == "Synced" }
+
+        Output.table(
+          [
+            ["Ready", presence(ready_condition&.dig("status"))],
+            ["Synced", presence(synced_condition&.dig("status"))]
+          ]
+        )
+
+        if for_provider["allowedCIDRs"].is_a?(Array)
+          puts
+
+          Output.header("Access")
+          Output.table(
+            [
+              ["Allowed CIDRs", for_provider["allowedCIDRs"].join(", ")]
+            ]
+          )
+
+          puts
+
+          Output.header("SSH Keys")
+          for_provider["sshKeys"].each do |key|
+            puts "- #{key}"
+          end
+        end
+      rescue Deploio::Error => e
+        Output.error(e.message)
+        exit 1
+      end
+
+      desc "backups COMMAND", "Manage MySQL database backups"
+      subcommand "backups", Commands::MySQLBackups
+
+      private
+
+      def presence(value, default: "-")
+        (value.nil? || value.to_s.empty?) ? default : value
+      end
+
+      def project_from_namespace(namespace, current_org)
+        if current_org && namespace.start_with?("#{current_org}-")
+          namespace.delete_prefix("#{current_org}-")
+        else
+          namespace
+        end
+      end
+    end
+  end
+end

data/lib/deploio/commands/mysql_backups.rb

@@ -0,0 +1,77 @@
+module Deploio
+  module Commands
+    class MySQLBackups < Thor
+      include SharedOptions
+      include BackupsHelper
+
+      namespace "mysql:backups"
+
+      DEDICATED_KIND = "MySQL"
+      ECONOMY_KIND = "MySQLDatabase"
+
+      desc "capture NAME", "Capture a new backup for the specified MySQL database"
+      def capture(name)
+        backup_service_for(name).capture
+      rescue Deploio::Error => e
+        Output.error(e.message)
+        exit 1
+      end
+
+      desc "list NAME", "List the available backups for the specified MySQL database"
+      def list(name)
+        backups = backup_service_for(name).backups
+        if backups.empty?
+          Output.warning("No backups found for '#{name}'")
+          return
+        end
+
+        rows = backups.map do |backup|
+          [format_time(backup["ModTime"]), format_size(backup["Size"]), backup["Name"]]
+        end
+        Output.table(rows, headers: ["DATE", "SIZE", "NAME"])
+      rescue Deploio::Error => e
+        Output.error(e.message)
+        exit 1
+      end
+
+      desc "download NAME [--output destination_path]", "Download the latest backup for the specified MySQL database instance"
+      method_option :output, type: :string, desc: "Output file path (defaults to current directory with auto-generated name)"
+      method_option :db_name, type: :string, desc: "If there are multiple DBs, specify which one to download the backup for", default: nil
+      def download(name)
+        service = backup_service_for(name)
+        destination = merged_options[:output] || service.default_destination
+        backup = service.download(destination: destination, db_name: merged_options[:db_name])
+
+        # Only the economy tier knows when its backup was taken.
+        if backup
+          Output.success("Downloaded backup from #{format_time(backup["ModTime"])} to #{destination}")
+        else
+          Output.success("Downloaded backup to #{destination}")
+        end
+      rescue Deploio::Error => e
+        Output.error(e.message)
+        exit 1
+      end
+
+      private
+
+      def backup_service_for(name)
+        setup_options
+        resolver = MysqlDatabaseResolver.new(nctl_client: @nctl)
+        db_ref = resolver.resolve(database_name: name)
+        data = @nctl.get_mysql_database(db_ref)
+        raise Deploio::Error, "Could not read database '#{db_ref.full_name}'." if data.nil?
+
+        case data["kind"]
+        when DEDICATED_KIND
+          MysqlBackupService.new(data: data, name: name, dry_run: @nctl.dry_run)
+        when ECONOMY_KIND
+          MysqlDatabaseBackupService.new(db_ref: db_ref, data: data, nctl_client: @nctl, name: name)
+        else
+          raise Deploio::UnsupportedBackupOperationError,
+            "Backups are not supported for databases of kind '#{data["kind"]}'."
+        end
+      end
+    end
+  end
+end

data/lib/deploio/commands/postgresql_backups.rb

@@ -2,73 +2,75 @@ module Deploio
   module Commands
     class PostgreSQLBackups < Thor
       include SharedOptions
+      include BackupsHelper
 
       namespace "pg:backups"
 
+      DEDICATED_KIND = "Postgres"
+      ECONOMY_KIND = "PostgresDatabase"
+
       desc "capture NAME", "Capture a new backup for the specified PostgreSQL database"
       def capture(name)
-        setup_options
-        resolver = PgDatabaseResolver.new(nctl_client: @nctl)
-        db_ref = resolver.resolve(database_name: name)
-        data = @nctl.get_pg_database(db_ref)
-        kind = data["kind"] || ""
+        backup_service_for(name).capture
+      rescue Deploio::Error => e
+        Output.error(e.message)
+        exit 1
+      end
 
-        unless kind == "Postgres" || @nctl.dry_run
-          Output.error("Backups can only be captured for PostgreSQL databases. (shared dbs are not supported)")
-          exit 1
+      desc "list NAME", "List the available backups for the specified PostgreSQL database"
+      def list(name)
+        backups = backup_service_for(name).backups
+        if backups.empty?
+          Output.warning("No backups found for '#{name}'")
+          return
         end
 
-        fqdn = data.dig("status", "atProvider", "fqdn")
-        if fqdn.nil? || fqdn.empty?
-          Output.error("Database FQDN not found; cannot capture backup.")
-          exit 1
+        rows = backups.map do |backup|
+          [format_time(backup["ModTime"]), format_size(backup["Size"]), backup["Name"]]
         end
-
-        cmd = ["ssh", "dbadmin@#{fqdn}", "sudo nine-postgresql-backup"]
-        Output.command(cmd.join(" "))
-        system(*cmd) unless @nctl.dry_run
+        Output.table(rows, headers: ["DATE", "SIZE", "NAME"])
+      rescue Deploio::Error => e
+        Output.error(e.message)
+        exit 1
       end
 
       desc "download NAME [--output destination_path]", "Download the latest backup for the specified PostgreSQL database instance"
       method_option :output, type: :string, desc: "Output file path (defaults to current directory with auto-generated name)"
       method_option :db_name, type: :string, desc: "If there are multiple DBs, specify which one to download the backup for", default: nil
       def download(name)
-        destination = options[:output] || "./#{name}-latest-backup.zst"
+        service = backup_service_for(name)
+        destination = merged_options[:output] || service.default_destination
+        backup = service.download(destination: destination, db_name: merged_options[:db_name])
 
+        # Only the economy tier knows when its backup was taken.
+        if backup
+          Output.success("Downloaded backup from #{format_time(backup["ModTime"])} to #{destination}")
+        else
+          Output.success("Downloaded backup to #{destination}")
+        end
+      rescue Deploio::Error => e
+        Output.error(e.message)
+        exit 1
+      end
+
+      private
+
+      def backup_service_for(name)
         setup_options
         resolver = PgDatabaseResolver.new(nctl_client: @nctl)
         db_ref = resolver.resolve(database_name: name)
         data = @nctl.get_pg_database(db_ref)
-        kind = data["kind"] || ""
-
-        unless kind == "Postgres" || @nctl.dry_run
-          Output.error("Backups can only be downloaded for PostgreSQL databases. (shared dbs are not supported)")
-          exit 1
-        end
+        raise Deploio::Error, "Could not read database '#{db_ref.full_name}'." if data.nil?
 
-        databases = data.dig("status", "atProvider", "databases")&.keys || []
-        databases.reject! { |db| db.strip.empty? }
-        if databases.empty?
-          Output.error("No databases found in PostgreSQL instance; cannot download backup.")
-          exit 1
-        elsif databases.size > 1 && options[:db_name].nil?
-          Output.error("Multiple databases found in PostgreSQL instance")
-          Output.error("Databases: #{databases.join(", ")}")
-          Output.error("Please specify the database name using the --db_name option.")
-          exit 1
+        case data["kind"]
+        when DEDICATED_KIND
+          PostgresBackupService.new(data: data, name: name, dry_run: @nctl.dry_run)
+        when ECONOMY_KIND
+          PostgresDatabaseBackupService.new(db_ref: db_ref, data: data, nctl_client: @nctl, name: name)
+        else
+          raise Deploio::UnsupportedBackupOperationError,
+            "Backups are not supported for databases of kind '#{data["kind"]}'."
         end
-
-        db_name = options[:db_name] || databases.first
-
-        fqdn = data.dig("status", "atProvider", "fqdn")
-        if fqdn.nil? || fqdn.empty?
-          Output.error("Database FQDN not found; cannot download backup.")
-          exit 1
-        end
-
-        cmd = ["rsync", "-avz", "dbadmin@#{fqdn}:~/backup/postgresql/latest/customer/#{db_name}/#{db_name}.zst", destination]
-        Output.command(cmd.join(" "))
-        system(*cmd) unless @nctl.dry_run
       end
     end
   end

data/lib/deploio/completion_generator.rb

@@ -37,7 +37,7 @@ module Deploio
     end
 
     def generate
-      template = File.read(TEMPLATE_PATH)
+      template = File.read(self.class::TEMPLATE_PATH)
       ERB.new(template, trim_mode: "-").result(binding)
     end
 
@@ -61,6 +61,7 @@ module Deploio
         "orgs:set" => "'1:organization:_#{program_name}_orgs_list'",
         "pg:info" => "'1:database:_#{program_name}_pg_databases_list'",
         "pg:backups:capture" => "'1:database:_#{program_name}_pg_databases_list'",
+        "pg:backups:list" => "'1:database:_#{program_name}_pg_databases_list'",
         "pg:backups:download" => "'1:database:_#{program_name}_pg_databases_list'"
       }
     end

data/lib/deploio/helpers/backups_helper.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Deploio
+  module BackupsHelper
+    def format_size(bytes)
+      bytes = bytes.to_i
+      units = ["B", "KiB", "MiB", "GiB", "TiB"]
+      index = 0
+      size = bytes.to_f
+      while size >= 1024 && index < units.size - 1
+        size /= 1024
+        index += 1
+      end
+      (index.zero? ? "#{bytes} B" : format("%.1f %s", size, units[index]))
+    end
+
+    def format_time(value)
+      Time.parse(value.to_s).localtime.strftime("%Y-%m-%d %H:%M")
+    rescue ArgumentError, TypeError
+      value.to_s
+    end
+  end
+end