deploio-cli 0.3.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ef7a08d44a816dd88331bf7e007a536ef399b10afbf05229bef8e1e3137629e
-  data.tar.gz: d042f89dc44e64df49d599f1291f88151af45461132156af5c36486fa6408baa
+  metadata.gz: 5dcf01de3150cb22e539daf36c3b166063427b1545c2bdf65bac575fea8b463c
+  data.tar.gz: 505202b6194b9248f039178c45b23c54089cb1887fb38dbfef37dafc6ad2b43e
 SHA512:
-  metadata.gz: 603238b92b6b23a32bf92f81a0a89a4cc0edbf8daad40519f1f165c095629ccb5f83775f01f0aae67541f6177f845ebc9797584fdcdb977425fa2307c2d8f98e
-  data.tar.gz: 2ac16607435cc562bcf3d3e94066002315bb06f198122fe6d088ee25782f9153106ab065e217f34a86d5aa99a4cb2d7d154876eabcc958266f2e74cc6771ef09
+  metadata.gz: b8fc759d2107cf92663ff45bc05c8bc6ccdd15f038a4d34e35941324571d6264e69fedd7ae7e179cedabb3029232982f4afd7a8b887af7e20d8bb712d581060c
+  data.tar.gz: 92916faa78a8645f47738bb749b872aa83e22852727c594498a26d642279d21db5acda922f103cc0e305ceea9e9eecc1353e401890e71bf80850b679ce30b2d0

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+# Changelog
+
+## 0.4.1 - 2026-11-04
+
+- Remove the duplicate `homepage_uri` gem metadata that made `gem build` warn
+
+## 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

@@ -15,10 +15,12 @@ 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
 ```
 
+`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
@@ -27,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:
@@ -108,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
@@ -211,31 +218,35 @@ deploio exec -- rails console
 ### Running tests
 
 ```bash
-bundle exec rake test
+bin/check
+bin/fastcheck
 ```
 
-### Building the gem
+### Release
 
-```bash
-gem build deploio-cli.gemspec
-```
+1. Bump the version in `lib/deploio/version.rb`, run `bundle install`, update `CHANGELOG.md` and commit to `main`.
+2. Tag the commit with the bare version and push the tag:
 
-### Testing commands
+   ```bash
+   git tag -a 1.2.3 -m 1.2.3
+   git push origin 1.2.3
+   ```
 
-The best way to test the commands in the shell is to temporarly set:
+3. Create a GitHub release for the tag with the changelog section as notes.
 
-```shell
-export PATH="$PWD/bin:$PATH"
-```
+Semaphore runs the tests on the tag and, when they pass, promotes the `release` pipeline, which pushes the gem to
+[rubygems.org](https://rubygems.org). It fails when the tag does not match the gem version.
+
+### Testing commands
 
-to have the `deploio` command binded to the current one, and
+After `bin/setup`, `deploio` runs this checkout, so changes take effect immediately.
+After adding or changing commands or options, refresh the autocompletion options:
 
 ```shell
-eval "$(deploio completion)"
+eval "$(deploio completion)"               # zsh
+eval "$(deploio completion --shell bash)"  # bash
 ```
 
-to refresh the autocompletion options.
-
 ## License
 
 MIT

data/Rakefile

@@ -3,6 +3,8 @@
 require "bundler/gem_tasks"
 require "rake/testtask"
 
+Rake::Task["release"].clear
+
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
   t.libs << "lib"

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,12 +22,16 @@ 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
     `git ls-files -z`.split("\x0").reject do |f|
       (File.expand_path(f) == __FILE__) ||
-        f.start_with?(*%w[bin/ test/ spec/ features/ .git .github appveyor Gemfile])
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .github .semaphore appveyor Gemfile])
     end
   end
   spec.bindir = "bin"

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

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

@@ -1,9 +1,8 @@
-require "time"
-
 module Deploio
   module Commands
     class PostgreSQLBackups < Thor
       include SharedOptions
+      include BackupsHelper
 
       namespace "pg:backups"
 
@@ -73,24 +72,6 @@ module Deploio
             "Backups are not supported for databases of kind '#{data["kind"]}'."
         end
       end
-
-      def format_time(value)
-        Time.parse(value.to_s).localtime.strftime("%Y-%m-%d %H:%M")
-      rescue ArgumentError, TypeError
-        value.to_s
-      end
-
-      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
     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
 

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

