captive-cli 1.0.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ec4e1f102b8ed8f597677d727876ad7a0be2996de6cd51de68cb1e4730953e2
-  data.tar.gz: 2a7e112840ea957652e340a70d9586328a65e95cf154b6d5de1a7b3f518a400b
+  metadata.gz: f79f7992c692e80419a6da77317d0e3d50d72ee4b48d41ea6001fa3e8a968400
+  data.tar.gz: 43220b3bb3e0b9cdaae4bf96de10d80eb3145af3f52584bff1c73fb45d4e7349
 SHA512:
-  metadata.gz: 84a84d1504ace4bc7ddfc544a930df455297e4f806509f387241371f6f0f256b7ad2d0aee1ed870fc494a9a93eed36ee33e601808f7ee4363b62908e241076f6
-  data.tar.gz: c5ba6f27ac8b9efb857b62c2f241ade477b976717f5225e4e1423b4be3407a88cadb89dc151e220394efa8d5e09c2bae28e215b491258148ba367adc0f046046
+  metadata.gz: cec86c2467edb73bb4c46c520c2fb793c1c4b67800213d5ef68348aa2ddae4c91b25e85d82fe73e599fc7cb188aee96b63feb5674b10885e7aa7100027f240ac
+  data.tar.gz: a69f88f24623b2329515daff60be1df8d3092046c51cd20b995cb6a0ba58a176dc29898640a07cdc6d9904315b10a321b7d7f6cc9cb7c301e768e991d55a3980

data/lib/captive/cli/dependencies.rb

@@ -2,18 +2,28 @@
 
 module Captive
   module CLIDependencies
+    # Les écritures du dashboard sont appliquées plus tard par captive-platform (réponse 202).
+    ASYNC_NOTICE = "demande envoyée, appliquée sous quelques minutes"
+
     private
 
     def kubectl
       @kubectl ||= begin
         raise NotAuthenticatedError, "Pas de session active. Lance : captive login" if active_kubeconfig.nil?
 
-        Kubectl.new(kubeconfig: active_kubeconfig) if binary_on_path?("kubectl")
+        unless binary_on_path?("kubectl")
+          raise MissingDependencyError, "kubectl introuvable. Installe-le : brew install kubernetes-cli"
+        end
+
+        Kubectl.new(kubeconfig: active_kubeconfig)
       end
     end
-    def gh_cli    = @gh_cli    ||= GhCLI.new
     def trail     = @trail     ||= ActivityTrail.new
     def paint     = @paint     ||= Pastel.new
+    def dashboard = @dashboard ||= DashboardApi.new
+    def apps_api  = @apps_api  ||= Dashboard::AppsResource.new(api: dashboard)
+    def env_api   = @env_api   ||= Dashboard::EnvVarsResource.new(api: dashboard)
+    def crons_api = @crons_api ||= Dashboard::ScheduledTasksResource.new(api: dashboard)
 
     def active_kubeconfig
       env_kc = ENV["KUBECONFIG"]

data/lib/captive/cli.rb

@@ -4,9 +4,12 @@ require "time"
 require_relative "loader"
 require_relative "cli/dependencies"
 require_relative "commands/apps_commands"
-require_relative "commands/env_kube_commands"
+require_relative "commands/env_commands"
+require_relative "commands/crons_commands"
 require_relative "commands/db_commands"
 require_relative "commands/user_login"
+require_relative "commands/auth_commands"
+require_relative "credentials_store"
 require_relative "dashboard_client"
 require_relative "github_device_flow"
 require_relative "cluster_endpoint"
@@ -22,15 +25,9 @@ module Captive
     def self.start(args = ARGV, config = {})
       args = [ "help", args.first ] if args.length == 2 && %w[--help -h].include?(args.last)
 
-      case UpdateChecker.new.check
-      when :blocked
-        warn "Version #{VERSION} n'est plus supportée. Mettez à jour : brew upgrade captive-studio/tap/captive-cli"
-        exit 1
-      when :update_available
-        warn "⚠ Nouvelle version disponible. Mettez à jour : brew upgrade captive-studio/tap/captive-cli"
-      end
+      check_for_update unless args.first(2) == %w[auth token]
       super
