captive-cli 1.0.0 → 1.2.0

data/lib/captive/dashboard_response.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "errors"
+require_relative "validation_message"
+
+module Captive
+  # Traduit une réponse HTTP du dashboard : le corps JSON si elle réussit, sinon l'erreur
+  # que l'utilisateur peut comprendre.
+  class DashboardResponse
+    ERRORS = {
+      401 => [ AuthError, "Token invalide ou expiré. Lance : captive login" ],
+      403 => [ ForbiddenError, "Accès refusé : tu n'es pas Membre de l'Organization de cette app." ],
+      404 => [ NotFoundError, "App ou ressource introuvable" ],
+      503 => [ ServiceUnavailableError, "Service indisponible, réessaie" ],
+    }.freeze
+
+    def initialize(response)
+      @code = response.code.to_i
+      @body = response.body.to_s
+    end
+
+    def parse
+      return (@body.strip.empty? ? nil : JSON.parse(@body)) if @code.between?(200, 299)
+      raise ValidationError, ValidationMessage.new(json_body).to_s if @code == 422
+
+      klass, message = ERRORS.fetch(@code) { [ DashboardError, "Erreur dashboard (HTTP #{@code})" ] }
+      raise klass, message
+    end
+
+    private
+
+    def json_body
+      JSON.parse(@body)
+    rescue JSON::ParserError
+      {}
+    end
+  end
+end

data/lib/captive/errors.rb

@@ -4,13 +4,19 @@ module Captive
   class NoPodFound < StandardError; end
   class UnknownAppType < StandardError; end
   class PollTimeout < StandardError; end
-  class ImageYamlNotFound < StandardError; end
-  class WorkflowDispatchNotConfigured < StandardError; end
   class RestoreError < StandardError; end
   class DumpError < StandardError; end
   class ExecError < StandardError; end
   class AuthError < StandardError; end
   class NotAuthenticatedError < StandardError; end
   class NoTtyError < StandardError; end
-  class PlatformRootNotFound < StandardError; end
+  class MissingDependencyError < StandardError; end
+
+  # Réponses de l'API du dashboard qui ont un sens pour l'utilisateur : rattrapées par
+  # CLI.start et affichées sans trace.
+  class DashboardError < StandardError; end
+  class ForbiddenError < DashboardError; end
+  class NotFoundError < DashboardError; end
+  class ValidationError < DashboardError; end
+  class ServiceUnavailableError < DashboardError; end
 end

data/lib/captive/flux.rb

@@ -1,15 +1,24 @@
 # frozen_string_literal: true
 
 require "open3"
+require_relative "errors"
 
 module Captive
   class Flux
     def suspend_kustomization(name)
-      Open3.capture3("flux", "suspend", "kustomization", name)
+      capture("suspend", "kustomization", name)
     end
 
     def resume_kustomization(name)
-      Open3.capture3("flux", "resume", "kustomization", name)
+      capture("resume", "kustomization", name)
+    end
+
+    private
+
+    def capture(*args)
+      Open3.capture3("flux", *args)
+    rescue Errno::ENOENT
+      raise MissingDependencyError, "flux introuvable. Installe-le : brew install flux"
     end
   end
 end

data/lib/captive/kubectl.rb

@@ -237,12 +237,6 @@ module Captive
       raise
     end
 
-    def get_secret_data(namespace, secret_name)
-      json = run("get", "secret", secret_name, "-n", namespace, "-o", "json")
-      data = JSON.parse(json).fetch("data", {})
-      data.transform_values { |v| Base64.strict_decode64(v) }
-    end
-
     def get_secret_password(namespace, secret_name)
       encoded = run("get", "secret", secret_name, "-n", namespace,
                     "-o", "jsonpath={.data.password}").strip
@@ -291,10 +285,6 @@ module Captive
       status.success? ? out : nil
     end
 
-    def restart_deployment(namespace, name)
-      run("rollout", "restart", "deployment", "-n", namespace, name)
-    end
-
     def run(*args)
       out, err, status = Open3.capture3("kubectl", *kubeconfig_args, *args)
       raise AuthError, "Votre session a expiré. Reconnectez-vous avec : captive login" if err.include?("Unauthorized")

data/lib/captive/loader.rb

@@ -6,14 +6,18 @@ require "pastel"
 require "tty-prompt"
 
 require_relative "kubectl"
-require_relative "cluster_apps"
 require_relative "log_noise_filter"
 require_relative "presenter/ansi_stripper"
 require_relative "null_log_filter"
 require_relative "one_off_spec"
 require_relative "session_id"
 require_relative "poller"
