captive-cli 1.0.0 → 1.3.0

data/lib/captive/session_token.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "credentials_store"
+require_relative "token_refresher"
+require_relative "errors"
+
+module Captive
+  # La source unique du jeton envoyé au dashboard et à kubectl : renouvelé quand il expire dans
+  # moins de 5 minutes, ou quand le dashboard le refuse (401).
+  class SessionToken
+    INVALID = "Token invalide ou expiré. Lance : captive login"
+
+    def initialize(store: CredentialsStore.new, refresher: TokenRefresher.new, clock: -> { Time.now })
+      @store     = store
+      @refresher = refresher
+      @clock     = clock
+    end
+
+    def current
+      now         = @clock.call
+      credentials = @store.read
+      return credentials unless credentials.expiring?(now)
+
+      renew { |fresh| fresh.expiring?(now) }
+    end
+
+    # Après un 401 sur `stale_token` : renouvelle, sauf si un autre processus l'a déjà fait.
+    def refresh(stale_token)
+      renew { |fresh| fresh.access_token == stale_token }.access_token
+    end
+
+    # Pour les transports : la requête est rejouée une fois avec un jeton renouvelé sur un 401.
+    def authorize
+      token    = current.access_token
+      response = yield token
+      return response unless response.code.to_i == 401
+
+      yield refresh(token)
+    end
+
+    private
+
+    # Sous verrou, on relit : si un autre processus a renouvelé entre-temps, son jeton suffit.
+    def renew(&stale)
+      @store.exclusively do
+        fresh = @store.read
+        next fresh unless stale.call(fresh)
+
+        @refresher.refresh(refreshable(fresh).refresh_token).tap { |credentials| @store.write(credentials) }
+      end
+    end
+
+    def refreshable(credentials)
+      return credentials if credentials.refreshable?(@clock.call)
+      raise SessionExpiredError if credentials.expirable?
+
+      raise AuthError, INVALID
+    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_refresher.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "http_client"
+require_relative "credentials"
+require_relative "errors"
+require_relative "github_device_flow"
+
+module Captive
+  # Échange un refresh_token contre de nouveaux jetons. Jeton issu du device flow : pas de
+  # client_secret. L'échange est à usage unique et invalide l'ancien couple de jetons.
+  class TokenRefresher
+    URL = "https://github.com/login/oauth/access_token"
+
+    def initialize(http: HttpClient.new, clock: -> { Time.now })
+      @http  = http
+      @clock = clock
+    end
+
+    def refresh(refresh_token)
+      data = @http.post(URL, client_id: GithubDeviceFlow::CLIENT_ID, grant_type: "refresh_token",
+                             refresh_token: refresh_token)
+      raise SessionExpiredError unless data["access_token"]
+
+      Credentials.from_github(data, now: @clock.call)
+    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.3.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.3.0
 platform: ruby
 authors:
 - Captive Studio
@@ -106,29 +106,36 @@ 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/auth_commands.rb
+- lib/captive/commands/auth_token.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/credentials.rb
+- lib/captive/credentials_store.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 +143,21 @@ 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/session_token.rb
 - lib/captive/shell_completions.rb
 - lib/captive/terminal.rb
+- lib/captive/token_refresher.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

data/lib/captive/gh_cli.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require "open3"
-require_relative "errors"
-
-module Captive
-  class GhCLI
-    def trigger_workflow(repo, workflow: "ci.yml", ref: "main", fields: {})
-      field_args = fields.flat_map { |k, v| [ "--field", "#{k}=#{v}" ] }
-      run("workflow", "run", workflow, "--repo", repo, "--ref", ref, *field_args)
-    rescue RuntimeError => e
-      raise WorkflowDispatchNotConfigured,
-        "Le workflow '#{workflow}' de '#{repo}' n'a pas de trigger workflow_dispatch.\n" \
-        "  Regénère le ci.yml : captive apps launch <app> dans le repo de l'app." \
-        if e.message.include?("workflow_dispatch")
-      raise
-    end
-
-    def workflow_exists?(repo)
-      %w[deploy.yml ci.yml].any? do |file|
-        run("api", "/repos/#{repo}/contents/.github/workflows/#{file}") && true
-      rescue RuntimeError
-        false
-      end
-    end
-
-    def latest_run_status(repo)
-      output = run("run", "list", "--repo", repo, "--limit", "1",
-                   "--json", "status,conclusion", "--jq", ".[0]")
-      data = JSON.parse(output)
-      return :success    if data["status"] == "completed" && data["conclusion"] == "success"
-      return :failure    if data["status"] == "completed"
-
-      :in_progress
-    end
-
-    def image_exists?(repo, tag)
-      output = run("api", "/repos/#{repo}/packages/container/#{repo.split("/").last}/versions",
-                   "--jq", ".[].metadata.container.tags[]")
-      output.split("\n").include?(tag)
-    rescue RuntimeError => e
-      return false if e.message.include?("404") || e.message.include?("Not Found")
-
-      raise
-    end
-
-    def app_installed?(repo)
-      run("api", "repos/#{repo}/installation")
-      true
-    rescue RuntimeError
-      false
-    end
-
-    def detect_type(repo)
-      data = JSON.parse(run("api", "repos/#{repo}"))
-      case data["language"]
-      when "Ruby"                     then "rails-app"
-      when "JavaScript", "TypeScript" then "node-app"
-      else raise UnknownAppType, "language non supportée : #{data["language"]}"
-      end
-    end
-
-    PLATFORM_REPO = "captive-studio/captive-platform"
-
-    def dispatch_build(repo)
-      repo_name = repo.split("/").last.downcase
-      sha = run("api", "repos/#{repo}/git/ref/heads/main", "--jq", ".object.sha").strip
-      body = JSON.generate(
-        event_type: "build-app",
-        client_payload: { repo: repo, repo_name: repo_name, sha: sha, ref: "refs/heads/main" }
-      )
-      run_with_input("api", "repos/#{PLATFORM_REPO}/dispatches", "-X", "POST", "--input", "-",
-                     input: body)
-    end
-
-    def run(*args, input: nil)
-      opts = input ? { stdin_data: input } : {}
-      out, err, status = Open3.capture3("gh", *args, **opts)
-      raise "gh #{args.join(" ")} failed: #{err}" unless status.success?
-
-      out
-    end
-
-    def run_with_input(*args, input:)
-      run(*args, input: input)
-    end
-  end
-end

data/lib/captive/platform_root.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require "pathname"
-require_relative "errors"
-
-module Captive
-  # Où est le clone de captive-platform. Installé en gem, le CLI ne vit plus dans le monorepo :
-  # la racine se trouve en remontant depuis le dossier courant, comme git trouve .git, ou se
-  # désigne par CAPTIVE_PLATFORM_ROOT. Seul `apps rebuild` en a encore besoin (ADR 0018).
-  module PlatformRoot
-    ENV_VAR = "CAPTIVE_PLATFORM_ROOT"
-
-    def self.find(start: Dir.pwd, env: ENV)
-      env[ENV_VAR] || ascend(start) ||
-        raise(PlatformRootNotFound, "Clone de captive-platform introuvable depuis #{start}. " \
-                                    "Lance la commande depuis le clone ou définis #{ENV_VAR}.")
-    end
-
-    def self.ascend(start)
-      Pathname.new(start).realpath.ascend
-              .find { |dir| dir.join("services").directory? && dir.join(".sops.yaml").file? }&.to_s
-    end
-    private_class_method :ascend
-  end
-end