-    rescue AuthError, NotAuthenticatedError, NoTtyError => e
+    rescue AuthError, NotAuthenticatedError, NoTtyError, MissingDependencyError, DashboardError => e
       warn e.message
       exit 1
     rescue StandardError => e
@@ -39,6 +36,19 @@ module Captive
       exit 1
     end
 
+    # kubectl appelle `captive auth token` à chaque commande : ni requête réseau en plus, ni
+    # avertissement à afficher.
+    def self.check_for_update
+      case UpdateChecker.new.check
+      when :blocked
+        warn "Version #{VERSION} n'est plus supportée. Mettez à jour : brew upgrade captive-studio/tap/captive-cli"
+        exit 1
+      when :update_available
+        warn "⚠ Nouvelle version disponible. Mettez à jour : brew upgrade captive-studio/tap/captive-cli"
+      end
+    end
+    private_class_method :check_for_update
+
     # ── Subcommands ─────────────────────────────────────────────────────────
     desc "apps SUBCOMMAND", "Gestion des apps"
     subcommand "apps", Commands::AppsCommands
@@ -47,7 +57,13 @@ module Captive
     subcommand "db", Commands::DbCommands
 
     desc "env SUBCOMMAND", "Variables d'environnement d'une app"
-    subcommand "env", Commands::EnvKubeCommands
+    subcommand "env", Commands::EnvCommands
+
+    desc "crons SUBCOMMAND", "Tâches planifiées d'une app"
+    subcommand "crons", Commands::CronsCommands
+
+    desc "auth SUBCOMMAND", "Jeton pour kubectl", hide: true
+    subcommand "auth", Commands::AuthCommands
 
     # ── Root commands ────────────────────────────────────────────────────────
     map "--version" => :version
@@ -65,7 +81,7 @@ module Captive
       Commands::UserLogin.new(
         github:          GithubDeviceFlow.new,
         cluster:         ClusterEndpoint.new,
-        token_path:      File.expand_path("~/.config/captive/token"),
+        store:           CredentialsStore.new,
         kubeconfig_path: File.expand_path("~/.config/captive/kubeconfig")
       ).call
       puts "Authentifié avec succès."
@@ -102,9 +118,10 @@ module Captive
       exit(exit_code) if exit_code && exit_code != 0
     end
 
-    desc "whoami", "Affiche l'identité K8s courante"
+    desc "whoami", "Affiche l'utilisateur connecté au dashboard"
     def whoami
-      puts kubectl.run("auth", "whoami")
+      me = dashboard.get("/me")
+      puts [ me["login"], ("(#{me["name"]})" if me["name"]) ].compact.join(" ")
     end
 
     desc "completions SHELL", "Génère le script de complétion shell (bash ou zsh)"

data/lib/captive/commands/apps_commands.rb

@@ -5,99 +5,74 @@ module Captive
     class AppsCommands < Thor
       include CLIDependencies
 
+      STAGE_BADGES = { "staging" => [ :yellow, "[staging]" ], "production" => [ :green, "[prod]" ] }.freeze
+
       def self.exit_on_failure? = true
 
-      desc "list", "Liste toutes les apps déployées sur la plateforme"
+      desc "list", "Liste les apps auxquelles tu as accès"
       long_desc <<~DESC
-        Liste les apps déployées sur le cluster, avec leurs domaines et leur stage.
+        Liste les apps de tes Organizations, avec leur stage et leur URL (API du dashboard).
 
         \x05Exemple :
         \x05  captive apps list
       DESC
       def list
-        apps = ClusterApps.new(kubectl: kubectl).all
+        apps = apps_api.list
         puts paint.bold("Apps (#{apps.size}) :")
         apps.each do |app|