-require_relative "gh_cli"
+require_relative "dashboard_api"
+require_relative "dashboard/apps_resource"
+require_relative "dashboard/env_vars_resource"
+require_relative "dashboard/scheduled_tasks_resource"
+require_relative "presenter/app_info"
+require_relative "presenter/scheduled_task"
 require_relative "activity_trail"
 require_relative "errors"
 require_relative "ui/spinner"
@@ -23,9 +27,7 @@ require_relative "commands/console"
 require_relative "commands/one_off_session"
 require_relative "commands/run"
 require_relative "commands/logs"
-require_relative "commands/apps_info"
 require_relative "commands/apps_restart"
-require_relative "commands/apps_rebuild"
 require_relative "commands/db_dump"
 require_relative "commands/db_restore"
 

data/lib/captive/presenter/app_info.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Captive
+  module Presenter
+    # La fiche d'une app telle que `captive apps info` l'affiche, à partir des lectures du
+    # dashboard : l'app, ses workloads, ses datastores et ses domaines.
+    class AppInfo
+      def initialize(paint:)
+        @paint = paint
+      end
+
+      def lines(app:, workloads:, datastores:, domains:)
+        [ @paint.bold(app["name"]),
+          "  Stage    : #{app["stage"] || "–"}",
+          "  Statut   : #{app["status"] || "–"}",
+          "  URL      : #{app["app_url"] || "–"}",
+          *section("Processus", workloads.map { |w| workload(w) }),
+          *section("Datastores", datastores.map { |d| "#{d["kind"]} #{d["name"]}" }),
+          *section("Domaines", domains.map { |d| domain(d) }), ]
+      end
+
+      private
+
+      def section(title, items)
+        [ "  #{title} :", *(items.empty? ? [ @paint.dim("    –") ] : items.map { |item| "    #{item}" }) ]
+      end
+
+      def workload(entry)
+        ready = "#{entry["ready"]}/#{entry["total"]}"
+        ready = @paint.yellow(ready) unless entry["ready"] == entry["total"]
+        "#{entry["name"]} #{ready} prêt(s), tier #{entry["tier"] || "–"}"
+      end
+
+      def domain(entry)
+        flags = [ ("principal" if entry["primary"]), ("en attente" if entry["pending"]) ].compact
+        flags.empty? ? entry["hostname"] : "#{entry["hostname"]} (#{flags.join(", ")})"
+      end
+    end
+  end
+end

data/lib/captive/presenter/scheduled_task.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Captive
+  module Presenter
+    # Une tâche planifiée sur une ligne, puis sa dernière exécution si elle a tourné.
+    class ScheduledTask
+      def initialize(paint:)
+        @paint = paint
+      end
+
+      def lines(task)
+        head = "#{@paint.bold(task["name"])}  #{task["schedule"]} (#{task["timezone"]})  " \
+               "#{task["mode"]} #{task["target"]}"
+        head += " #{@paint.yellow("[suspendue]")}" if task["suspended"]
+        [ head, last_run(task["last_run"]) ]
+      end
+
+      # Le cluster ne garde qu'une exécution réussie, cinq minutes : seule la dernière se lit.
+      def last_run(run)
+        return @paint.dim("    aucune exécution récente") unless run
+
+        "    dernière : #{run["started_at"]} → #{run["finished_at"] || "en cours"} #{outcome(run["outcome"])}"
+      end
+
+      private
+
+      def outcome(value)
+        case value
+        when "succeeded" then @paint.green(value)
+        when "failed", "timeout" then @paint.red(value)
+        else value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/captive/shell_completions.rb

@@ -2,11 +2,12 @@
 
 module Captive
   module ShellCompletions
-    ROOT_COMMANDS = %w[apps env db login whoami console run logs version completions].freeze
+    ROOT_COMMANDS = %w[apps env crons db login whoami console run logs version completions].freeze
 
     SUBCOMMANDS = {
       "apps" => %w[list info restart rebuild],
-      "env"  => %w[list],
+      "env"  => %w[list set unset],
+      "crons" => %w[list add edit rm suspend resume trigger runs],
       "db"   => %w[restore],
     }.freeze
 
@@ -21,6 +22,7 @@ module Captive
           case "$prev" in
             apps)  COMPREPLY=($(compgen -W "#{SUBCOMMANDS["apps"].join(" ")}" -- "$cur")); return ;;
             env)   COMPREPLY=($(compgen -W "#{SUBCOMMANDS["env"].join(" ")}" -- "$cur")); return ;;
