deploio-cli 0.1.1 → 0.3.0

data/lib/deploio/commands/projects.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require_relative "../price_fetcher"
+
+module Deploio
+  module Commands
+    class Projects < Thor
+      include SharedOptions
+
+      namespace "projects"
+
+      class_option :json, type: :boolean, default: false, desc: "Output as JSON"
+
+      default_task :list
+
+      desc "list", "List all projects"
+      method_option :chf, type: :boolean, default: false,
+        desc: "Show estimated total price (CHF) for each project with breakdown"
+      def list
+        setup_options
+        raw_projects = @nctl.get_projects
+
+        if options[:json]
+          puts JSON.pretty_generate(raw_projects)
+          return
+        end
+
+        if raw_projects.empty?
+          Output.warning("No projects found") unless merged_options[:dry_run]
+          return
+        end
+
+        current_org = @nctl.current_org
+        show_price = merged_options[:chf]
+
+        if show_price
+          display_projects_with_breakdown(raw_projects, current_org)
+        else
+          display_projects_simple(raw_projects, current_org)
+        end
+      end
+
+      private
+
+      def display_projects_simple(raw_projects, current_org)
+        rows = raw_projects.map do |project|
+          metadata = project["metadata"] || {}
+          spec = project["spec"] || {}
+          labels = metadata["labels"] || {}
+          namespace = metadata["namespace"] || ""
+          name = metadata["name"] || ""
+
+          display_name = compute_display_name(spec, labels, name, namespace)
+
+          [
+            presence(name),
+            presence(display_name, default: ""),
+            project_from_namespace(namespace, current_org)
+          ]
+        end
+
+        Output.table(rows, headers: ["PROJECT", "DISPLAY NAME", "ORGANIZATION"])
+      end
+
+      def display_projects_with_breakdown(raw_projects, current_org)
+        price_fetcher = PriceFetcher.new
+        all_apps = @nctl.get_all_apps
+        all_services = @nctl.get_all_services
+
+        # Group apps and services by project
+        apps_by_project = all_apps.group_by { |a| a.dig("metadata", "namespace") }
+        services_by_project = all_services.group_by { |s| s.dig("metadata", "namespace") }
+
+        groups = {}
+        grand_total = 0
+
+        raw_projects.sort_by { |p| p.dig("metadata", "name") || "" }.each do |project|
+          metadata = project["metadata"] || {}
+          spec = project["spec"] || {}
+          labels = metadata["labels"] || {}
+          name = metadata["name"] || ""
+
+          display_name = compute_display_name(spec, labels, name, metadata["namespace"] || "")
+          project_label = display_name.empty? ? name : display_name
+
+          project_apps = apps_by_project[name] || []
+          project_services = services_by_project[name] || []
+
+          # Skip projects with no apps or services
+          next if project_apps.empty? && project_services.empty?
+
+          rows = []
+          project_total = 0
+
+          # Add apps
+          project_apps.sort_by { |a| a.dig("metadata", "name") || "" }.each do |app|
+            app_name = app.dig("metadata", "name") || "-"
+            app_spec = app["spec"] || {}
+            for_provider = app_spec["forProvider"] || {}
+            config = for_provider["config"] || {}
+            status = app["status"] || {}
+            at_provider = status["atProvider"] || {}
+
+            size = config["size"] || "micro"
+            replicas = at_provider["replicas"] || for_provider["replicas"] || 1
+
+            price = price_fetcher.price_for_app(app) || 0
+            project_total += price
+
+            size_info = (replicas.to_i > 1) ? "#{size} ×#{replicas}" : size
+            rows << [project_label, app_name, "app", size_info, format_price(price)]
+          end
+
+          # Add services
+          project_services.sort_by { |s| [s["_type"] || "", s.dig("metadata", "name") || ""] }.each do |service|
+            service_name = service.dig("metadata", "name") || "-"
+            service_type = service["_type"] || "-"
+            service_spec = service["spec"] || {}
+
+            price = price_fetcher.price_for_service(service_type, service_spec) || 0
+            project_total += price
+
+            size_info = service_size_info(service_type, service_spec)
+            rows << [project_label, service_name, service_type, size_info, format_price(price)]
+          end
+
+          # Add subtotal row
+          rows << [project_label, "SUBTOTAL", "", "", format_price(project_total)]
+          grand_total += project_total
+
+          groups[project_label] = rows
+        end
+
+        if groups.empty?
+          Output.warning("No apps or services found")
+          return
+        end
+
+        Output.grouped_table(groups, headers: %w[PROJECT NAME TYPE SIZE PRICE])
+        puts
+        puts "Grand Total: CHF #{grand_total}/mo"
+      end
+
+      def service_size_info(type, spec)
+        for_provider = spec["forProvider"] || {}
+
+        case type
+        when "postgres", "mysql"
+          for_provider["machineType"] || for_provider["singleDBMachineType"] || "-"
+        when "keyvaluestore"
+          for_provider["memorySize"] || "-"
+        else
+          "-"
+        end
+      end
+
+      def format_price(price)
+        (price > 0) ? "CHF #{price}/mo" : "-"
+      end
+
+      private
+
+      def compute_display_name(spec, _labels, name, namespace)
+        # Use displayName from spec if available (enriched from table output)
+        return spec["displayName"] if spec["displayName"] && !spec["displayName"].empty?
+
+        # Fallback: strip namespace prefix from name
+        # e.g., "n10518-mytextur" -> "mytextur"
+        name.delete_prefix("#{namespace}-")
+      end
+
+      def presence(value, default: "-")
+        (value.nil? || value.to_s.empty?) ? default : value
+      end
+
+      def project_from_namespace(namespace, current_org)
+        if current_org && namespace == current_org
+          "#{namespace} (current)"
+        else
+          namespace
+        end
+      end
+    end
+  end
+end