data/lib/deploio/mysql_backup_service.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Deploio
+  class MysqlBackupService
+    DEFAULT_EXTENSION = ".zst"
+
+    # @param name [String] the name the user typed, used for hints in messages
+    def initialize(data:, name: nil, dry_run: false)
+      @data = data || {}
+      @name = name
+      @dry_run = dry_run
+    end
+
+    def default_destination = "./#{@name}-latest-backup"
+
+    def backups
+      raise Deploio::UnsupportedBackupOperationError,
+        "Listing backups is not yet supported for dedicated MySQL instances; Feel free to implement it!\n" \
+          "Use 'deploio mysql backups download #{@name}' to fetch it."
+    end
+
+    def capture
+      cmd = ["ssh", "dbadmin@#{fqdn}", "sudo", "nine-mysql-backup"]
+      Output.command(cmd.join(" "))
+      system(*cmd) unless @dry_run
+    end
+
+    def download(destination:, db_name: nil)
+      name = resolve_db_name(db_name)
+
+      cmd = [
+        "rsync",
+        "-av",
+        "dbadmin@#{fqdn}:~/backup/mysql/latest/customer/#{name}/",
+        destination
+      ]
+
+      Output.command(cmd.join(" "))
+      unless @dry_run || system(*cmd)
+        raise Deploio::Error, "Failed to download MySQL backup for database '#{name}'."
+      end
+
+      nil
+    end
+
+    private
+
+    def resolve_db_name(db_name)
+      if databases.empty?
+        raise Deploio::Error,
+          "No databases found in MySQL instance; cannot download backup."
+      elsif databases.size > 1 && db_name.nil?
+        raise Deploio::Error,
+          "Multiple databases found in MySQL instance\n" \
+            "Databases: #{databases.join(", ")}\n" \
+            "Please specify the database name using the --db_name option."
+      end
+
+      db_name || databases.first
+    end
+
+    def databases
+      @databases ||= (
+        @data.dig("status", "atProvider", "databases")&.keys || []
+      ).reject { |db| db.strip.empty? }
+    end
+
+    def fqdn
+      value = @data.dig("status", "atProvider", "fqdn")
+
+      if value.nil? || value.empty?
+        raise Deploio::Error,
+          "Database FQDN not found; cannot reach the database server."
+      end
+
+      value
+    end
+  end
+end

data/lib/deploio/mysql_database_backup_service.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Deploio
+  class MysqlDatabaseBackupService
+    DEFAULT_EXTENSION = ".sql.zst"
+    BACKUP_SCHEDULE_LABEL = "DatabaseBackupSchedule"
+
+    def initialize(
+      db_ref:,
+      data:,
+      nctl_client:,
+      name: nil,
+      rclone_client_factory: nil
+    )
+      @db_ref = db_ref
+      @data = data || {}
+      @nctl = nctl_client
+      @name = name || db_ref.full_name
+      @rclone_client_factory = rclone_client_factory || method(:build_rclone_client)
+    end
+
+    def default_destination
+      "./#{@name}-latest-backup#{DEFAULT_EXTENSION}"
+    end
+
+    # Nine takes these backups on a schedule and there is no way to trigger one.
+    def capture
+      raise Deploio::UnsupportedBackupOperationError,
+        "'#{@db_ref.full_name}' is an economy-tier database. Those are backed up automatically " \
+          "on their configured schedule and cannot be captured manually.\n" \
+          "Use 'deploio mysql backups list #{@name}' to see the available backups."
+    end
+
+    def backups
+      @backups ||= begin
+        entries = rclone.list(bucket_name)
+        entries = entries.select { |entry| own_backup?(entry["Name"].to_s) }
+        entries.sort_by { |entry| entry["ModTime"].to_s }.reverse
+      end
+    end
+
+    def download(destination:, db_name: nil)
+      backup = backups.first
+
+      unless backup
+        raise Deploio::Error,
+          "No backups found for '#{@db_ref.full_name}' in bucket '#{bucket_name}'."
+      end
+
+      rclone.download(bucket_name, backup["Name"], destination)
+      backup
+    end
+
+    private
+
+    def own_backup?(object_name)
+      return true if instance_name.empty?
+
+      object_name.start_with?("MySQLDatabase-#{instance_name}-")
+    end
+
+    def instance_name
+      @instance_name ||= @data.dig("status", "atProvider", "name").to_s
+    end
+
+    def bucket_name
+      bucket.dig("metadata", "name")
+    end
+
+    # The database resource holds no reference to its backup bucket.
+    # Therefore, match the bucket by name for now.
+    def bucket
+      @bucket ||= begin
+        candidates = @nctl
+          .get_services_by_type("bucket", project: @db_ref.project_name)
+          .select { |candidate| backup_bucket_for_database?(candidate) }
+
+        if candidates.empty?
+          raise Deploio::Error,
+            "No backup bucket found for '#{@db_ref.full_name}'. " \
+              "Check that backups are enabled for this database " \
+              "(spec.forProvider.backupSchedule)."
+        end
+
+        candidates.first
+      end
+    end
+
+    def backup_bucket_for_database?(bucket)
+      metadata = bucket["metadata"] || {}
+      labels = metadata["labels"] || {}
+
+      return false unless labels["nine.ch/controllerKind"] == BACKUP_SCHEDULE_LABEL
+
+      metadata["name"].to_s.match?(
+        /\Amysqldatabase-#{Regexp.escape(@db_ref.database_name)}-[0-9a-f]{7}\z/
+      )
+    end
+
+    def rclone
+      @rclone ||= @rclone_client_factory.call
+    end
+
+    def build_rclone_client
+      endpoint = bucket.dig("status", "atProvider", "endpoint")
+
+      if endpoint.nil? || endpoint.to_s.empty?
+        raise Deploio::Error,
+          "Backup bucket '#{bucket_name}' has no endpoint; cannot access backups."
+      end
+
+      client = RcloneClient.new(
+        endpoint: "https://#{endpoint}",
+        access_key: @nctl.get_bucket_user_access_key(
+          bucket_name,
+          project: @db_ref.project_name
+        ),
+        secret_key: @nctl.get_bucket_user_secret_key(
+          bucket_name,
+          project: @db_ref.project_name
+        ),
+        dry_run: @nctl.dry_run
+      )
+
+      client.check_requirements unless @nctl.dry_run
+      client
+    end
+  end
+end