+            crons) COMPREPLY=($(compgen -W "#{SUBCOMMANDS["crons"].join(" ")}" -- "$cur")); return ;;
             db)    COMPREPLY=($(compgen -W "#{SUBCOMMANDS["db"].join(" ")}" -- "$cur")); return ;;
           esac
 

data/lib/captive/token_file.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+
+module Captive
+  # Le jeton GitHub écrit par `captive login`, qui authentifie toutes les requêtes au dashboard.
+  class TokenFile
+    PATH = File.expand_path("~/.config/captive/token")
+
+    def initialize(path: PATH)
+      @path = path
+    end
+
+    def read
+      raise NotAuthenticatedError, "Pas de session active. Lance : captive login" unless File.exist?(@path)
+
+      File.read(@path).strip
+    end
+  end
+end

data/lib/captive/validation_message.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Captive
+  # Les refus de validation, un par ligne : `errors` est une liste de {field, message}, un
+  # objet champ → messages, ou absent (seul `error` dit alors ce qui ne va pas).
+  class ValidationMessage
+    def initialize(body)
+      @body = body.is_a?(Hash) ? body : {}
+    end
+
+    def to_s
+      ([ "Requête refusée :" ] + lines.map { |line| "  - #{line}" }).join("\n")
+    end
+
+    private
+
+    def lines
+      errors = @body["errors"]
+      case errors
+      when Array then errors.map { |e| e.is_a?(Hash) ? "#{e["field"]} : #{e["message"]}" : e.to_s }
+      when Hash  then errors.map { |field, messages| "#{field} : #{Array(messages).join(", ")}" }
+      else [ @body.fetch("error", "invalide").to_s ]
+      end
+    end
+  end
+end

data/lib/captive/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: captive-cli
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Captive Studio
@@ -106,29 +106,32 @@ files:
 - lib/captive/activity_trail.rb
 - lib/captive/cli.rb
 - lib/captive/cli/dependencies.rb
-- lib/captive/cluster_apps.rb
 - lib/captive/cluster_endpoint.rb
 - lib/captive/commands/apps_commands.rb
-- lib/captive/commands/apps_info.rb
-- lib/captive/commands/apps_rebuild.rb
 - lib/captive/commands/apps_restart.rb
 - lib/captive/commands/console.rb
+- lib/captive/commands/cron_declaration.rb
+- lib/captive/commands/crons_commands.rb
 - lib/captive/commands/db_commands.rb
 - lib/captive/commands/db_dump.rb
 - lib/captive/commands/db_exec.rb
 - lib/captive/commands/db_psql.rb
 - lib/captive/commands/db_restore.rb
 - lib/captive/commands/db_target.rb
-- lib/captive/commands/env_kube_commands.rb
-- lib/captive/commands/env_list_kube.rb
+- lib/captive/commands/env_commands.rb
+- lib/captive/commands/env_set.rb
 - lib/captive/commands/logs.rb
 - lib/captive/commands/one_off_session.rb
 - lib/captive/commands/run.rb
 - lib/captive/commands/user_login.rb
+- lib/captive/dashboard/apps_resource.rb
+- lib/captive/dashboard/env_vars_resource.rb
+- lib/captive/dashboard/scheduled_tasks_resource.rb
+- lib/captive/dashboard_api.rb
 - lib/captive/dashboard_client.rb
+- lib/captive/dashboard_response.rb
 - lib/captive/errors.rb
 - lib/captive/flux.rb
-- lib/captive/gh_cli.rb
 - lib/captive/github_device_flow.rb
 - lib/captive/http_client.rb
 - lib/captive/kubectl.rb
@@ -136,17 +139,20 @@ files:
 - lib/captive/log_noise_filter.rb
 - lib/captive/null_log_filter.rb
 - lib/captive/one_off_spec.rb
-- lib/captive/platform_root.rb
 - lib/captive/poller.rb
 - lib/captive/presenter/ansi_stripper.rb
+- lib/captive/presenter/app_info.rb
 - lib/captive/presenter/log_colorizer.rb
 - lib/captive/presenter/log_line.rb
+- lib/captive/presenter/scheduled_task.rb
 - lib/captive/session_id.rb
 - lib/captive/shell_completions.rb
 - lib/captive/terminal.rb
+- lib/captive/token_file.rb
 - lib/captive/ui/banner.rb
 - lib/captive/ui/spinner.rb
 - lib/captive/update_checker.rb
