deploio-cli 0.1.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cfbf5567b54c09796623b3347320fa36f2999d18269bf4c3e9d36cbcdd15ee59
-  data.tar.gz: 81019ea594eded66c41bea3d5d9a696858f7f8f23023d160782e42e6b4028a01
+  metadata.gz: 1ef7a08d44a816dd88331bf7e007a536ef399b10afbf05229bef8e1e3137629e
+  data.tar.gz: d042f89dc44e64df49d599f1291f88151af45461132156af5c36486fa6408baa
 SHA512:
-  metadata.gz: 89924672422ab905ca8143a1a4ec51302057ffdcf58c26be1272dca11572a02a6a9f54ab48af8428171587ad9eceeddcc6af933dc40b4f3d6ab004a09b2da4e8
-  data.tar.gz: 977f56ebf1bca8df8f09a2759f0c67228b92f44243eacd4573035a5b34fb4e16abc3fcb90b2d18dee1576b744b191eedad23e3dcd58aecd73c9977ac90bdf71a
+  metadata.gz: 603238b92b6b23a32bf92f81a0a89a4cc0edbf8daad40519f1f165c095629ccb5f83775f01f0aae67541f6177f845ebc9797584fdcdb977425fa2307c2d8f98e
+  data.tar.gz: 2ac16607435cc562bcf3d3e94066002315bb06f198122fe6d088ee25782f9153106ab065e217f34a86d5aa99a4cb2d7d154876eabcc958266f2e74cc6771ef09

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
 
@@ -18,7 +19,7 @@ bundle install
 bundle exec bin/deploio --help
 ```
 
-### As a gem (coming soon)
+### As a gem
 
 ```bash
 gem install deploio-cli
@@ -71,8 +72,32 @@ AUTHENTICATION
 
 APPS
   deploio apps                    List all apps
+  deploio apps -p PROJECT         List apps in a specific project
+  deploio apps --chf              Show estimated monthly price (CHF) for each app
   deploio apps:info -a APP        Show app details
 
+PROJECTS
+  deploio projects                List all projects
+  deploio projects --chf          Show estimated total price (CHF) for each project
+
+BUILDS
+  deploio builds                  List all builds
+  deploio builds -a APP           List builds for a specific app
+
+SERVICES
+  deploio services                            List all services
+  deploio services -p PROJECT                 List services in a specific project
+  deploio services -p PROJECT --url List services with connection URLs (requires -p)
+  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
@@ -111,11 +136,58 @@ deploio auth:whoami
 # List all apps
 deploio apps
 
+# List apps in a specific project
+deploio apps -p myproject
+
+# List apps with estimated monthly prices (CHF)
+deploio apps --chf
+
 # Show app info
 deploio apps:info -a myproject-staging
+```
+
+### Working with projects
+
+```bash
+# List all projects
+deploio projects
+
+# List projects with estimated total prices (apps + services)
+deploio projects --chf
+
+# Output as JSON
+deploio projects --json
+```
+
+```
+
+### Working with services
+
+```bash
+# List all services
+deploio services
 
+# List services in a specific project
+deploio services -p myproject
+
+# List services with estimated monthly prices (CHF)
+deploio services --chf
+
+# List services with connection URLs (requires --project)
+deploio services -p myproject --url
+
+# Show which apps are connected to each service (requires --project)
+deploio services -p myproject --connected-apps
+
+# Combine options
+deploio services -p myproject --url --connected-apps --chf
+
+# Output as JSON
+deploio services --json
 ```
 