data/lib/deploio/mysql_database_ref.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "did_you_mean"
+
+module Deploio
+  class MysqlDatabaseRef
+    attr_reader :project_name, :database_name
+
+    def initialize(input, available_databases: {})
+      @input = input.to_s
+      if available_databases.key?(@input)
+        match = available_databases[@input]
+        @project_name = match[:project_name]
+        @database_name = match[:database_name]
+      else
+        raise_not_found_error(@input, available_databases.keys)
+      end
+    end
+
+    def full_name = "#{project_name}-#{database_name}"
+    def to_s = full_name
+
+    def ==(other)
+      other.is_a?(self.class) && project_name == other.project_name && database_name == other.database_name
+    end
+
+    private
+
+    def raise_not_found_error(input, available_database_names)
+      message = "Database not found: '#{input}'"
+      suggestions = DidYouMean::SpellChecker.new(dictionary: available_database_names).correct(input) unless available_database_names.empty?
+      unless suggestions.nil? || suggestions.empty?
+        message += "\n\nDid you mean?"
+        suggestions.each { |suggestion| message += "\n  #{suggestion}" }
+      end
+      message += "\n\nRun 'deploio mysql' to see available MySQL databases."
+      raise Deploio::MysqlDatabaseNotFoundError, message
+    end
+  end
+end

data/lib/deploio/mysql_database_resolver.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Deploio
+  class MysqlDatabaseResolver
+    attr_reader :nctl, :current_org
+
+    def initialize(nctl_client:)
+      @nctl = nctl_client
+      @database_ref = MysqlDatabaseRef
+      @fetch_databases = -> { @nctl.get_all_mysql_databases }
+      @current_org = @nctl.current_org
+    end
+
+    def resolve(database_name: nil)
+      if database_name
+        return @database_ref.new(
+          database_name,
+          available_databases: available_databases_hash
+        )
+      end
+
+      raise Deploio::Error, "No database specified"
+    end
+
+    # Returns hash mapping database names -> { project_name:, database_name: }
+    def available_databases_hash
+      @available_databases_hash ||= begin
+        hash = {}
+        current_org = @nctl.current_org
+
+        @fetch_databases.call.each do |database|
+          metadata = database["metadata"] || {}
+          project_name = metadata["namespace"] || ""
+          database_name = metadata["name"]
+          full_name = "#{project_name}-#{database_name}"
+
+          hash[full_name] = {
+            project_name: project_name,
+            database_name: database_name
+          }
+
+          # Also index by short name (without org prefix) for convenience
+          if current_org && project_name.start_with?("#{current_org}-")
+            project = project_name.delete_prefix("#{current_org}-")
+            short_name = "#{project}-#{database_name}"
+
+            hash[short_name] ||= {
+              project_name: project_name,
+              database_name: database_name
+            }
+          end
+        end
+
+        hash
+      end
+    rescue
+      {}
+    end
+
+    def short_name_for(namespace, database_name)
+      org = current_org
+
+      if org && namespace.start_with?("#{org}-")
+        project = namespace.delete_prefix("#{org}-")
+        "#{project}-#{database_name}"
+      else
+        "#{namespace}-#{database_name}"
+      end
+    end
+  end
+end