+- lib/captive/validation_message.rb
 - lib/captive/version.rb
 homepage: https://github.com/captive-studio/captive-platform
 licenses:

data/lib/captive/cluster_apps.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-module Captive
-  # Ce que le cluster sait des apps déployées. Le CLI développeur décrit l'état réellement
-  # servi, pas l'état désiré dans le repo GitOps — auquel il n'a pas accès.
-  class ClusterApps
-    def initialize(kubectl:)
-      @kubectl = kubectl
-    end
-
-    def all
-      web_deployments.map do |deployment|
-        namespace = deployment.dig("metadata", "namespace")
-        { name: namespace, stage: stage_of(namespace), domains: domains_by_namespace[namespace] || [] }
-      end
-    end
-
-    def domains(app) = domains_by_namespace[app] || []
-
-    def stage(app) = stage_of(app)
-
-    def tier(app) = web_of(app)&.dig("metadata", "annotations", "captive.dev/tier")
-
-    def workers(app) = of_type(app, "worker").map { |d| d.dig("metadata", "name") }
-
-    # L'add-on peut ne pas être posé, ou la CRD absente du cluster : les deux se lisent
-    # comme « pas d'IP fixe », pas comme une panne.
-    def egress_ip(app)
-      first_item("egresspolicy", app)&.dig("spec", "egressIP", "ipv4")
-    end
-
-    def postgres(app)
-      spec = first_item("cluster", app)&.fetch("spec", nil) or return nil
-
-      { instances: spec["instances"],
-        memory:    spec.dig("resources", "limits", "memory"),
-        storage:   spec.dig("storage", "size"), }.compact
-    end
-
-    private
-
-    def first_item(kind, app)
-      items(@kubectl.run("get", kind, "-n", app, "-o", "json")).first
-    rescue RuntimeError
-      nil
-    end
-
-    def web_of(app) = of_type(app, "web").first
-
-    def of_type(app, type)
-      workloads(app).select { |d| d.dig("metadata", "labels", "captive.dev/type") == type }
-    end
-
-    def workloads(app)
-      @workloads ||= {}
-      @workloads[app] ||= items(@kubectl.run("get", "deployment", "-n", app, "-o", "json"))
-    end
-
-
-    # Une app est un Deployment portant le type web : le même label que les composants de
-    # tier ciblent, et que la conformité exige.
-    def web_deployments
-      items(@kubectl.run("get", "deployment", "-A", "-l", "captive.dev/type=web", "-o", "json"))
-    end
-
-    def domains_by_namespace
-      @domains_by_namespace ||= items(@kubectl.run("get", "httproute", "-A", "-o", "json"))
-                                .group_by { |route| route.dig("metadata", "namespace") }
-                                .transform_values { |routes| routes.flat_map { |r| Array(r.dig("spec", "hostnames")) } }
-    end
-
-    def items(json) = JSON.parse(json).fetch("items", [])
-
-    def stage_of(namespace)
-      return "production" if namespace.end_with?("-production")
-
-      "staging" if namespace.end_with?("-staging")
-    end
-  end
-end

data/lib/captive/commands/apps_info.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-module Captive
-  module Commands
-    # L'état d'une app tel que le cluster le sert. Le CLI développeur n'a pas accès au repo
-    # GitOps : tout se lit sur les ressources vivantes, ce qui décrit l'état réel plutôt que
-    # l'état désiré — un déploiement en cours s'y voit, un manifeste poussé mais non
-    # réconcilié ne s'y voit pas encore.
-    class AppsInfo
-      TIER_RESOURCES = {
-        "xs" => { cpu: "100m → 500m", memory: "256Mi → 512Mi" },
-        "s"  => { cpu: "250m → 1",    memory: "512Mi → 1Gi"   },
-        "m"  => { cpu: "500m → 2",    memory: "1Gi → 2Gi"     },
-        "l"  => { cpu: "1 → 4",       memory: "2Gi → 4Gi"     },
-      }.freeze
-
-      def initialize(kubectl:, cluster_apps: nil)
-        @kubectl = kubectl
-        @apps    = cluster_apps || ClusterApps.new(kubectl: kubectl)
-      end
-
-      def gather(app)
-        tier     = @apps.tier(app)
-        postgres = @apps.postgres(app)
-        egress   = @apps.egress_ip(app)
-        {
-          pod_status: pod_status(app),
-          replicas:   replicas(app),
-          postgres:   !postgres.nil?,
-          redis:      redis?(app),
-          egress_ip:  !egress.nil?,
-          tier:       tier,
-          resources:  TIER_RESOURCES[tier],
-          domains:    @apps.domains(app),
-          stage:      @apps.stage(app),
-          workers:    @apps.workers(app),
-          postgres_details:  postgres,
-          redis_details:     redis_details(app),
-          egress_ip_details: egress && { ip: egress },
-        }
-      end
-
-      private
-
-      def pod_status(app)
-        @kubectl.run("get", "pod", "-n", app, "-l", "app=#{app}",
-                     "-o", "jsonpath={.items[0].status.phase}").strip
-      end
-
-      def replicas(app)
-        @kubectl.run("get", "deployment", app, "-n", app,
-                     "-o", "jsonpath={.spec.replicas}").strip.to_i
-      end
-
-      def redis?(app)
-        !@kubectl.run("get", "deployment", "-n", app, "-l", "app=redis",
-                      "--no-headers", "-o", "name").strip.empty?
-      end
-
-      # Redis est un Deployment ordinaire : sa taille se lit sur le conteneur, pas sur une CRD.
-      def redis_details(app)
-        limits = @kubectl.run(
-          "get", "deployment", "-n", app, "-l", "app=redis",
-          "-o", "jsonpath={.items[0].spec.template.spec.containers[0].resources.limits.memory}"
-        ).strip
-        limits.empty? ? nil : { memory: limits }
-      end
-    end
-  end
-end