data/lib/deploio/commands/services.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require_relative "../price_fetcher"
+
+module Deploio
+  module Commands
+    class Services < Thor
+      include SharedOptions
+
+      namespace "services"
+
+      class_option :json, type: :boolean, default: false, desc: "Output as JSON"
+
+      default_task :list
+
+      desc "list", "List services (all or filtered by project)"
+      method_option :project, aliases: "-p", type: :string,
+        desc: "Filter by project name"
+      method_option :url, aliases: "-u", type: :boolean, default: false,
+        desc: "Show connection URL for each service (requires --project)"
+      method_option :connected_apps, aliases: "-c", type: :boolean, default: false,
+        desc: "Show apps connected to each service (requires --project)"
+      method_option :chf, type: :boolean, default: false,
+        desc: "Show estimated price (CHF) for each service"
+      def list
+        setup_options
+
+        validate_project_required_options!
+
+        project = merged_options[:project] ? resolve_project(merged_options[:project]) : nil
+        all_services = @nctl.get_all_services(project: project)
+
+        if options[:json]
+          puts JSON.pretty_generate(all_services)
+          return
+        end
+
+        if all_services.empty?
+          msg = project ? "No services found in project #{merged_options[:project]}" : "No services found"
+          Output.warning(msg) unless merged_options[:dry_run]
+          return
+        end
+
+        show_url = merged_options[:url]
+        show_connected_apps = merged_options[:connected_apps]
+        show_price = merged_options[:chf]
+        current_org = @nctl.current_org
+
+        # Pre-fetch apps and their env vars if we need to show connected apps
+        apps_by_project = {}
+        if show_connected_apps
+          all_services.map { |s| s.dig("metadata", "namespace") }.uniq.each do |ns|
+            apps_by_project[ns] = @nctl.get_apps_by_project(ns)
+          end
+        end
+
+        # Initialize price fetcher if needed
+        price_fetcher = PriceFetcher.new if show_price
+
+        # Build rows and group by project
+        grouped_rows = {}
+        all_services.each do |service|
+          metadata = service["metadata"] || {}
+          status = service["status"] || {}
+          spec = service["spec"] || {}
+          conditions = status["conditions"] || []
+          ready_condition = conditions.find { |c| c["type"] == "Ready" }
+
+          namespace = metadata["namespace"] || ""
+          name = metadata["name"] || ""
+          type = service["_type"] || "-"
+          project_name = project_from_namespace(namespace, current_org)
+
+          row = [
+            short_service_name(namespace, name, current_org),
+            project_name,
+            type,
+            presence(ready_condition&.dig("status"))
+          ]
+
+          if show_price
+            price = price_fetcher.price_for_service(type, spec)
+            row << price_fetcher.format_price(price)
+          end
+
+          # Get URL if needed (for display or for connected apps search)
+          url = nil
+          if show_url || show_connected_apps
+            url = @nctl.get_service_connection_string(type, name, project: namespace)
+          end
+
+          row << presence(url) if show_url
+
+          if show_connected_apps
+            connected = find_connected_apps(apps_by_project[namespace] || [], url)
+            row << (connected.empty? ? "-" : connected.join(", "))
+          end
+
+          grouped_rows[project_name] ||= []
+          grouped_rows[project_name] << row
+        end
+
+        # Sort groups by project name
+        sorted_groups = grouped_rows.sort.to_h
+
+        headers = %w[SERVICE PROJECT TYPE READY]
+        headers << "PRICE" if show_price
+        headers << "URL" if show_url
+        headers << "CONNECTED APPS" if show_connected_apps
+        Output.grouped_table(sorted_groups, headers: headers)
+      end
+
+      private
+
+      def validate_project_required_options!
+        options_requiring_project = []
+        options_requiring_project << "--url" if merged_options[:url]
+        options_requiring_project << "--connected-apps" if merged_options[:connected_apps]
+
+        return if options_requiring_project.empty? || merged_options[:project]
+
+        Output.error("The #{options_requiring_project.join(" and ")} option(s) require --project to be specified")
+        Output.info("Fetching this data for all services is too slow. Please filter by project first.")
+        Output.info("Example: deploio services -p myproject #{options_requiring_project.first}")
+        exit 1
+      end
+
+      def find_connected_apps(apps, service_url)
+        return [] if service_url.nil? || service_url.empty?
+
+        apps.filter_map do |app|
+          app_name = app.dig("metadata", "name")
+          env_vars = app.dig("spec", "forProvider", "config", "env") || []
+
+          # Check if any env var value contains the service URL (or a recognizable part of it)
+          connected = env_vars.any? do |env|
+            value = env["value"].to_s
+            next false if value.empty?
+
+            # Match the service URL or its host part
+            value.include?(service_url) || url_host_matches?(value, service_url)
+          end
+
+          app_name if connected
+        end
+      end
+
+      def url_host_matches?(env_value, service_url)
+        # Extract host from service URL and check if it appears in the env value
+        # This handles cases where the env var might have a slightly different URL format
+        service_host = extract_host(service_url)
+        return false if service_host.nil?
+
+        env_value.include?(service_host)
+      end
+
+      def extract_host(url)
+        # Extract host from URLs like:
+        # postgres://user:pass@host.example.com/db
+        # rediss://:token@host.example.com:6379
+        # mysql://user:pass@host.example.com:3306/db
+        match = url.match(%r{://[^/]*@([^/:]+)})
+        match&.[](1)
+      end
+
+      def presence(value, default: "-")
+        return default if value.nil? || value.to_s.empty?
+
+        value.to_s
+      end
+
+      def short_service_name(namespace, name, current_org)
+        project = project_from_namespace(namespace, current_org)
+        "#{project}-#{name}"
+      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/completion_generator.rb

@@ -51,13 +51,18 @@ module Deploio
     def default_option_completers
       {
         "app" => "app:_#{program_name}_apps_list",
-        "size" => "size:(micro mini standard)"
+        "size" => "size:(micro mini standard)",
+        "project" => "project:_#{program_name}_projects_list"
       }
     end
 
     def default_positional_completers
       {
-        "orgs:set" => "'1:organization:_#{program_name}_orgs_list'"
+        "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
 
@@ -71,10 +76,24 @@ module Deploio
         commands = klass.commands.except("help").map do |cmd_name, cmd|
           [cmd_name, cmd.description, cmd.options]
         end
-        [name, commands, klass.class_options]
+        default_task = klass.default_command if klass.respond_to?(:default_command)
+        [name, commands, klass.class_options, default_task, klass]
       end
     end
 
+    def nested_subcommands
+      result = []
+      cli_class.subcommand_classes.each do |parent_name, parent_klass|
+        parent_klass.subcommand_classes.each do |nested_name, nested_klass|
+          commands = nested_klass.commands.except("help").map do |cmd_name, cmd|
+            [cmd_name, cmd.description, cmd.options]
+          end
+          result << ["#{parent_name}:#{nested_name}", commands, nested_klass.class_options]
+        end
+      end
+      result
+    end
+
     def main_commands
       cli_class.commands.except("help").map do |name, cmd|
         [name, cmd.description]

data/lib/deploio/nctl_client.rb

@@ -26,6 +26,15 @@ module Deploio
         *args)
     end
 
+    def build_logs(build_name, app_ref: nil, tail: false, lines: 5000)
+      args = ["--lines=#{lines}"]
+      args << "-f" if tail
+      if app_ref
+        args += ["--project", app_ref.project_name, "-a", app_ref.app_name]
+      end
+      exec_passthrough("logs", "build", *[build_name].compact, *args)
+    end
+
     def exec_command(app_ref, command)
       exec_passthrough("exec", "app", app_ref.app_name,
         "--project", app_ref.project_name,
@@ -55,32 +64,145 @@ module Deploio
       {}
     end
 
-    def get_app_stats(app_ref)
-      capture("get", "app", app_ref.app_name,
+    def get_all_pg_databases
+      output_dedicated_dbs = capture("get", "postgres", "-A", "-o", "json")
+      output_shared_dbs = capture("get", "postgresdatabase", "-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_pg_database(db_ref)
+      output = begin
+        capture("get", "postgres", db_ref.database_name,
+          "--project", db_ref.project_name, "-o", "json")
+      rescue Deploio::NctlError
+        nil
+      end
+
+      if output.nil? || output.empty?
+        output = capture("get", "postgresdatabase", 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 = JSON.parse(output)
+      data.is_a?(Array) ? data : (data["items"] || [])
+    rescue JSON::ParserError
+      []
+    end
+
+    def get_all_builds
+      output = capture("get", "builds", "-A", "-o", "json")
+      return [] if output.nil? || output.empty?
+
+      data = JSON.parse(output)
+      builds = data.is_a?(Array) ? data : (data["items"] || [])
+      # Sort by creation timestamp descending (newest first)
+      builds.sort_by { |b| b.dig("metadata", "creationTimestamp") || "" }.reverse
+    rescue JSON::ParserError
+      []
+    end
+
+    # @param app_ref [Deploio::AppRef]
+    def get_builds(app_ref)
+      output = capture("get", "builds",
         "--project", app_ref.project_name,
-        "-o", "stats")
+        "-a", app_ref.app_name,
+        "-o", "json")
+      return [] if output.nil? || output.empty?
+
+      data = JSON.parse(output)
+      builds = data.is_a?(Array) ? data : (data["items"] || [])
+      # Sort by creation timestamp descending (newest first)
+      builds.sort_by { |b| b.dig("metadata", "creationTimestamp") || "" }.reverse
+    rescue JSON::ParserError
+      []
+    end
+
+    def get_all_services(project: nil)
+      service_types = %w[keyvaluestore postgres postgresdatabases mysql mysqldatabases opensearch bucket]
+      all_services = []
+
+      service_types.each do |type|
+        services = get_services_by_type(type, project: project)
+        services.each { |s| s["_type"] = type }
+        all_services.concat(services)
+      end
+
+      all_services
     end
 
-    def edit_app(app_ref)
-      exec_passthrough("edit", "app", app_ref.app_name,
-        "--project", app_ref.project_name)
+    def get_services_by_type(type, project: nil)
+      args = ["get", type]
+      if project
+        args += ["--project", project]
+      else
+        args << "-A"
+      end
+      args += ["-o", "json"]
+
+      output = capture(*args)
+      return [] if output.nil? || output.empty?
+
+      data = JSON.parse(output)
+      data.is_a?(Array) ? data : (data["items"] || [])
+    rescue JSON::ParserError
+      []
+    rescue Deploio::NctlError
+      []
+    end
+
+    def get_service(type, name, project:)
+      output = capture("get", type, name, "--project", project, "-o", "json")
+      return nil if output.nil? || output.empty?
+
+      JSON.parse(output)
+    rescue JSON::ParserError
+      nil
+    rescue Deploio::NctlError
+      nil
     end
 
-    def create_app(project, app_name, git_url:, git_revision:, size: "mini")
-      run("create", "app", app_name,
-        "--project", project,
-        "--git-url", git_url,
-        "--git-revision", git_revision,
-        "--size", size)
+    def get_service_connection_string(type, name, project:)
+      case type
+      when "postgres", "mysql", "postgresdatabases", "mysqldatabases"
+        capture("get", type, name, "--project", project, "--print-connection-string").strip
+      when "keyvaluestore"
+        build_keyvaluestore_connection_string(name, project)
+      when "opensearch"
+        build_opensearch_connection_string(name, project)
+      when "bucket"
+        build_bucket_url(name, project)
+      end
+    rescue Deploio::NctlError
+      nil
     end
 
-    def delete_app(app_ref)
-      run("delete", "app", app_ref.app_name,
-        "--project", app_ref.project_name)
+    def get_bucket_user_access_key(name, project:)
+      capture("get", "bucketuser", name, "--project", project, "--print-access-key").strip
     end
 
-    def create_project(project_name)
-      run("create", "project", project_name)
+    def get_bucket_user_secret_key(name, project:)
+      capture("get", "bucketuser", name, "--project", project, "--print-secret-key").strip
     end
 
     def get_projects
@@ -88,11 +210,42 @@ module Deploio
       return [] if output.nil? || output.empty?
 
       data = JSON.parse(output)
-      data.is_a?(Array) ? data : (data["items"] || [])
+      projects = data.is_a?(Array) ? data : (data["items"] || [])
+
+      display_names = get_project_display_names
+      projects.each do |project|
+        name = project.dig("metadata", "name")
+        if display_names[name]
+          project["spec"] ||= {}
+          project["spec"]["displayName"] = display_names[name]
+        end
+      end
+
+      projects
     rescue JSON::ParserError
       []
     end
 
+    # Enrich with display names from table output (since JSON excludes spec.displayName)
+    # TODO: https://github.com/ninech/nctl/pull/339
+    def get_project_display_names
+      output = capture("get", "projects")
+      return {} if output.nil? || output.empty?
+
+      display_names = {}
+      output.each_line.drop(1).each do |line| # Skip header
+        parts = line.strip.split(" ").map(&:strip)
+        next if parts.length < 2
+
+        project_name = parts[0]
+        display_name = parts[1]
+        display_names[project_name] = display_name unless display_name == "<none>"
+      end
+      display_names
+    rescue Deploio::NctlError
+      {}
+    end
+
     def get_orgs
       output = capture("auth", "whoami")
       return [] if output.nil? || output.empty?
@@ -178,6 +331,7 @@ module Deploio
         Output.command(cmd.join(" "))
         ""
       else
+        puts "> #{cmd.join(" ")}" if ENV["DEPLOIO_DEBUG"]
         stdout, stderr, status = Open3.capture3(*cmd)
         unless status.success?
           raise Deploio::NctlError, "nctl command failed: #{stderr}"
@@ -210,5 +364,38 @@ module Deploio
       raise Deploio::NctlError,
         "nctl version #{version} is too old. Need #{REQUIRED_VERSION}+. Run: brew upgrade nctl"
     end
+
+    def build_keyvaluestore_connection_string(name, project)
+      data = get_service("keyvaluestore", name, project: project)
+      return nil unless data
+
+      at_provider = data.dig("status", "atProvider") || {}
+      fqdn = at_provider["fqdn"]
+      return nil if fqdn.nil? || fqdn.empty?
+
+      token = capture("get", "keyvaluestore", name, "--project", project, "--print-token").strip
+      "rediss://:#{token}@#{fqdn}:6379"
+    end
+
+    def build_opensearch_connection_string(name, project)
+      data = get_service("opensearch", name, project: project)
+      return nil unless data
+
+      at_provider = data.dig("status", "atProvider") || {}
+      hosts = at_provider["hosts"] || []
+      return nil if hosts.empty?
+
+      user = capture("get", "opensearch", name, "--project", project, "--print-user").strip
+      password = capture("get", "opensearch", name, "--project", project, "--print-password").strip
+      host = hosts.first
+      "https://#{user}:#{password}@#{host}"
+    end
+
+    def build_bucket_url(name, project)
+      data = get_service("bucket", name, project: project)
+      return nil unless data
+
+      data.dig("status", "atProvider", "publicURL")
+    end
   end
 end