data/lib/deploio/nctl_client.rb

@@ -100,6 +100,42 @@ module Deploio
       nil
     end
 
+    def get_all_mysql_databases
+      output_dedicated_dbs = capture("get", "mysql", "-A", "-o", "json")
+      output_shared_dbs = capture("get", "mysqldatabase", "-A", "-o", "json")
+      if (output_dedicated_dbs.nil? || output_dedicated_dbs.empty?) &&
+          (output_shared_dbs.nil? || output_shared_dbs.empty?)
+        return []
+      end
+
+      [
+        *JSON.parse(output_dedicated_dbs),
+        *JSON.parse(output_shared_dbs)
+      ]
+    rescue JSON::ParserError
+      []
+    end
+
+    def get_mysql_database(db_ref)
+      output = begin
+        capture("get", "mysql", db_ref.database_name,
+          "--project", db_ref.project_name, "-o", "json")
+      rescue Deploio::NctlError
+        nil
+      end
+
+      if output.nil? || output.empty?
+        output = capture("get", "mysqldatabase", db_ref.database_name,
+          "--project", db_ref.project_name, "-o", "json")
+      end
+
+      return nil if output.nil? || output.empty?
+
+      JSON.parse(output)
+    rescue JSON::ParserError
+      nil
+    end
+
     def get_apps_by_project(project)
       output = capture("get", "apps", "--project", project, "-o", "json")
       return [] if output.nil? || output.empty?

data/lib/deploio/templates/completion.bash.erb