data/lib/captive/commands/apps_rebuild.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../errors"
-require_relative "../platform_root"
-
-module Captive
-  module Commands
-    class AppsRebuild
-      # Dernière commande du CLI développeur qui lit le repo GitOps, contre l'ADR 0016.
-      # Elle déduit le repo GitHub de l'image, or les images valent
-      # ghcr.io/captive-studio/captive-platform/<app> : la déduction rend trois segments, qui
-      # ne désignent aucun repo. Rien dans le service ni sur le cluster n'enregistre le repo
-      # d'origine, donc la commande n'est pas portable en l'état — voir la note de l'étape 9.
-      # Elle exige donc un clone de captive-platform (PlatformRoot), jusqu'à passer par l'API
-      # du dashboard.
-      def initialize(gh:, repo_root: nil)
-        @gh        = gh
-        @repo_root = repo_root
-      end
-
-      def run(app)
-        repo    = extract_repo(app)
-        version = current_version(app)
-        fields  = version ? { version: version } : {}
-        @gh.trigger_workflow(repo, ref: "main", fields: fields)
-      end
-
-      private
-
-      def repo_root = @repo_root ||= PlatformRoot.find
-
-      def extract_repo(app)
-        image_file = File.join(repo_root, "services", app, "image.yaml")
-        raise ImageYamlNotFound, "image.yaml introuvable pour '#{app}'" unless File.exist?(image_file)
-
-        content = File.read(image_file)
-        image   = content.match(/image:\s+ghcr\.io\/([^\s:]+)/)&.captures&.first
-        raise ImageYamlNotFound, "image introuvable dans image.yaml de '#{app}'" unless image
-
-        image
-      end
-
-      def current_version(app)
-        deploy_file = File.join(repo_root, "services", app, "#{app}.yaml")
-        return nil unless File.exist?(deploy_file)
-
-        tag = File.read(deploy_file).match(/:(v\d+\.\d+\.\d+(?:-\d{14})?)/)&.captures&.first
-        tag&.sub(/-\d{14}$/, "")
-      end
-    end
-  end
-end

data/lib/captive/commands/env_kube_commands.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "env_list_kube"
-
-module Captive
-  module Commands
-    class EnvKubeCommands < Thor
-      include CLIDependencies
-
-      def self.exit_on_failure? = true
-
-      desc "list APP", "Liste les variables d'environnement de l'app depuis K8s"
-      long_desc <<~DESC
-        Lit directement le secret <app>-env depuis le cluster Kubernetes.
-
-        \x05Exemple :
-        \x05  captive env list my-app-staging
-      DESC
-      def list(app)
-        vars = EnvListKube.new(kubectl: kubectl).run(app)
-        vars.sort.each { |v| puts v }
-      end
-    end
-  end
-end

data/lib/captive/commands/env_list_kube.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module Captive
-  module Commands
-    class EnvListKube
-      def initialize(kubectl:)
-        @kubectl = kubectl
-      end
-
-      def run(app)
-        data = @kubectl.get_secret_data(app, "#{app}-env")
-        data.map { |k, v| "#{k}=#{v}" }
-      end
-    end
-  end
-end