+Note: Prices (--chf) are fetched from the Nine calculator API and cached locally in `~/.deploio/prices.json` for 24 hours.
+
 ### Logs and execution
 
 ```bash

data/lib/deploio/cli.rb

@@ -3,7 +3,12 @@
 require "thor"
 require_relative "commands/auth"
 require_relative "commands/apps"
+require_relative "commands/builds"
 require_relative "commands/orgs"
+require_relative "commands/projects"
+require_relative "commands/services"
+require_relative "commands/postgresql_backups"
+require_relative "commands/postgresql"
 require_relative "completion_generator"
 
 module Deploio
@@ -40,6 +45,18 @@ module Deploio
     desc "orgs COMMAND", "Organization management commands"
     subcommand "orgs", Commands::Orgs
 
+    desc "projects COMMAND", "Project management commands"
+    subcommand "projects", Commands::Projects
+
+    desc "services COMMAND", "Service management commands"
+    subcommand "services", Commands::Services
+
+    desc "builds COMMAND", "Build management commands"
+    subcommand "builds", Commands::Builds
+
+    desc "pg COMMAND", "PostgreSQL database management commands"
+    subcommand "pg", Commands::PostgreSQL
+
     # Shortcut for auth:login
     desc "login", "Authenticate with nctl (alias for auth:login)"
     def login
@@ -83,6 +100,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/apps.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../price_fetcher"
+
 module Deploio
   module Commands
     class Apps < Thor
@@ -11,10 +13,15 @@ module Deploio
 
       default_task :list
 
-      desc "list", "List all apps"
+      desc "list", "List apps (all or filtered by project)"
+      method_option :project, aliases: "-p", type: :string,
+        desc: "Filter by project name"
+      method_option :chf, type: :boolean, default: false,
+        desc: "Show estimated price (CHF) for each app"
       def list
         setup_options
-        raw_apps = @nctl.get_all_apps
+        project = merged_options[:project] ? resolve_project(merged_options[:project]) : nil
+        raw_apps = project ? @nctl.get_apps_by_project(project) : @nctl.get_all_apps
 
         if options[:json]
           puts JSON.pretty_generate(raw_apps)
@@ -22,11 +29,14 @@ module Deploio
         end
 
         if raw_apps.empty?
-          Output.warning("No apps found") unless merged_options[:dry_run]
+          msg = project ? "No apps found in project #{merged_options[:project]}" : "No apps found"
+          Output.warning(msg) unless merged_options[:dry_run]
           return
         end
 
         resolver = AppResolver.new(nctl_client: @nctl)
+        show_price = merged_options[:chf]
+        price_fetcher = PriceFetcher.new if show_price
 
         rows = raw_apps.map do |app|
           metadata = app["metadata"] || {}
@@ -37,15 +47,24 @@ module Deploio
           namespace = metadata["namespace"] || ""
           name = metadata["name"] || ""
 
-          [
+          row = [
             resolver.short_name_for(namespace, name),
             project_from_namespace(namespace, resolver.current_org),
             presence(config["size"], default: "micro"),
             presence(git["revision"])
           ]
+
+          if show_price
+            price = price_fetcher.price_for_app(app)
+            row << price_fetcher.format_price(price)
+          end
+
+          row
         end
 
-        Output.table(rows, headers: %w[APP PROJECT SIZE REVISION])
+        headers = %w[APP PROJECT SIZE REVISION]
+        headers << "PRICE" if show_price
+        Output.table(rows, headers: headers)
       end
 
       desc "info", "Show app details"
@@ -93,10 +112,13 @@ module Deploio
         ready_condition = conditions.find { |c| c["type"] == "Ready" }
         synced_condition = conditions.find { |c| c["type"] == "Synced" }
 
+        default_url = at_provider["defaultURL"]
+        default_url_display = default_url ? Output.link(default_url) : "-"
+
         Output.table([
           ["Ready", presence(ready_condition&.dig("status"))],
           ["Synced", presence(synced_condition&.dig("status"))],
-          ["Default URL", presence(at_provider["defaultURL"])],
+          ["Default URL", default_url_display],
           ["Latest Build", presence(at_provider["latestBuild"])],
           ["Latest Release", presence(at_provider["latestRelease"])]
         ])
@@ -106,7 +128,7 @@ module Deploio
         hosts = for_provider["hosts"] || []
         if hosts.any?
           Output.header("Hosts")
-          Output.table(hosts.map { |h| [presence(h)] })
+          Output.list(hosts.map { |h| Output.link(h, "https://#{h}") })
           puts
         end
 

data/lib/deploio/commands/builds.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Deploio
+  module Commands
+    class Builds < Thor
+      include SharedOptions
+
+      namespace "builds"
+
+      class_option :json, type: :boolean, default: false, desc: "Output as JSON"
+
+      desc "list", "List builds (all or for a specific app)"
+      def list
+        setup_options
+
+        if merged_options[:app]
+          list_for_app
+        else
+          list_all
+        end
+      end
+
+      desc "logs [BUILD_NAME]", "Show build logs"
+      method_option :tail, aliases: "-t", type: :boolean, default: false, desc: "Stream logs continuously"
+      method_option :lines, aliases: "-n", type: :numeric, default: 5000, desc: "Number of lines to show"
+      def logs(build_name = nil)
+        setup_options
+        app_ref = merged_options[:app] ? resolve_app : nil
+        @nctl.build_logs(build_name, app_ref: app_ref, tail: options[:tail], lines: options[:lines])
+      end
+
+      private
+
+      def list_all
+        raw_builds = @nctl.get_all_builds
+
+        if options[:json]
+          puts JSON.pretty_generate(raw_builds)
+          return
+        end
+
+        if raw_builds.empty?
+          Output.warning("No builds found") unless merged_options[:dry_run]
+          return
+        end
+
+        resolver = AppResolver.new(nctl_client: @nctl)
+
+        rows = raw_builds.map do |build|
+          metadata = build["metadata"] || {}
+          spec = build["spec"] || {}
+          status = build["status"] || {}
+          for_provider = spec["forProvider"] || {}
+          git = for_provider["sourceConfig"]&.dig("git") || {}
+          at_provider = status["atProvider"] || {}
+          labels = metadata["labels"] || {}
+          app_name = labels["application.apps.nine.ch/name"] || "-"
+          namespace = metadata["namespace"] || ""
+
+          [
+            resolver.short_name_for(namespace, app_name),
+            presence(metadata["name"]),
+            format_status(at_provider["buildStatus"]),
+            presence(git["revision"], max_length: 20),
+            format_timestamp(metadata["creationTimestamp"])
+          ]
+        end
+
+        Output.table(rows, headers: %w[APP BUILD STATUS REVISION CREATED])
+      end
+
+      def list_for_app
+        app_ref = resolve_app
+        raw_builds = @nctl.get_builds(app_ref)
+
+        if options[:json]
+          puts JSON.pretty_generate(raw_builds)
+          return
+        end
+
+        if raw_builds.empty?
+          Output.warning("No builds found for #{app_ref.full_name}") unless merged_options[:dry_run]
+          return
+        end
+
+        rows = raw_builds.map do |build|
+          metadata = build["metadata"] || {}
+          spec = build["spec"] || {}
+          status = build["status"] || {}
+          for_provider = spec["forProvider"] || {}
+          git = for_provider["sourceConfig"]&.dig("git") || {}
+          at_provider = status["atProvider"] || {}
+
+          [
+            presence(metadata["name"]),
+            format_status(at_provider["buildStatus"]),
+            presence(git["revision"], max_length: 30),
+            format_timestamp(metadata["creationTimestamp"])
+          ]
+        end
+
+        Output.table(rows, headers: %w[BUILD STATUS REVISION CREATED])
+      end
+
+      def presence(value, default: "-", max_length: nil)
+        return default if value.nil? || value.to_s.empty?
+
+        str = value.to_s
+        (max_length && str.length > max_length) ? "#{str[0, max_length - 3]}..." : str
+      end
+
+      def format_status(status)
+        return "-" if status.nil? || status.to_s.empty?
+
+        case status.downcase
+        when "succeeded", "success"
+          Output.color_enabled ? "\e[32m#{status}\e[0m" : status
+        when "error", "failed"
+          Output.color_enabled ? "\e[31m#{status}\e[0m" : status
+        when "building", "running", "pending"
+          Output.color_enabled ? "\e[33m#{status}\e[0m" : status
+        else
+          status
+        end
+      end
+
+      def format_timestamp(timestamp)
+        return "-" if timestamp.nil? || timestamp.to_s.empty?
+
+        time = Time.parse(timestamp)
+        time.strftime("%Y-%m-%d %H:%M")
+      rescue ArgumentError
+        timestamp
+      end
+    end
+  end
+end

data/lib/deploio/commands/postgresql.rb

@@ -0,0 +1,131 @@
+module Deploio
+  module Commands
+    class PostgreSQL < Thor
+      include SharedOptions
+
+      namespace "pg"
+
+      class_option :json, type: :boolean, default: false, desc: "Output as JSON"
+
+      default_task :list
+
+      desc "list", "List all PostgreSQL databases"
+      def list
+        setup_options
+        raw_dbs = @nctl.get_all_pg_databases
+
+        if options[:json]
+          puts JSON.pretty_generate(raw_dbs)
+          return
+        end
+
+        if raw_dbs.empty?
+          Output.warning("No PostgreSQL databases found") unless merged_options[:dry_run]
+          return
+        end
+
+        resolver = PgDatabaseResolver.new(nctl_client: @nctl)
+
+        rows = raw_dbs.map do |pg|
+          kind = pg["kind"] || ""
+          metadata = pg["metadata"] || {}
+          spec = pg["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 PostgreSQL database details"
+      def info(name)
+        setup_options
+        resolver = PgDatabaseResolver.new(nctl_client: @nctl)
+        db_ref = resolver.resolve(database_name: name)
+        data = @nctl.get_pg_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("PostgreSQL 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 PostgreSQL database backups"
+      subcommand "backups", Commands::PostgreSQLBackups
+
+      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/postgresql_backups.rb

@@ -0,0 +1,96 @@
+require "time"
+
+module Deploio
+  module Commands
+    class PostgreSQLBackups < Thor
+      include SharedOptions
+
+      namespace "pg:backups"
+
+      DEDICATED_KIND = "Postgres"
+      ECONOMY_KIND = "PostgresDatabase"
+
+      desc "capture NAME", "Capture a new backup for the specified PostgreSQL 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 PostgreSQL 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 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)
+        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)
+        raise Deploio::Error, "Could not read database '#{db_ref.full_name}'." if data.nil?
+
+        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
+      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