@@ -0,0 +1,140 @@
+# Bash completion for <%= program_name %>-cli
+# Auto-generated from Thor command definitions
+# Enable with: eval "$(<%= program_name %> completion --shell bash)"
+
+# Dynamic completion for organizations
+_<%= program_name %>_orgs_list() {
+  <%= program_name %> orgs --json 2>/dev/null | ruby -rjson -e '
+    data = JSON.parse(STDIN.read) rescue []
+    data.each { |o| puts o["name"] }
+  ' 2>/dev/null
+}
+
+# Dynamic completion for projects
+_<%= program_name %>_projects_list() {
+  <%= program_name %> projects --json 2>/dev/null | ruby -rjson -e '
+    data = JSON.parse(STDIN.read) rescue []
+    orgs_json = `<%= program_name %> orgs --json 2>/dev/null` rescue "[]"
+    orgs = JSON.parse(orgs_json) rescue []
+    current_org = orgs.find { |o| o["current"] }&.fetch("name", nil)
+
+    data.each do |p|
+      name = p.dig("metadata", "name") || ""
+      short_name = current_org && name.start_with?("#{current_org}-") ? name.delete_prefix("#{current_org}-") : name
+      puts short_name
+    end
+  ' 2>/dev/null
+}
+
+# Dynamic completion for apps
+_<%= program_name %>_apps_list() {
+  <%= program_name %> apps --json 2>/dev/null | ruby -rjson -e '
+    data = JSON.parse(STDIN.read) rescue []
+    orgs_json = `<%= program_name %> orgs --json 2>/dev/null` rescue "[]"
+    orgs = JSON.parse(orgs_json) rescue []
+    current_org = orgs.find { |o| o["current"] }&.fetch("name", nil)
+
+    data.each do |a|
+      ns = a.dig("metadata", "namespace") || ""
+      name = a.dig("metadata", "name") || ""
+      project = current_org && ns.start_with?("#{current_org}-") ? ns.delete_prefix("#{current_org}-") : ns
+      puts "#{project}-#{name}"
+    end
+  ' 2>/dev/null
+}
+
+# Dynamic completion for PostgreSQL databases
+_<%= program_name %>_pg_databases_list() {
+  <%= program_name %> pg list --json 2>/dev/null | ruby -rjson -e '
+    data = JSON.parse(STDIN.read) rescue []
+    orgs_json = `<%= program_name %> orgs --json 2>/dev/null` rescue "[]"
+    orgs = JSON.parse(orgs_json) rescue []
+    current_org = orgs.find { |o| o["current"] }&.fetch("name", nil)
+
+    data.each do |db|
+      ns = db.dig("metadata", "namespace") || ""
+      name = db.dig("metadata", "name") || ""
+      project = current_org && ns.start_with?("#{current_org}-") ? ns.delete_prefix("#{current_org}-") : ns
+      puts "#{project}-#{name}"
+    end
+  ' 2>/dev/null
+}
+
+# Sets the candidates following a command path in the caller's scope
+_<%= program_name %>_context() {
+  commands="" flags="" value_flags="" positional="" passthrough=""
+  case "$1" in
+<% contexts.each do |context| -%>
+    "<%= context.path %>")
+<% unless context.commands.empty? -%>
+      commands="<%= context.commands.join(" ") %>"
+<% end -%>
+      flags="<%= flags(context).join(" ") %>"
+<% unless value_flags(context).empty? -%>
+      value_flags="<%= value_flags(context).join(" ") %>"
+<% end -%>
+<% if context.positional -%>
+      positional="<%= context.positional %>"
+<% end -%>
+<% if context.passthrough -%>
+      passthrough=1
+<% end -%>
+      ;;
+<% end -%>
+  esac
+}
+
+_<%= program_name %>_option_values() {
+  case "$1" in
+<% option_value_completers.each do |flags, completer| -%>
+    <%= flags.join("|") %>) <%= completer %> ;;
+<% end -%>
+  esac
+}
+
+_<%= program_name %>_includes() {
+  [[ -n "$2" && " $1 " == *" $2 "* ]]
+}
+
+# Main completion function
+_<%= program_name %>() {
+  local cur="${COMP_WORDS[COMP_CWORD]}" prev="${COMP_WORDS[COMP_CWORD-1]}"
+  local cmd="" args=0 word i
+  local commands flags value_flags positional passthrough
+  COMPREPLY=()
+
+  _<%= program_name %>_context ""
+  for ((i = 1; i < COMP_CWORD; i++)); do
+    word="${COMP_WORDS[i]}"
+    if [[ "$word" == "--" && -n "$passthrough" ]]; then
+      if ((i + 1 == COMP_CWORD)); then
+        COMPREPLY=($(compgen -c -- "$cur"))
+      else
+        COMPREPLY=($(compgen -f -- "$cur"))
+      fi
+      return
+    elif _<%= program_name %>_includes "$value_flags" "$word"; then
+      ((++i))
+    elif [[ "$word" == -* ]]; then
+      continue
+    elif ((args == 0)) && _<%= program_name %>_includes "$commands" "$word"; then
+      cmd="${cmd:+$cmd:}$word"
+      _<%= program_name %>_context "$cmd"
+    else
+      ((++args))
+    fi
+  done
+
+  if _<%= program_name %>_includes "$value_flags" "$prev"; then
+    COMPREPLY=($(compgen -W "$(_<%= program_name %>_option_values "$prev")" -- "$cur"))
+  elif [[ "$cur" == -* ]]; then
+    COMPREPLY=($(compgen -W "$flags" -- "$cur"))
+  elif ((args == 0)) && [[ -n "$commands" ]]; then
+    COMPREPLY=($(compgen -W "$commands" -- "$cur"))
+  elif ((args == 0)) && [[ -n "$positional" ]]; then
+    COMPREPLY=($(compgen -W "$($positional)" -- "$cur"))
+  fi
+}
+
+# Register the completion function
+complete -F _<%= program_name %> <%= program_name %> depl

data/lib/deploio/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Deploio
-  VERSION = "0.3.0"
+  VERSION = "0.4.1"
 end

data/lib/deploio.rb

@@ -7,12 +7,16 @@ require_relative "deploio/utils"
 require_relative "deploio/output"
 require_relative "deploio/app_ref"
 require_relative "deploio/pg_database_ref"