-          stage_badge = case app[:stage]
-          when "staging"    then " " + paint.yellow("[staging]")
-          when "production" then " " + paint.green("[prod]")
-          else ""
-          end
-          puts "  - #{paint.bold(app[:name])}#{stage_badge}"
-          if app[:domains]&.any?
-            app[:domains].each { |d| puts "      #{paint.cyan("https://#{d}")}" }
-          else
-            puts paint.dim("      <no domain>")
-          end
+          puts "  - #{paint.bold(app["name"])}#{stage_badge(app["stage"])}"
+          puts app["app_url"] ? "      #{paint.cyan(app["app_url"])}" : paint.dim("      <no domain>")
         end
       end
 
       desc "info APP", "Affiche le statut et les infos de l'app"
       long_desc <<~DESC
-        Affiche l'état complet : pod, replicas, stage, tier, domaines, addons.
+        Affiche stage, statut, URL, processus (replicas prêts, tier), datastores et domaines.
 
         \x05Exemple :
         \x05  captive apps info my-app
       DESC
       def info(app)
-        i = AppsInfo.new(kubectl: kubectl).gather(app)
-        puts paint.bold("\n#{app}")
-        puts "  Stage    : #{i[:stage] || "–"}"
-        puts "  Tier     : #{i[:tier]  || "–"}"
-        puts "  Pod      : #{i[:pod_status]} (#{i[:replicas]} replica(s))"
-        puts "  Postgres : #{i[:postgres]  ? paint.green("✓") : paint.dim("–")}"
-        puts "  Redis    : #{i[:redis]     ? paint.green("✓") : paint.dim("–")}"
-        puts "  IP fixe  : #{i[:egress_ip] ? paint.green("✓") : paint.dim("–")}"
-        i[:domains]&.any? && i[:domains].each { |d| puts "    → #{d}" }
-        i[:workers]&.any? && puts("  Workers  : #{i[:workers].join(", ")}")
-        (pg = i[:postgres_details])  && puts("  Postgres : #{pg[:instances] || 1} instance(s), #{pg[:memory] || "–"} RAM")
-        (rd = i[:redis_details])     && puts("  Redis    : #{rd[:memory] || "–"} RAM, #{rd[:storage] || "–"}")
-        (eg = i[:egress_ip_details]) && puts("  IP fixe  : #{eg[:ip] || "–"}")
-        puts
+        lines = Presenter::AppInfo.new(paint: paint).lines(
+          app: apps_api.show(app), workloads: apps_api.workloads(app).fetch("workloads", []),
+          datastores: apps_api.datastores(app), domains: apps_api.domains(app)
+        )
+        puts lines
       end
 
-      desc "restart APP", "Redémarre le deployment"
+      desc "restart APP", "Redémarre les processus de l'app"
       long_desc <<~DESC
-        Rollout restart du deployment + attend pod Ready.
+        Demande le redémarrage au dashboard, puis attend (120 s max) que tous les
+        processus soient de nouveau prêts.
 
         \x05Exemple :
         \x05  captive apps restart my-app
       DESC
       def restart(app)
-        AppsRestart.new(kubectl: kubectl).run(app)
-        pod_name, created_at = kubectl.pod_info(app, app)
-        age = format_age(created_at)
+        AppsRestart.new(apps: apps_api).run(app)
         puts paint.green("  ✓ #{app} redémarré")
-        puts paint.dim("    pod: #{pod_name} (#{age})")
       rescue PollTimeout => e
         abort paint.red("✗ Timeout : #{e.message}")
-      rescue RuntimeError => e
-        abort paint.red("✗ #{e.message.split("failed: ").last}")
       end
 
-      desc "rebuild APP", "Déclenche un rebuild sans changer le code"
+      desc "rebuild APP", "Redéploie l'app sans changer le code"
       long_desc <<~DESC
-        workflow_dispatch sur le repo GitHub. Utile après changement d'env vars.
+        Relance le build et le déploiement de la version courante via le dashboard.
+        Utile après un changement de variables d'environnement.
 
         \x05Exemple :
         \x05  captive apps rebuild my-app-staging
       DESC
       def rebuild(app)
-        AppsRebuild.new(gh: gh_cli).run(app)
-        puts paint.green("  ✓ Rebuild déclenché pour '#{app}'")
-      rescue WorkflowDispatchNotConfigured, ImageYamlNotFound, PlatformRootNotFound => e
-        abort paint.red("✗ #{e.message}")
+        apps_api.redeploy(app)
+        puts paint.green("  ✓ Redéploiement déclenché pour '#{app}'")
       end
 
       private
 
-      def format_age(created_at)
-        return "?" unless created_at
-
-        require "time"
-        "#{((Time.now - Time.parse(created_at)) / 60).round}s"
-      rescue ArgumentError
-        "?"
+      def stage_badge(stage)
+        color, label = STAGE_BADGES[stage]
+        color ? " #{paint.public_send(color, label)}" : ""
       end
     end
   end

data/lib/captive/commands/apps_restart.rb

@@ -1,23 +1,37 @@
 # frozen_string_literal: true
 
+require "time"
 require_relative "../poller"
 require_relative "../errors"
 
 module Captive
   module Commands
+    # Demande le redémarrage au dashboard, puis attend que chaque workload ait tous ses
+    # replicas prêts, sur des pods créés après la demande : juste après le POST, les anciens
+    # pods sont encore prêts et le redémarrage paraîtrait déjà fini.
     class AppsRestart
-      def initialize(kubectl:, poller: nil)
-        @kubectl = kubectl
-        @poller  = poller || Poller.new(interval: 5, timeout: 120)
+      def initialize(apps:, poller: nil)
+        @apps   = apps
+        @poller = poller || Poller.new(interval: 5, timeout: 120)
       end
 
       def run(app)
-        old_pod, = @kubectl.pod_info(app, app)
-        @kubectl.restart_deployment(app, app)
-        @poller.poll_until(context: "nouveau pod #{app} Running") do
-          new_pod, = @kubectl.pod_info(app, app)
-          new_pod && !new_pod.empty? && new_pod != old_pod
-        end
+        restarted_at = Time.parse(@apps.restart(app).fetch("restarted_at"))
+        @poller.poll_until(context: "redémarrage de #{app}") { restarted?(app, restarted_at) }
+      end
+
+      private
+
+      def restarted?(app, restarted_at)
+        state     = @apps.workloads(app)
+        workloads = state.fetch("workloads", [])
+        workloads.any? && workloads.all? { |w| w["ready"] == w["total"] } &&
+          state.fetch("pods", []).all? { |pod| fresh?(pod, restarted_at) }
+      end
+
+      def fresh?(pod, restarted_at)
+        created_at = pod["created_at"]
+        created_at.nil? || Time.parse(created_at.to_s) >= restarted_at
       end
     end
   end

data/lib/captive/commands/auth_commands.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "auth_token"
+require_relative "../session_token"
+
+module Captive
+  module Commands
+    # `captive auth` : ce dont kubectl a besoin pour s'authentifier, masqué de l'aide.
+    class AuthCommands < Thor
+      def self.exit_on_failure? = true
+
+      desc "token", "Imprime un ExecCredential pour kubectl (appelé par le kubeconfig)"
+      def token = AuthToken.new(session: SessionToken.new).call
+    end
+  end
+end

data/lib/captive/commands/auth_token.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+
+module Captive
+  module Commands
+    # Le plugin d'authentification exec de kubectl : un ExecCredential sur stdout, et rien d'autre.
+    class AuthToken
+      def initialize(session:, out: $stdout)
+        @session = session
+        @out     = out
+      end
+
+      def call
+        @out.puts JSON.generate(exec_credential(@session.current))
+      end
+
+      private
+
+      def exec_credential(credentials)
+        expires_at = credentials.expires_at
+        status = { token: credentials.access_token }
+        status[:expirationTimestamp] = expires_at.utc.iso8601 if expires_at
+        { apiVersion: "client.authentication.k8s.io/v1", kind: "ExecCredential", status: status }
+      end
+    end
+  end
+end

data/lib/captive/commands/cron_declaration.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Captive
+  module Commands
+    # Le corps d'une tâche planifiée à déclarer : les options données sur la ligne de
+    # commande, posées sur une base (les défauts du dashboard pour un ajout, la tâche
+    # actuelle pour une édition).
+    class CronDeclaration
+      DEFAULTS = { "schedule" => "", "timezone" => "Etc/UTC", "mode" => "http", "target" => "",
+                   "timeout_seconds" => 60, "suspended" => false, }.freeze
+      OPTIONS = { schedule: "schedule", timezone: "timezone", mode: "mode", target: "target",
+                  timeout: "timeout_seconds", suspended: "suspended", }.freeze
+
+      def initialize(name, base: DEFAULTS)
+        @name = name
+        @base = base
+      end
+
+      def with(options)
+        given = OPTIONS.filter_map { |option, field| [ field, options[option] ] unless options[option].nil? }
+        DEFAULTS.merge(@base.slice(*DEFAULTS.keys)).merge(given.to_h).merge("name" => @name)
+      end
+    end
+  end
+end

data/lib/captive/commands/crons_commands.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require_relative "cron_declaration"
+
+module Captive
+  module Commands
+    class CronsCommands < Thor
+      include CLIDependencies
+
+      def self.exit_on_failure? = true
+
+      DECLARATION_OPTIONS = {
+        schedule:  { type: :string,  desc: "Planning cron à 5 champs, ex. \"0 3 * * *\"" },
+        target:    { type: :string,  desc: "URL (mode http) ou commande (mode command)" },
+        mode:      { type: :string,  enum: %w[http command], desc: "http (défaut) ou command" },
+        timezone:  { type: :string,  desc: "Fuseau IANA (défaut Etc/UTC)" },
+        timeout:   { type: :numeric, desc: "Durée max en secondes, 1 à 3600 (défaut 60)" },
+        suspended: { type: :boolean, desc: "Déclare la tâche suspendue" },
+      }.freeze
+
+      def self.declaration_options
+        DECLARATION_OPTIONS.each { |name, settings| method_option(name, **settings) }
+      end
+
+      desc "list APP", "Liste les tâches planifiées de l'app"
+      long_desc <<~DESC
+        \x05Exemple :
+        \x05  captive crons list my-app
+      DESC
+      def list(app)
+        tasks = crons_api.list(app)
+        return puts(paint.dim("Aucune tâche planifiée.")) if tasks.empty?
+
+        tasks.each { |task| puts presenter.lines(task) }
+      end
+
+      desc "add APP NAME --schedule CRON --target CIBLE", "Déclare une tâche planifiée"
+      long_desc <<~DESC
+        \x05Exemple :
+        \x05  captive crons add my-app nettoyage --schedule "0 3 * * *" --target /cron/cleanup
+        \x05  captive crons add my-app purge --schedule "*/15 * * * *" --mode command --target "bin/rails purge"
+      DESC
+      declaration_options
+      def add(app, name)
+        crons_api.create(app, CronDeclaration.new(name).with(options.transform_keys(&:to_sym)))
+        accepted("#{name} déclarée")
+      end
+
+      desc "edit APP NAME [options]", "Modifie une tâche planifiée"
+      long_desc <<~DESC
+        Les options absentes gardent la valeur actuelle de la tâche.
+
+        \x05Exemple :
+        \x05  captive crons edit my-app nettoyage --schedule "0 4 * * *"
+      DESC
+      declaration_options
+      def edit(app, name)
+        base = crons_api.find(app, name)
+        crons_api.update(app, name, CronDeclaration.new(name, base: base).with(options.transform_keys(&:to_sym)))
+        accepted("#{name} modifiée")
+      end
+
+      desc "rm APP NAME", "Supprime une tâche planifiée"
+      long_desc <<~DESC
+        \x05Exemple :
+        \x05  captive crons rm my-app nettoyage
+      DESC
+      def rm(app, name)
+        crons_api.delete(app, name)
+        accepted("#{name} supprimée")
+      end
+
+      desc "suspend APP NAME", "Suspend une tâche planifiée"
+      long_desc <<~DESC
+        \x05Exemple :
+        \x05  captive crons suspend my-app nettoyage
+      DESC
+      def suspend(app, name)
+        crons_api.suspend(app, name)
+        accepted("#{name} suspendue")
+      end
+
+      desc "resume APP NAME", "Reprend une tâche planifiée suspendue"
+      long_desc <<~DESC
+        \x05Exemple :
+        \x05  captive crons resume my-app nettoyage
+      DESC
+      def resume(app, name)
+        crons_api.resume(app, name)
+        accepted("#{name} reprise")
+      end
+
+      desc "trigger APP NAME", "Lance une tâche planifiée maintenant"
+      long_desc <<~DESC
+        \x05Exemple :
+        \x05  captive crons trigger my-app nettoyage
+      DESC
+      def trigger(app, name)
+        job = crons_api.trigger(app, name).fetch("job_name")
+        puts paint.green("  ✓ #{name} lancée (job #{job})")
+      end
+
+      desc "runs APP NAME", "Affiche la dernière exécution d'une tâche"
+      long_desc <<~DESC
+        Le cluster ne garde que la dernière exécution (un succès disparaît après 5 minutes).
+
+        \x05Exemple :
+        \x05  captive crons runs my-app nettoyage
+      DESC
+      def runs(app, name)
+        puts presenter.last_run(crons_api.find(app, name)["last_run"]).strip
+      end
+
+      private
+
+      def presenter = Presenter::ScheduledTask.new(paint: paint)
+
+      def accepted(message)
+        puts paint.green("  ✓ #{message} : #{ASYNC_NOTICE}")
+      end
+    end
+  end
+end

data/lib/captive/commands/env_commands.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative "env_set"
+
+module Captive
+  module Commands
+    class EnvCommands < Thor
+      include CLIDependencies
+
+      def self.exit_on_failure? = true
+
+      desc "list APP", "Liste les variables d'environnement de l'app"
+      long_desc <<~DESC
+        Lit les variables via le dashboard. Une écriture pas encore appliquée est signalée.
+
+        \x05Exemple :
+        \x05  captive env list my-app-staging
+      DESC
+      def list(app)
+        env_api.list(app).sort_by { |var| var["key"] }.each do |var|
+          puts "#{var["key"]}=#{var["value"]}#{state(var)}"
+        end
+      end
+
+      desc "set APP KEY=VALUE [KEY=VALUE...]", "Crée ou modifie des variables d'environnement"
+      long_desc <<~DESC
+        Crée les clés absentes, met à jour les autres. Appliqué par la plateforme
+        sous quelques minutes.
+
+        \x05Exemple :
+        \x05  captive env set my-app-staging FOO=bar BAZ=qux
+      DESC
+      def set(app, *pairs)
+        abort "Indique au moins une paire KEY=VALUE." if pairs.empty?
+
+        EnvSet.new(env_vars: env_api).run(app, pairs).each do |key, outcome|
+          puts paint.green("  ✓ #{key} #{outcome == :created ? "créée" : "modifiée"}")
+        end
+        puts paint.dim("  #{ASYNC_NOTICE}")
+      end
+
+      desc "unset APP KEY [KEY...]", "Supprime des variables d'environnement"
+      long_desc <<~DESC
+        \x05Exemple :
+        \x05  captive env unset my-app-staging FOO BAZ
+      DESC
+      def unset(app, *keys)
+        abort "Indique au moins une clé." if keys.empty?
+
+        keys.each do |key|
+          env_api.delete(app, key)
+          puts paint.green("  ✓ #{key} supprimée")
+        end
+        puts paint.dim("  #{ASYNC_NOTICE}")
+      end
+
+      private
+
+      def state(var)
+        return paint.red("  [échec : #{var["failure_reason"] || "écriture refusée"}]") if var["failed"]
+
+        var["pending"] ? paint.yellow("  [en attente : #{var["pending_change"]}]") : ""
+      end
+    end
+  end
+end

data/lib/captive/commands/env_set.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+
+module Captive
+  module Commands
+    # Écrit des paires KEY=VALUE : une clé déjà présente se met à jour, une nouvelle se crée.
+    class EnvSet
+      def initialize(env_vars:)
+        @env_vars = env_vars
+      end
+
+      # Retourne [[clé, :created|:updated], …] dans l'ordre des paires.
+      def run(app, pairs)
+        parsed   = pairs.map { |pair| parse(pair) }
+        existing = @env_vars.list(app).to_set { |var| var["key"] }
+        parsed.map { |key, value| write(app, key, value, existing.include?(key)) }
+      end
+
+      private
+
+      def parse(pair)
+        key, separator, value = pair.partition("=")
+        raise ValidationError, "Paire invalide : #{pair.inspect}. Attendu KEY=VALUE" if separator.empty? || key.empty?
+
+        [ key, value ]
+      end
+
+      def write(app, key, value, exists)
+        if exists
+          @env_vars.update(app, key, value)
+          [ key, :updated ]
+        else
+          @env_vars.create(app, key, value)
+          [ key, :created ]
+        end
+      end
+    end
+  end
+end