ruby_everywhere 0.0.1 → 0.1.0

data/lib/everywhere/commands/install.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+require "dry/cli"
+require "fileutils"
+require_relative "../shellout"
+
+module Everywhere
+  module Commands
+    # Prepare an existing app for packaged desktop life. Idempotent: skips
+    # anything already in place.
+    class Install < Dry::CLI::Command
+      desc "Prepare this app for RubyEverywhere (boot stub, config/everywhere.yml, config tweaks)"
+
+      option :root, default: ".", desc: "App root directory"
+      option :path, default: nil, desc: "Use a local checkout of ruby_everywhere in the Gemfile (path:)"
+
+      def call(root: ".", path: nil, **)
+        @framework = Framework.detect(root)
+        @root = @framework.root
+        UI.step("#{UI.bold(@framework.name)} app at #{@root}")
+
+        # Common to every framework.
+        add_gem(path)
+        write_config
+        write_boot_stub
+
+        # Framework-specific config surgery.
+        send("install_#{@framework.name}")
+
+        UI.success("installed — run `every dev` to open the app, `every build` to package it")
+      end
+
+      private
+
+      # ---- framework-specific recipes -----------------------------------------
+
+      def install_rails
+        guard_bootsnap
+        disable_force_ssl
+        point_database_at_app_data
+        disable_puma_keep_alives
+        write_initializer
+        install_bridge
+      end
+
+      def install_sinatra
+        vendor_bridge_to_public
+        guide_rack_manual_steps(
+          db: "point your production SQLite path at ENV.fetch(\"NATIVE_STORAGE_DIR\", \"storage\")",
+          boot: "call `Everywhere::Database.prepare!(__dir__)` from config.ru after loading your app",
+          script: "load the bridge with <script type=\"module\" src=\"/bridge.js\"></script>"
+        )
+      end
+
+      def install_hanami
+        vendor_bridge_to_public
+        guide_rack_manual_steps(
+          db: "override DATABASE_URL from ENV[\"NATIVE_STORAGE_DIR\"] in config.ru when NATIVE_PACKAGED",
+          boot: "migrate before Hanami finalizes: Hanami.prepare → run ROM migrations → require \"hanami/boot\"",
+          script: "serve public/ via Rack::Static and load /bridge.js as an EXTERNAL module (Hanami's CSP forbids inline scripts)"
+        )
+      end
+
+      # Rack frameworks vary too much to auto-edit their boot files safely, so we
+      # vendor the bridge and print the remaining wiring rather than guess.
+      def vendor_bridge_to_public
+        source = File.expand_path("../javascript/bridge.js", __dir__)
+        target_dir = app_file("public")
+        FileUtils.mkdir_p(target_dir)
+        target = File.join(target_dir, "bridge.js")
+        fresh = !File.exist?(target) || File.read(target) != File.read(source)
+        FileUtils.cp(source, target) if fresh
+        change("vendor @rubyeverywhere/bridge to public/bridge.js", fresh)
+      end
+
+      def guide_rack_manual_steps(db:, boot:, script:)
+        UI.step("#{UI.dim("next, wire these by hand (see example-#{@framework.name}/):")}")
+        UI.step("  #{UI.dim("• database:")} #{db}")
+        UI.step("  #{UI.dim("• boot:")}     #{boot}")
+        UI.step("  #{UI.dim("• bridge:")}   #{script}")
+      end
+
+      def app_file(*parts) = File.join(@root, *parts)
+
+      def change(label, made)
+        made ? UI.ok(label) : UI.step("#{label} #{UI.dim("(already done, skipped)")}")
+      end
+
+      def add_gem(path)
+        gemfile = app_file("Gemfile")
+        contents = File.read(gemfile)
+        return change("add ruby_everywhere to Gemfile", false) if contents.match?(/gem ["']ruby_everywhere["']/)
+
+        line = path ? "gem \"ruby_everywhere\", path: #{path.inspect}" : "gem \"ruby_everywhere\""
+        File.write(gemfile, "#{contents.chomp}\n\n# Desktop apps from this #{@framework.name.capitalize} app — https://rubyeverywhere.com\n#{line}\n")
+        Shellout.run!({}, "bundle", "install", "--quiet", chdir: @root)
+        change("add ruby_everywhere to Gemfile", true)
+      end
+
+      def write_config
+        config = app_file("config", "everywhere.yml")
+        return change("create config/everywhere.yml", false) if File.exist?(config)
+
+        app_name = File.basename(@root).split(/[-_]/).map(&:capitalize).join(" ")
+        File.write(config, <<~YAML)
+          # RubyEverywhere app configuration — https://rubyeverywhere.com
+          app:
+            name: #{app_name}
+            # Reverse-DNS app identifier: names the app-data directory on every
+            # platform (and the macOS bundle id). Set once, never change it.
+            bundle_id: com.example.#{app_name.downcase.gsub(/[^a-z0-9]+/, "-")}
+            entry_path: /          # initial url on app launch
+            # icon: icon.png       # PNG used to generate app icons (defaults to icon.png at the app root if present)
+            # splash: splash.html  # custom boot splash (HTML); window.__EVERYWHERE_CONFIG__ carries name/colors
+
+          appearance:
+            # Colors take a hex string, or split by system theme:
+            #   tint_color:
+            #     light: "#AA1111"
+            #     dark: "#FF5555"
+            tint_color: "#CC342D"
+            background_color:
+              light: "#FFFFFF"
+              dark: "#1C1B1A"
+        YAML
+        change("create config/everywhere.yml", true)
+      end
+
+      def write_boot_stub
+        stub = app_file("native_boot.rb")
+        return change("create native_boot.rb", false) if File.exist?(stub)
+
+        File.write(stub, @framework.boot_stub)
+        change("create native_boot.rb", true)
+      end
+
+      def guard_bootsnap
+        boot = app_file("config", "boot.rb")
+        contents = File.read(boot)
+        return change("guard bootsnap for packaged runs", false) if contents.include?("NATIVE_PACKAGED")
+
+        made = contents.sub!(/^require ["']bootsnap\/setup["'].*$/) do
+          "# Bootsnap writes its cache to tmp/, which is read-only inside the packaged filesystem.\n" \
+          "require \"bootsnap/setup\" unless ENV[\"NATIVE_PACKAGED\"]"
+        end
+        File.write(boot, contents) if made
+        change("guard bootsnap for packaged runs", !!made)
+      end
+
+      def disable_force_ssl
+        production = app_file("config", "environments", "production.rb")
+        contents = File.read(production)
+        made = false
+        made |= !!contents.gsub!(/^(\s*config\.assume_ssl\s*=\s*)true/) { "#{Regexp.last_match(1)}false # desktop: webview talks plain HTTP to 127.0.0.1" }
+        made |= !!contents.gsub!(/^(\s*config\.force_ssl\s*=\s*)true/) { "#{Regexp.last_match(1)}false" }
+        File.write(production, contents) if made
+        change("disable force_ssl for localhost", made)
+      end
+
+      # Vendor @rubyeverywhere/bridge (one JS API across browser/desktop/mobile)
+      # and pin it for importmap. Re-running `every install` after a gem update
+      # refreshes the vendored copy.
+      def install_bridge
+        source = File.expand_path("../javascript/bridge.js", __dir__)
+        target_dir = app_file("vendor", "javascript")
+        target = File.join(target_dir, "@rubyeverywhere--bridge.js")
+        FileUtils.mkdir_p(target_dir)
+        # Stamp a machine-readable version marker on the vendored copy so the
+        # build receipt (Receipt#bridge_version) can record which bridge shipped.
+        # Comparing against the fully-stamped content keeps re-runs idempotent.
+        desired = "// @rubyeverywhere/bridge version: #{Everywhere::BRIDGE_VERSION} (vendored by `every install`)\n#{File.read(source)}"
+        fresh = !File.exist?(target) || File.read(target) != desired
+        File.write(target, desired) if fresh
+
+        importmap = app_file("config", "importmap.rb")
+        if File.exist?(importmap)
+          contents = File.read(importmap)
+          unless contents.include?("@rubyeverywhere/bridge")
+            File.write(importmap, contents.chomp + "\npin \"@rubyeverywhere/bridge\", to: \"@rubyeverywhere--bridge.js\" # vendored by `every install`\n")
+            fresh = true
+          end
+        end
+        wire_application_js(fresh)
+      end
+
+      def wire_application_js(fresh)
+        app_js = app_file("app", "javascript", "application.js")
+        if File.exist?(app_js)
+          contents = File.read(app_js)
+          unless contents.include?("@rubyeverywhere/bridge")
+            File.write(app_js, contents.chomp + <<~JS)
+
+
+              import Everywhere from "@rubyeverywhere/bridge"
+              // Available everywhere: controllers, inline scripts, the console.
+              window.Everywhere = Everywhere
+            JS
+            fresh = true
+          end
+        end
+        change("install @rubyeverywhere/bridge", fresh)
+      end
+
+      def write_initializer
+        init = app_file("config", "initializers", "everywhere.rb")
+        return change("create everywhere initializer", false) if File.exist?(init)
+
+        File.write(init, <<~RUBY)
+          # RubyEverywhere desktop-runtime configuration (generated by `every install`).
+          if ENV["NATIVE_PACKAGED"]
+            # Large static files truncate when streamed from the packaged read-only
+            # filesystem; Everywhere.boot! copies public/ to app-data — serve from there.
+            Rails.application.config.paths["public"] = ENV["NATIVE_PUBLIC_DIR"] if ENV["NATIVE_PUBLIC_DIR"]
+
+            # Keep desktop users signed in across launches (session cookies are
+            # browser-session-scoped by default).
+            Rails.application.config.session_store :cookie_store,
+              key: "_\#{Rails.application.class.module_parent_name.underscore}_session",
+              expire_after: 1.year
+          end
+        RUBY
+        change("create everywhere initializer", true)
+      end
+
+      # WebKit (the webview) reuses keep-alive connections that Puma has
+      # already closed, intermittently killing asset loads with "network
+      # connection was lost" (-1005). Single local user: keep-alives off.
+      def disable_puma_keep_alives
+        puma = app_file("config", "puma.rb")
+        contents = File.read(puma)
+        return change("disable puma keep-alives when packaged", false) if contents.include?("enable_keep_alives")
+
+        File.write(puma, contents.chomp + <<~RUBY)
+
+
+          # RubyEverywhere: WebKit drops reused keep-alive connections from a local
+          # Puma ("network connection was lost"); disable them in the packaged app.
+          enable_keep_alives false if ENV["NATIVE_PACKAGED"] && respond_to?(:enable_keep_alives)
+        RUBY
+        change("disable puma keep-alives when packaged", true)
+      end
+
+      def point_database_at_app_data
+        db = app_file("config", "database.yml")
+        contents = File.read(db)
+        return change("point production SQLite at app-data dir", false) if contents.include?("NATIVE_STORAGE_DIR")
+
+        # Rails 8.x generates commented-out production database paths.
+        made = !!contents.gsub!(%r{^(\s*)#\s*database: path/to/persistent/storage/(\S+\.sqlite3)$}) do
+          "#{Regexp.last_match(1)}database: <%= ENV.fetch(\"NATIVE_STORAGE_DIR\", \"storage\") %>/#{Regexp.last_match(2)}"
+        end
+        # Older/edited apps: uncommented storage/ paths in the production section.
+        File.write(db, contents) if made
+
+        unless made || contents.include?("NATIVE_STORAGE_DIR")
+          UI.warn "couldn't rewrite config/database.yml automatically — point production " \
+                  "sqlite paths at <%= ENV.fetch(\"NATIVE_STORAGE_DIR\", \"storage\") %>/..."
+          return
+        end
+        change("point production SQLite at app-data dir", made)
+      end
+    end
+  end
+end

data/lib/everywhere/commands/platform/auth_status.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "dry/cli"
+require_relative "../../ui"
+require_relative "../../platform/client"
+require_relative "../../platform/credentials"
+
+module Everywhere
+  module Commands
+    # `every platform auth status` — show whether this machine is logged in, and
+    # validate the saved token against the Platform.
+    class PlatformAuthStatus < Dry::CLI::Command
+      desc "Show Platform authentication status"
+
+      option :url, default: nil, desc: "Platform base URL"
+
+      def call(url: nil, **)
+        base = Everywhere::Platform::Client.base_url(url)
+        creds = Everywhere::Platform::Credentials.load.for(base)
+        return UI.warn("not logged in to #{base} — run `every platform login`") unless creds
+
+        res = Everywhere::Platform::Client.new(base, token: creds["token"]).get("/cli/token")
+        if res.ok?
+          user = res.body["user"] || {}
+          org  = res.body["organization"] || {}
+          tok  = res.body["token"] || {}
+          UI.ok("logged in to #{base}")
+          UI.step("user:  #{user["email"]}")
+          UI.step("org:   #{org["name"]} #{UI.dim("(#{org["id"]})")}")
+          last = tok["last_used_at"] ? " · last used #{tok["last_used_at"]}" : ""
+          UI.step("token: #{tok["hint"]}#{UI.dim(last)}")
+        elsif res.unauthorized?
+          UI.bad("saved token is invalid or revoked — run `every platform login`")
+        else
+          UI.bad("couldn't check status — HTTP #{res.status}")
+        end
+      rescue Everywhere::Error => e
+        UI.bad(e.message)
+      end
+    end
+  end
+end

data/lib/everywhere/commands/platform/build.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require "dry/cli"
+require "tmpdir"
+require "fileutils"
+require_relative "../../ui"
+require_relative "../../config"
+require_relative "../../framework"
+require_relative "../../receipt"
+require_relative "../../platform/client"
+require_relative "../../platform/credentials"
+require_relative "../../platform/snapshot"
+
+module Everywhere
+  module Commands
+    # `every platform build` — hosted build (Model B): snapshot the source, upload
+    # it straight to storage, submit a build for the configured targets, then tail
+    # logs and pull the finished artifacts. No local toolchain needed.
+    class PlatformBuild < Dry::CLI::Command
+      desc "Build this app on the RubyEverywhere Platform"
+
+      option :root,    default: ".",       desc: "App root directory"
+      option :url,     default: nil,       desc: "Platform base URL"
+      option :target,  default: nil,       desc: "Targets (comma-separated os-arch); overrides everywhere.yml"
+      option :channel, default: "direct",  desc: "Distribution channel"
+      option :ruby,    default: nil,       desc: "Ruby version (default: build.ruby or 4.0.6)"
+      option :output,  default: nil,       desc: "Where to save artifacts (default: <root>/dist)"
+      option :wait,        type: :boolean, default: true,  desc: "Wait for the build and download results"
+      option :download,    type: :boolean, default: true,  desc: "Download finished artifacts"
+
+      def call(root: ".", url: nil, target: nil, channel: "direct", ruby: nil, output: nil,
+               wait: true, download: true, **)
+        root_path = File.expand_path(root)
+        config = Everywhere::Config.load(root_path)
+        base = Everywhere::Platform::Client.base_url(url)
+        creds = Everywhere::Platform::Credentials.load.for(base)
+        UI.die!("not logged in to #{base} — run `every platform login`") unless creds
+
+        client = Everywhere::Platform::Client.new(base, token: creds["token"])
+        framework = config.remote? ? nil : Everywhere::Framework.detect(root_path)
+        targets = resolve_targets(target, config)
+        ruby ||= config.build_ruby || "4.0.6"
+
+        Dir.mktmpdir("every-snapshot") do |tmp|
+          signed_id = snapshot_and_upload(client, root_path, tmp)
+          manifest = Everywhere::Receipt.new(
+            root: root_path, config: config, framework: framework, ruby: ruby,
+            target: targets.first, channel: channel
+          ).manifest
+
+          build = submit(client, targets, channel, signed_id, manifest)
+          UI.success("submitted #{UI.bold(build["id"])} for #{targets.join(", ")}")
+
+          return unless wait
+
+          final = poll_and_tail(client, build["id"])
+          report(client, final, output || File.join(root_path, "dist"), download)
+        end
+      rescue Everywhere::Error => e
+        UI.die!(e.message)
+      end
+
+      private
+
+      def snapshot_and_upload(client, root_path, tmp)
+        path = File.join(tmp, "snapshot.tar.gz")
+        UI.step("snapshotting source #{UI.dim("(honoring .everywhereignore)")}")
+        count = Everywhere::Platform::Snapshot.create(root_path, path)
+        size = File.size(path)
+        UI.step("#{count} files, #{mb(size)}MB")
+
+        reservation = client.post("/cli/direct_uploads",
+          filename: "snapshot.tar.gz", byte_size: size,
+          checksum: Everywhere::Platform::Snapshot.md5_base64(path), content_type: "application/gzip")
+        UI.die!("couldn't reserve upload (HTTP #{reservation.status})") unless reservation.ok?
+
+        upload = reservation.body["direct_upload"] || {}
+        UI.step("uploading snapshot")
+        res = client.put_file(upload["url"], path, headers: upload["headers"] || {})
+        UI.die!("snapshot upload failed (HTTP #{res.code})") unless res.code.to_i.between?(200, 299)
+
+        reservation.body["signed_id"]
+      end
+
+      def submit(client, targets, channel, signed_id, manifest)
+        res = client.post("/cli/builds",
+          targets: targets.join(","), channel: channel, snapshot_signed_id: signed_id, manifest: manifest)
+        return res.body if res.ok?
+
+        if res.status == 422 && res.body["error"] == "missing_credentials"
+          UI.bad("can't build yet — missing signing credentials:")
+          Array(res.body["targets"]).each do |t|
+            tgt = t["target"] || {}
+            UI.step("#{tgt["os"]}-#{tgt["arch"]}/#{tgt["distribution_channel"]}: add #{Array(t["missing"]).join(", ")}")
+          end
+          UI.step("set them up → #{UI.cyan(res.body["manage_url"])}")
+          exit 1
+        end
+        UI.die!("build submission failed (HTTP #{res.status}) #{res.body["error"]}")
+      end
+
+      def poll_and_tail(client, build_id)
+        printed = Hash.new("")
+        last = {}
+        loop do
+          res = client.get("/cli/builds/#{build_id}/logs")
+          if res.ok?
+            artifacts = res.body["artifacts"] || []
+            artifacts.each do |artifact|
+              tail_log(artifact, printed)
+              announce_status(artifact, last)
+            end
+            break if artifacts.any? && artifacts.all? { |a| terminal?(a["status"]) }
+          end
+          sleep(2)
+        end
+        client.get("/cli/builds/#{build_id}").body
+      end
+
+      def tail_log(artifact, printed)
+        full = artifact["log"].to_s
+        prev = printed[artifact["id"]]
+        return unless full.length > prev.length
+
+        print(full[prev.length..])
+        printed[artifact["id"]] = full
+      end
+
+      def announce_status(artifact, last)
+        return if last[artifact["id"]] == artifact["status"]
+
+        UI.step("#{label(artifact["target"])} → #{artifact["status"]}")
+        last[artifact["id"]] = artifact["status"]
+      end
+
+      def report(client, build, out_dir, download)
+        artifacts = build["artifacts"] || []
+        artifacts.each do |artifact|
+          if artifact["status"] == "succeeded"
+            report_success(client, artifact, out_dir, download)
+          else
+            UI.bad("#{label(artifact["target"])} — #{artifact["error"] || "failed"}")
+          end
+        end
+
+        if artifacts.all? { |a| a["status"] == "succeeded" }
+          UI.success("build #{build["id"]} complete")
+        else
+          UI.die!("build #{build["id"]} had failures")
+        end
+      end
+
+      def report_success(client, artifact, out_dir, download)
+        url = artifact["download_url"]
+        if download && url
+          FileUtils.mkdir_p(out_dir)
+          dest = File.join(out_dir, File.basename(artifact.dig("release", "artifact", "filename") || "#{label(artifact["target"])}.zip"))
+          client.download(url, dest)
+          UI.ok("#{label(artifact["target"])} ✓  #{dest}")
+        else
+          UI.ok("#{label(artifact["target"])} ✓  #{url}")
+        end
+      end
+
+      # everywhere.yml build.targets, or --target, or the macOS default.
+      def resolve_targets(override, config)
+        list = override ? override.split(",") : config.targets
+        list = ["macos-arm64"] if list.nil? || list.empty?
+        list.map(&:strip).reject(&:empty?)
+      end
+
+      def label(target)
+        target ? "#{target["os"]}-#{target["arch"]}" : "target"
+      end
+
+      def terminal?(status) = %w[succeeded failed].include?(status)
+
+      def mb(bytes) = (bytes / 1024.0 / 1024.0).round(1)
+    end
+  end
+end

data/lib/everywhere/commands/platform/login.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "dry/cli"
+require "socket"
+require_relative "../../ui"
+require_relative "../../platform/client"
+require_relative "../../platform/credentials"
+
+module Everywhere
+  module Commands
+    # `every platform login` — OAuth-style device flow: start a request, send the
+    # user to the browser to confirm the code and pick an org, then poll for the
+    # org-scoped token and save it locally.
+    class PlatformLogin < Dry::CLI::Command
+      desc "Log in to the RubyEverywhere Platform (device authorization)"
+
+      option :url, default: nil, desc: "Platform base URL (default: $EVERYWHERE_PLATFORM_URL or production)"
+
+      def call(url: nil, **)
+        base = Everywhere::Platform::Client.base_url(url)
+        client = Everywhere::Platform::Client.new(base)
+
+        start = client.post("/cli/device_authorizations", client_name: client_name)
+        UI.die!("couldn't start login — HTTP #{start.status}") unless start.ok?
+
+        verify_url = start.body["verification_uri_complete"] || start.body["verification_uri"]
+        UI.step("confirmation code: #{UI.bold(start.body["user_code"])}")
+        UI.step("opening #{UI.cyan(verify_url)}")
+        UI.step(UI.dim("browser didn't open? paste that URL yourself")) unless Everywhere::Platform.open_url(verify_url)
+        UI.step(UI.dim("waiting for you to approve in the browser…"))
+
+        result = poll(client, start.body["device_code"],
+                      [start.body["interval"].to_i, 1].max, start.body["expires_in"].to_i)
+
+        org = result["organization"] || {}
+        Everywhere::Platform::Credentials.load.set(base,
+          "token" => result["access_token"], "organization" => org)
+        UI.success("logged in to #{org["name"]} #{UI.dim("(#{org["id"]})")}")
+      rescue Everywhere::Error => e
+        UI.die!(e.message)
+      end
+
+      private
+
+      def poll(client, device_code, interval, expires_in)
+        deadline = monotonic + (expires_in.positive? ? expires_in : 600)
+        loop do
+          sleep(interval)
+          UI.die!("login timed out — run `every platform login` again") if monotonic > deadline
+
+          res = client.post("/cli/device_authorizations/token", device_code: device_code)
+          UI.die!("login failed — #{res.body["error"] || "invalid request"}") if res.status == 400
+          next unless res.ok? # transient 5xx/network: keep polling until the deadline
+
+          case res.body["status"]
+          when "approved" then return res.body
+          when "pending"  then interval = [res.body["interval"].to_i, interval].max
+          when "denied"   then UI.die!("request denied in the browser")
+          when "expired"  then UI.die!("the code expired — run `every platform login` again")
+          end
+        end
+      end
+
+      def monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      # Shown on the approval page + used as the token's name, so a user can tell
+      # their machines apart when reviewing/revoking tokens.
+      def client_name
+        host = Socket.gethostname.split(".").first
+        os = case RUBY_PLATFORM
+             when /darwin/ then "macOS"
+             when /mingw|mswin/ then "Windows"
+             else "Linux"
+             end
+        "#{host} (#{os})"
+      rescue StandardError
+        "RubyEverywhere CLI"
+      end
+    end
+  end
+end

data/lib/everywhere/commands/platform/logout.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "dry/cli"
+require_relative "../../ui"
+require_relative "../../platform/client"
+require_relative "../../platform/credentials"
+
+module Everywhere
+  module Commands
+    # `every platform logout` — revoke the token on the Platform, then drop the
+    # local credential.
+    class PlatformLogout < Dry::CLI::Command
+      desc "Log out of the RubyEverywhere Platform"
+
+      option :url, default: nil, desc: "Platform base URL"
+
+      def call(url: nil, **)
+        base = Everywhere::Platform::Client.base_url(url)
+        store = Everywhere::Platform::Credentials.load
+        creds = store.for(base)
+        return UI.step("not logged in to #{base}") unless creds
+
+        begin
+          Everywhere::Platform::Client.new(base, token: creds["token"]).delete("/cli/token")
+        rescue Everywhere::Error => e
+          UI.warn("couldn't reach the Platform to revoke (#{e.message}) — removing local credential anyway")
+        end
+
+        store.delete(base)
+        UI.success("logged out of #{base}")
+      end
+    end
+  end
+end