+require_relative "deploio/mysql_database_ref"
 require_relative "deploio/nctl_client"
 require_relative "deploio/rclone_client"
 require_relative "deploio/app_resolver"
 require_relative "deploio/pg_database_resolver"
 require_relative "deploio/postgres_backup_service"
 require_relative "deploio/postgres_database_backup_service"
+require_relative "deploio/mysql_database_resolver"
+require_relative "deploio/mysql_backup_service"
+require_relative "deploio/mysql_database_backup_service"
 require_relative "deploio/price_fetcher"
 require_relative "deploio/shared_options"
 require_relative "deploio/cli"
@@ -21,6 +25,7 @@ module Deploio
   class Error < StandardError; end
   class AppNotFoundError < Error; end
   class PgDatabaseNotFoundError < Error; end
+  class MysqlDatabaseNotFoundError < Error; end
   class NctlError < Error; end
   class RcloneError < Error; end
   class UnsupportedBackupOperationError < Error; end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: deploio-cli
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Renuo AG
@@ -46,6 +46,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".ruby-version"
+- CHANGELOG.md
 - README.md
 - Rakefile
 - bin/deploio
@@ -53,16 +54,24 @@ files:
 - lib/deploio.rb
 - lib/deploio/app_ref.rb
 - lib/deploio/app_resolver.rb
+- lib/deploio/bash_completion_generator.rb
 - lib/deploio/cli.rb
 - lib/deploio/commands/apps.rb
 - lib/deploio/commands/auth.rb
 - lib/deploio/commands/builds.rb
+- lib/deploio/commands/mysql.rb
+- lib/deploio/commands/mysql_backups.rb
 - lib/deploio/commands/orgs.rb
 - lib/deploio/commands/postgresql.rb
 - lib/deploio/commands/postgresql_backups.rb
 - lib/deploio/commands/projects.rb
 - lib/deploio/commands/services.rb
 - lib/deploio/completion_generator.rb
+- lib/deploio/helpers/backups_helper.rb
+- lib/deploio/mysql_backup_service.rb
+- lib/deploio/mysql_database_backup_service.rb
+- lib/deploio/mysql_database_ref.rb
+- lib/deploio/mysql_database_resolver.rb
 - lib/deploio/nctl_client.rb
 - lib/deploio/output.rb
 - lib/deploio/pg_database_ref.rb
@@ -72,15 +81,14 @@ files:
 - lib/deploio/price_fetcher.rb
 - lib/deploio/rclone_client.rb
 - lib/deploio/shared_options.rb
+- lib/deploio/templates/completion.bash.erb
 - lib/deploio/templates/completion.zsh.erb
 - lib/deploio/utils.rb
 - lib/deploio/version.rb
-- setup
 homepage: https://github.com/renuo/deploio-cli
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/renuo/deploio-cli
   source_code_uri: https://github.com/renuo/deploio-cli
   changelog_uri: https://github.com/renuo/deploio-cli/blob/main/CHANGELOG.md
 post_install_message: |+
@@ -88,6 +96,10 @@ post_install_message: |+
 
       eval "$(deploio completion)"
 
+  or this to your ~/.bashrc:
+
+      eval "$(deploio completion --shell bash)"
+
 rdoc_options: []
 require_paths:
 - lib
@@ -102,7 +114,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.2
 specification_version: 4
 summary: CLI for Deploio
 test_files: []

data/setup

@@ -1,115 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-APP_NAME=${APP_NAME:-deploio}
-INSTALL_DIR=${INSTALL_DIR:-"${HOME}/.local/bin"}
-RAW_BASE=${RAW_BASE:-"https://raw.githubusercontent.com/CuddlyBunion341/deploio-cli/main"}
-CLI_URL="${RAW_BASE}/deploio"
-MAN_URL="${RAW_BASE}/deploio.1"
-COMPLETION_URL="${RAW_BASE}/_deploio"
-COLOR_RESET='\033[0m'
-COLOR_GREEN='\033[0;32m'
-COLOR_YELLOW='\033[0;33m'
-COLOR_CYAN='\033[0;36m'
-COLOR_RED='\033[0;31m'
-print() { printf "%b\n" "$*"; }
-info() { print "${COLOR_CYAN}$*${COLOR_RESET}"; }
-success() { print "${COLOR_GREEN}$*${COLOR_RESET}"; }
-warn() { print "${COLOR_YELLOW}$*${COLOR_RESET}"; }
-err() { print "${COLOR_RED}$*${COLOR_RESET}" 1>&2; }
-have_cmd() { command -v "$1" >/dev/null 2>&1; }
-fetch() {
-  local url="$1" dest="$2"
-  if have_cmd curl; then
-    curl -fsSL "$url" -o "$dest"
-  elif have_cmd wget; then
-    wget -qO "$dest" "$url"
-  else
-    err "Need curl or wget to download: $url"
-    return 1
-  fi
-}
-main() {
-  info "Installing ${APP_NAME} (deplo.io app CLI)"
-  mkdir -p "$INSTALL_DIR"
-  tmp_file="$(mktemp -t ${APP_NAME}.XXXXXX)"
-  tmp_man="$(mktemp -t ${APP_NAME}-man.XXXXXX)"
-  tmp_completion="$(mktemp -t ${APP_NAME}-completion.XXXXXX)"
-  trap 'rm -f "$tmp_file" "$tmp_man" "$tmp_completion"' EXIT
-  
-  info "Downloading CLI from: $CLI_URL"
-  if ! fetch "$CLI_URL" "$tmp_file"; then
-    err "Failed to download ${APP_NAME} from $CLI_URL"
-    exit 1
-  fi
-  
-  info "Downloading man page from: $MAN_URL"
-  if ! fetch "$MAN_URL" "$tmp_man"; then
-    warn "Failed to download man page from $MAN_URL (continuing without man page)"
-  fi
-  
-  info "Downloading zsh completion from: $COMPLETION_URL"
-  if ! fetch "$COMPLETION_URL" "$tmp_completion"; then
-    warn "Failed to download completion script from $COMPLETION_URL (continuing without completions)"
-  fi
-  
-  install_path="${INSTALL_DIR}/${APP_NAME}"
-  mv "$tmp_file" "$install_path"
-  chmod +x "$install_path"
-  
-  # Install man page if download succeeded
-  if [[ -s "$tmp_man" ]]; then
-    man_dir="${HOME}/.local/share/man/man1"
-    mkdir -p "$man_dir"
-    mv "$tmp_man" "${man_dir}/${APP_NAME}.1"
-    success "Installed man page to ${man_dir}/${APP_NAME}.1"
-  fi
-  
-  # Install zsh completion if download succeeded
-  if [[ -s "$tmp_completion" ]]; then
-    completion_dir="${HOME}/.local/share/zsh/site-functions"
-    mkdir -p "$completion_dir"
-    mv "$tmp_completion" "${completion_dir}/_${APP_NAME}"
-    success "Installed zsh completion to ${completion_dir}/_${APP_NAME}"
-  fi
-  
-  # Create shorthand symlink 'depl'
-  (cd "$INSTALL_DIR" && ln -sf "$APP_NAME" depl)
-  success "Installed ${APP_NAME} to ${install_path}"
-  case ":${PATH}:" in
-    *":${INSTALL_DIR}:"*) ;;
-    *)
-      warn "${INSTALL_DIR} is not on your PATH. Add this to your ~/.zshrc:"
-      echo ""
-      echo "  export PATH=\"$INSTALL_DIR:\$PATH\""
-      echo ""
-      echo "Then reload your shell:"
-      echo "  source ~/.zshrc"
-      ;;
-  esac
-  
-  # Check if man page directory is in MANPATH
-  man_dir="${HOME}/.local/share/man"
-  if [[ -f "${man_dir}/man1/${APP_NAME}.1" ]] && [[ ":${MANPATH}:" != *":${man_dir}:"* ]]; then
-    warn "Man page installed but ${man_dir} is not in MANPATH."
-    echo "Add this to your ~/.zshrc to access man pages:"
-    echo ""
-    echo "  export MANPATH=\"${man_dir}:\$MANPATH\""
-    echo ""
-  fi
-  
-  # Check if completion directory is in fpath
-  completion_dir="${HOME}/.local/share/zsh/site-functions"
-  if [[ -f "${completion_dir}/_${APP_NAME}" ]]; then
-    echo "Zsh completion installed. To enable it, add this to your ~/.zshrc:"
-    echo ""
-    echo "  fpath=(\"${completion_dir}\" \$fpath)"
-    echo "  autoload -Uz compinit && compinit"
-    echo ""
-    echo "Then restart your shell or run: source ~/.zshrc"
-  fi
-  echo ""
-  info "Test the installation:"
-  echo "  ${APP_NAME} --dry-run list"
-  echo "  man ${APP_NAME}"
-}
-main "$@"