omaship 0.4.0 → 0.6.0

data/lib/omaship/cli.rb

@@ -1,7 +1,31 @@
 require "thor"
+require "securerandom"
+require "uri"
 
 module Omaship
   class CLI < Thor
+    PROVISION_STEP_MESSAGES = {
+      "resolve_source" => "Preparing your ship run",
+      "prepare_server" => "Preparing your harbor",
+      "scaffold_app" => "Scaffolding your ship",
+      "deploy_app" => "Deploying your ship",
+      "create_tunnel" => "Configuring private access",
+      "cutover_dns" => "Wiring up your ship routes",
+      "lockdown_firewall" => "Locking down the harbor",
+      "healthcheck" => "Running final health checks"
+    }.freeze
+    PROVISION_STEP_ETAS = {
+      "resolve_source" => "about 2 min",
+      "prepare_server" => "about 2 min",
+      "scaffold_app" => "about 90 sec",
+      "deploy_app" => "about 90 sec",
+      "create_tunnel" => "about 45 sec",
+      "cutover_dns" => "about 30 sec",
+      "lockdown_firewall" => "about 20 sec",
+      "healthcheck" => "less than 15 sec"
+    }.freeze
+    DEFAULT_PROVISIONING_ETA = "about 2 min"
+
     map "new" => :new_ship
     map "status" => :info
     map "ship" => :info
@@ -13,8 +37,16 @@ module Omaship
     end
 
     def self.start(given_args = ARGV, config = {})
+      if root_version_requested?(given_args)
+        $stdout.puts Omaship::VERSION
+        return
+      end
+
       normalized_args = normalize_help_args(given_args)
       super(normalized_args, config)
+    rescue Interrupt
+      $stderr.puts "\nAborted."
+      exit(130)
     end
 
     def self.normalize_help_args(given_args)
@@ -36,6 +68,10 @@ module Omaship
       args == [ "-h" ] || args == [ "--help" ] || args == [ "help" ]
     end
 
+    def self.root_version_requested?(args)
+      args == [ "-v" ] || args == [ "--version" ]
+    end
+
     def self.help(shell, subcommand = false)
       if subcommand
         super
@@ -48,10 +84,9 @@ module Omaship
         shell.say "  login      Store API token credentials locally"
         shell.say "  whoami     Show authenticated user"
         shell.say "  list       List ships you can access"
-        shell.say "  use        Set default ship from `omaship list` (for example: `omaship use omaship/acme`)"
+        shell.say "  use        Set default ship from `omaship list` (for example: `omaship use acme.omaship.app`)"
         shell.say "  info       Show details for a ship (aliases: ship, status)"
         shell.say "  new        Create and provision a new ship"
-        shell.say "  deploy     Deploy a ship (requires Full CLI access)"
         shell.say "  upgrade    Open browser to upgrade your plan"
         shell.say "  complete   Print shell completion script (bash, zsh, fish)"
         shell.say "  logout     Remove local CLI credentials"
@@ -101,26 +136,14 @@ module Omaship
         auth_payload = client.authenticate
         user_payload = auth_payload.fetch("user")
         account_payload = auth_payload.fetch("account", {})
-        token_payload = auth_payload.fetch("token", {})
         ship_count = account_payload.fetch("ship_count", 0).to_i
-        orgs = normalize_orgs(account_payload["orgs"])
-        access_level = token_payload.fetch("access_level", "unknown").to_s.strip
-        if access_level.empty?
-          access_level = "unknown"
-        end
-        default_ship_reference = credentials.default_ship.to_s.strip
+        plan = normalized_plan_label(plan: user_payload["plan"], admin: user_payload["admin"])
+        default_ship_reference = current_default_ship_reference(token: token)
 
         say "User: #{user_payload.fetch("email_address")}"
         say "Host: #{resolved_host}"
-        say "Access: #{access_level}"
+        say "Plan: #{plan}"
         say "Ships: #{ship_count}"
-        if ship_count.zero?
-          say "Orgs: none (no ships yet)"
-        elsif orgs.empty?
-          say "Orgs: unavailable"
-        else
-          say "Orgs: #{orgs.join(", ")}"
-        end
 
         if default_ship_reference.empty?
           say "Default Ship: -"
@@ -135,7 +158,7 @@ module Omaship
       with_api_error_handling(command: :list) do
         token = current_token
         ships = build_api_client(token: token).list_ships
-        default_ship_reference = credentials.default_ship.to_s.strip
+        default_ship_reference = current_default_ship_reference(token: token, ships: ships)
 
         if ships.empty?
           say "No ships available yet."
@@ -143,8 +166,7 @@ module Omaship
           say "Ships:"
           ships.each do |ship|
             marker = default_ship_match?(ship: ship, ship_reference: default_ship_reference) ? "*" : " "
-            app_url = ship["app_url"] || "-"
-            say "#{marker} #{ship.fetch("id")}  #{ship.fetch("full_name")}  #{ship.fetch("status")}  #{app_url}"
+            say ship_list_line(ship:, marker:)
           end
 
           if !default_ship_reference.empty?
@@ -160,11 +182,11 @@ module Omaship
       Set the default ship used by commands when `--ship` is omitted.
 
       Get available values with `omaship list`.
-      Preferred format is full ship name (`org/repo`), for example `omaship/acme`.
+      Use the ship domain from `omaship list`, for example `acme.omaship.app`.
       Numeric ship ids from `omaship list` also work.
 
       Examples:
-        omaship use omaship/acme
+        omaship use acme.omaship.app
         omaship use 17
     DESC
     def use(ship_reference)
@@ -173,67 +195,67 @@ module Omaship
         ship = find_ship_by_reference(token: token, ship_reference: ship_reference)
         persist_default_ship(ship)
 
-        say "Default ship set to #{ship.fetch("full_name")}."
+        say "Default ship set to #{ship.fetch("reference")}."
       end
     end
 
     desc "info", "Show ship info"
-    method_option :ship, type: :string, desc: "Ship from `omaship list` (preferred: omaship/acme; id also works)"
+    method_option :ship, type: :string, desc: "Ship from `omaship list` (use the ship domain or id)"
     def info
       with_api_error_handling(command: :info) do
         token = current_token
         client = build_api_client(token: token)
         resolved_ship = resolve_ship(token: token)
         ship = client.ship(ship_id: resolved_ship.fetch("id")).fetch("ship")
-        deploy = client.latest_deploy(ship_id: ship.fetch("id")).fetch("deploy")
         default_ship_reference = credentials.default_ship.to_s.strip
+        latest_voyage = latest_voyage_summary_for(ship:)
 
-        say "Ship: #{ship.fetch("full_name")}"
+        say "Ship: #{ship.fetch("display_name")}"
         say "ID: #{ship.fetch("id")}"
         say "Status: #{ship.fetch("status")}"
-        say "App URL: #{ship["app_url"] || "-"}"
-        say "Repo URL: #{ship["repo_url"] || "-"}"
-        say "Default Ship: #{default_ship_reference.empty? ? "-" : default_ship_reference}"
-        say "Last Deploy: #{deploy_status_summary(deploy)}"
-        if deploy["run_number"]
-          say "Run: ##{deploy.fetch("run_number")}"
+        say "Domain: #{ship["root_domain"] || "-"}"
+        app_url = ship["app_url"].to_s.strip
+        if !app_url.empty?
+          say "App: #{app_url}"
+        end
+        api_url = ship["api_url"].to_s.strip
+        if !api_url.empty?
+          say "API: #{api_url}"
         end
-        if deploy["started_at"]
-          say "Started At: #{deploy.fetch("started_at")}"
+        say "Default Ship: #{default_ship_reference.empty? ? "-" : default_ship_reference}"
+
+        if latest_voyage
+          say "Latest Voyage: #{latest_voyage.fetch(:kind)} (#{latest_voyage.fetch(:status)})"
+          if latest_voyage[:id]
+            say "Voyage ID: ##{latest_voyage.fetch(:id)}"
+          end
         end
       end
     end
 
     desc "new NAME", "Create and provision a new ship"
-    method_option :domain, type: :string, desc: "Root domain (defaults to NAME.com)"
-    method_option :skip_purpose, type: :boolean, default: false, desc: "Skip purpose profile questions"
+    method_option :domain, type: :string, desc: "Custom root domain"
     def new_ship(name)
       with_api_error_handling(command: :new_ship) do
         token = current_token
-        plan = fetch_plan(token: token)
+        auth = fetch_auth(token: token)
+        allowed_starter_kinds = allowed_starter_kinds_from_auth(auth)
 
-        if plan == "free"
-          create_free_ship(name: name, token: token)
-        else
-          create_paid_ship(name: name, token: token)
+        unless can_create_ship_from_auth?(auth)
+          raise Thor::Error, "Ship limit reached for your plan. Run `omaship upgrade` to create another ship."
         end
-      end
-    end
 
-    desc "deploy", "Deploy a ship (requires Full CLI access)"
-    method_option :ship, type: :string, desc: "Ship from `omaship list` (preferred: omaship/acme; id also works)"
-    def deploy
-      with_api_error_handling(command: :deploy) do
-        token = current_token
-        ship = resolve_ship_for_deploy(token: token)
-        ship_name = ship.fetch("full_name", "##{ship.fetch("id")}")
-
-        progress_renderer.step("Target ship: #{ship_name}.")
-
-        build_api_client(token: token).create_deploy(ship_id: ship.fetch("id"))
-        progress_renderer.step("Deploy requested.")
+        if allowed_starter_kinds == [ "landing" ]
+          create_free_ship(name: name, token: token)
+        else
+          starter_kind = choose_paid_starter_kind
 
-        poll_until_deploy_finished(ship_id: ship.fetch("id"), token: token)
+          if starter_kind == "landing"
+            create_paid_landingpage(name: name, token: token)
+          else
+            create_paid_ship(name: name, token: token, starter_kind: starter_kind, auth: auth)
+          end
+        end
       end
     end
 
@@ -295,7 +317,7 @@ module Omaship
             fi
 
             if [[ ${COMP_CWORD} -eq 1 ]]; then
-              COMPREPLY=( $(compgen -W "login whoami list use info status ship new deploy upgrade logout complete help" -- "${cur}") )
+              COMPREPLY=( $(compgen -W "login whoami list use info status ship new upgrade logout complete help" -- "${cur}") )
               return 0
             fi
 
@@ -324,11 +346,11 @@ module Omaship
               use)
                 COMPREPLY=( $(compgen -W "--host -h --help" -- "${cur}") )
                 ;;
-              info|status|ship|deploy)
+              info|status|ship)
                 COMPREPLY=( $(compgen -W "--ship --host -h --help" -- "${cur}") )
                 ;;
               new)
-                COMPREPLY=( $(compgen -W "--domain --skip-purpose --host -h --help" -- "${cur}") )
+                COMPREPLY=( $(compgen -W "--domain --host -h --help" -- "${cur}") )
                 ;;
               complete)
                 COMPREPLY=( $(compgen -W "bash zsh fish" -- "${cur}") )
@@ -366,7 +388,6 @@ module Omaship
               'status:Alias for info'
               'ship:Alias for info'
               'new:Create and provision a new ship'
-              'deploy:Deploy a ship'
               'upgrade:Open browser to upgrade your plan'
               'logout:Remove local CLI credentials'
               'complete:Print shell completion script'
@@ -393,11 +414,11 @@ module Omaship
                   use)
                     _arguments '--host[API host]:host:' '1:ship reference:_omaship_ship_refs'
                     ;;
-                  info|status|ship|deploy)
+                  info|status|ship)
                     _arguments '--ship[Ship from omaship list]:ship:_omaship_ship_refs' '--host[API host]:host:'
                     ;;
                   new)
-                    _arguments '--domain[Root domain]:domain:' '--skip-purpose[Skip purpose questions]' '--host[API host]:host:' '1:name:'
+                    _arguments '--domain[Root domain]:domain:' '--host[API host]:host:' '1:name:'
                     ;;
                   complete)
                     _arguments '1:shell:(bash zsh fish)'
@@ -421,30 +442,88 @@ module Omaship
           end
 
           complete -c omaship -f
-          complete -c omaship -n '__fish_use_subcommand' -a 'login whoami list use info status ship new deploy upgrade logout complete help'
           complete -c omaship -l host -d 'API host'
+          complete -c omaship -n '__fish_use_subcommand' -a 'login' -d 'Store API token credentials locally'
+          complete -c omaship -n '__fish_use_subcommand' -a 'whoami' -d 'Show authenticated user'
+          complete -c omaship -n '__fish_use_subcommand' -a 'list' -d 'List ships you can access'
+          complete -c omaship -n '__fish_use_subcommand' -a 'use' -d 'Set default ship from omaship list'
+          complete -c omaship -n '__fish_use_subcommand' -a 'info' -d 'Show ship info'
+          complete -c omaship -n '__fish_use_subcommand' -a 'status' -d 'Alias for info'
+          complete -c omaship -n '__fish_use_subcommand' -a 'ship' -d 'Alias for info'
+          complete -c omaship -n '__fish_use_subcommand' -a 'new' -d 'Create and provision a new ship'
+          complete -c omaship -n '__fish_use_subcommand' -a 'upgrade' -d 'Open browser to upgrade your plan'
+          complete -c omaship -n '__fish_use_subcommand' -a 'logout' -d 'Remove local CLI credentials'
+          complete -c omaship -n '__fish_use_subcommand' -a 'complete' -d 'Print shell completion script'
+          complete -c omaship -n '__fish_use_subcommand' -a 'help' -d 'Describe available commands'
 
           complete -c omaship -n '__fish_seen_subcommand_from login' -l token -d 'API token from omaship settings'
           complete -c omaship -n '__fish_seen_subcommand_from new' -l domain -d 'Root domain'
-          complete -c omaship -n '__fish_seen_subcommand_from new' -l skip-purpose -d 'Skip purpose questions'
-          complete -c omaship -n '__fish_seen_subcommand_from info status ship deploy' -l ship -d 'Ship from omaship list' -a '(__fish_omaship_ship_refs)'
+          complete -c omaship -n '__fish_seen_subcommand_from info status ship' -l ship -d 'Ship from omaship list' -a '(__fish_omaship_ship_refs)'
           complete -c omaship -n '__fish_seen_subcommand_from use' -f -a '(__fish_omaship_ship_refs)'
           complete -c omaship -n '__fish_seen_subcommand_from complete' -f -a 'bash zsh fish'
         FISH
       end
 
-      def fetch_plan(token:)
-        auth = build_api_client(token: token).authenticate
-        auth.dig("user", "plan") || "free"
+      def fetch_auth(token:)
+        build_api_client(token: token).authenticate
+      end
+
+      def can_create_ship_from_auth?(auth)
+        can_create_ship = auth.dig("account", "can_create_ship")
+        return can_create_ship unless can_create_ship.nil?
+
+        legacy_plan = auth.dig("user", "plan").to_s
+        return false if legacy_plan.empty?
+
+        if legacy_plan == "free"
+          auth.dig("account", "ship_count").to_i < 1
+        else
+          true
+        end
+      end
+
+      def allowed_starter_kinds_from_auth(auth)
+        allowed_starter_kinds = Array(auth.dig("account", "allowed_starter_kinds"))
+          .map(&:to_s)
+          .reject(&:empty?)
+          .uniq
+
+        return allowed_starter_kinds if allowed_starter_kinds.any?
+
+        legacy_plan = auth.dig("user", "plan").to_s
+
+        if legacy_plan == "free"
+          [ "landing" ]
+        elsif legacy_plan.empty?
+          []
+        else
+          %w[landing app api]
+        end
       end
 
-      def create_paid_ship(name:, token:)
-        root_domain = options[:domain] || "#{name}.com"
-        payload = build_api_client(token: token).create_ship(root_domain: root_domain)
+      def create_paid_ship(name:, token:, starter_kind:, auth:)
+        identifier_suffix = generated_identifier_suffix
+        root_domain = requested_root_domain
+        harbor_id = choose_harbor_id(auth: auth)
+        payload = build_api_client(token: token).create_ship(
+          name: name,
+          harbor_id: harbor_id,
+          root_domain: root_domain,
+          bring_own_domain: root_domain.empty? ? "0" : "1",
+          identifier_suffix: identifier_suffix,
+          starter_kind: starter_kind
+        )
         ship = payload.fetch("ship")
+        progress_renderer.start_activity(
+          "Setting up #{ship_display_name(ship, fallback: name, suffix: identifier_suffix)}",
+          eta: DEFAULT_PROVISIONING_ETA
+        )
 
-        progress_renderer.step("Setting up your codebase")
-        final_ship = poll_until_terminal(ship_id: ship.fetch("id"), token: token)
+        begin
+          final_ship = poll_until_terminal(ship_id: ship.fetch("id"), token: token)
+        ensure
+          progress_renderer.finish_activity
+        end
 
         if final_ship.fetch("status") == "live"
           progress_renderer.step("Ready. Customers can sign up and pay at #{final_ship.fetch("root_domain")}")
@@ -454,23 +533,48 @@ module Omaship
         end
       end
 
-      def create_free_ship(name:, token:)
-        print_free_banner
+      def choose_paid_starter_kind
+        say
+        say "--- Ship Type ---"
+        selected = ship_type_picker.pick
+        say "Selected: #{Omaship::ShipTypePicker.label_for(selected)}"
+        selected
+      end
 
-        purpose_profile = {}
-        color_scheme = "mono-dark"
+      def choose_harbor_id(auth:)
+        ready_harbors = ready_harbors_from_auth(auth)
 
-        unless options[:skip_purpose]
-          if ask_purpose_profile?
-            purpose_profile = collect_purpose_profile
-          end
-          color_scheme = pick_color_scheme
+        if ready_harbors.empty?
+          raise Thor::Error, "No ready harbor available. Provision a managed harbor in Omaship before launching a full app or API."
         end
 
+        say
+        say "--- Harbor ---"
+        selected = harbor_picker(ready_harbors).pick
+        say "Selected harbor: #{harbor_label(ready_harbors, selected)}"
+        selected
+      end
+
+      def create_paid_landingpage(name:, token:)
+        create_landingpage_ship(name: name, token: token, show_free_banner: false)
+      end
+
+      def create_free_ship(name:, token:)
+        create_landingpage_ship(name: name, token: token, show_free_banner: true)
+      end
+
+      def create_landingpage_ship(name:, token:, show_free_banner:)
+        if show_free_banner
+          print_free_banner
+        end
+
+        purpose_profile = collect_purpose_profile
+        color_scheme = pick_color_scheme
+
         say
         progress_renderer.step("Creating your landing page...")
 
-        payload = build_api_client(token: token).create_landing_page(
+        payload = build_api_client(token: token).create_landingpage(
           name: name,
           color_scheme: color_scheme,
           purpose_profile: purpose_profile
@@ -483,8 +587,8 @@ module Omaship
         end
 
         say
-        say "Live at: https://#{ship.fetch("root_domain")}"
-        say "Review and refine at: #{resolved_host}/ships/#{ship.fetch("id")}/purpose_profile"
+        say "Live at: #{landingpage_url(ship)}"
+        say "Review and refine at: #{ship_dashboard_url(ship)}"
       end
 
       def print_free_banner
@@ -509,24 +613,19 @@ module Omaship
         say
       end
 
-      def ask_purpose_profile?
-        say "Would you like to create a purpose profile?"
-        say "This helps generate better landing page copy. (5 questions, ~2 min)"
-        say
-        answer = ask("Continue with purpose profile? (Y/n):")
-        answer.to_s.strip.downcase != "n"
-      end
-
       def collect_purpose_profile
+        say
+        say "We'll start with a purpose profile."
+        say "This helps generate better landing page copy. (5 questions, ~2 min)"
         say
         say "--- Purpose Profile ---"
         say
 
-        raw_problem = ask("What problem does your product solve?\n>")
-        raw_audience = ask("Who is most affected by this problem?\n>")
-        raw_belief = ask("Why is this worth solving? What's your core belief?\n>")
-        raw_contribution = ask("What's your contribution to the solution?\n>")
-        raw_outcome = ask("What does the world look like when you succeed?\n>")
+        raw_problem = ask_question("What problem does your product solve?")
+        raw_audience = ask_question("Who is most affected by this problem?")
+        raw_belief = ask_question("Why is this worth solving? What's your core belief?")
+        raw_contribution = ask_question("What's your contribution to the solution?")
+        raw_outcome = ask_question("What does the world look like when you succeed?")
 
         {
           raw_problem: raw_problem,
@@ -545,10 +644,64 @@ module Omaship
         selected
       end
 
+      def ask_question(question)
+        say question
+        ask("> ")
+      end
+
       def color_picker
         @color_picker ||= Omaship::ColorPicker.new
       end
 
+      def ship_type_picker
+        @ship_type_picker ||= Omaship::ShipTypePicker.new
+      end
+
+      def harbor_picker(harbors)
+        Omaship::HarborPicker.new(harbors: harbors)
+      end
+
+      def ready_harbors_from_auth(auth)
+        Array(auth.dig("account", "ready_harbors")).map do |harbor|
+          {
+            "id" => harbor["id"] || harbor[:id],
+            "name" => harbor["name"] || harbor[:name],
+            "status" => harbor["status"] || harbor[:status],
+            "management" => harbor["management"] || harbor[:management]
+          }
+        end.select { |harbor| harbor["id"] && harbor["name"].to_s.strip != "" }
+      end
+
+      def harbor_label(harbors, harbor_id)
+        harbor = harbors.find { |entry| entry["id"].to_s == harbor_id.to_s }
+        if harbor
+          harbor["name"].to_s
+        else
+          harbor_id.to_s
+        end
+      end
+
+      def landingpage_url(ship)
+        root_domain = ship.fetch("root_domain").to_s.strip
+        return "" if root_domain.empty?
+
+        base_url = URI.parse(resolved_host)
+        scheme = base_url.scheme.to_s.strip
+        scheme = "https" if scheme.empty?
+
+        port = base_url.port
+        default_port = scheme == "https" ? 443 : 80
+        port_suffix = port == default_port ? "" : ":#{port}"
+
+        "#{scheme}://#{root_domain}#{port_suffix}/"
+      rescue URI::InvalidURIError
+        "https://#{root_domain}/"
+      end
+
+      def ship_dashboard_url(ship)
+        "#{resolved_host.to_s.sub(%r{/*$}, "")}/ships/#{ship.fetch("id")}"
+      end
+
       def poll_until_distilled(ship_id:, token:)
         client = build_api_client(token: token)
         30.times do
@@ -584,7 +737,7 @@ module Omaship
 
       def resolve_ship_without_explicit_selection(token:)
         ships = build_api_client(token: token).list_ships
-        default_ship_reference = credentials.default_ship.to_s.strip
+        default_ship_reference = current_default_ship_reference(token: token, ships: ships)
 
         if !default_ship_reference.empty?
           default_ship = match_ship(ships: ships, ship_reference: default_ship_reference)
@@ -614,7 +767,7 @@ module Omaship
         if ship
           ship
         else
-          raise Thor::Error, "Unknown ship `#{ship_reference}`. Run `omaship list` and use the full ship name (for example: `omaship use omaship/acme`) or the numeric id."
+          raise Thor::Error, "Unknown ship `#{ship_reference}`. Run `omaship list` and use the ship domain from the list, or the numeric id."
         end
       end
 
@@ -625,25 +778,13 @@ module Omaship
       end
 
       def default_ship_match?(ship:, ship_reference:)
-        ship.fetch("id").to_s == ship_reference || ship.fetch("full_name") == ship_reference
+        ship.fetch("id").to_s == ship_reference ||
+          ship.fetch("reference") == ship_reference ||
+          ship["full_name"] == ship_reference
       end
 
       def persist_default_ship(ship)
-        credentials.write_default_ship(ship.fetch("full_name"))
-      end
-
-      def resolve_ship_for_deploy(token:)
-        resolve_ship(token: token)
-      rescue Thor::Error => error
-        if options[:ship].to_s.strip.empty? && selection_error_message?(error.message)
-          raise Thor::Error, "#{error.message} `omaship deploy` also requires a full-access token."
-        end
-
-        raise
-      end
-
-      def selection_error_message?(message)
-        message == no_ships_message || message == multiple_ships_message
+        credentials.write_default_ship(ship.fetch("reference"))
       end
 
       def no_ships_message
@@ -651,7 +792,7 @@ module Omaship
       end
 
       def multiple_ships_message
-        "Multiple ships found. Run `omaship list` and `omaship use <org/repo>` (or a ship id)."
+        "Multiple ships found. Run `omaship list` and `omaship use <ship-from-list>` (or a ship id)."
       end
 
       def with_api_error_handling(command:)
@@ -665,15 +806,24 @@ module Omaship
       end
 
       def permission_denied_message(command:)
-        if command == :new_ship
+        if current_access_level == "onboarding"
+          "This onboarding token only supports `omaship new` while you create your first ship. Create a full-access token in Settings after onboarding to use other CLI commands."
+        elsif command == :new_ship
           "`omaship new` requires a full-access token. Create a token with Full CLI access and run `omaship login` again."
-        elsif command == :deploy
-          "`omaship deploy` requires a full-access token. Create a token with Full CLI access and run `omaship login` again."
         else
           "Permission denied for this action. Check your token scopes and run `omaship login` again."
         end
       end
 
+      def current_access_level
+        token = credentials.token
+        return "unknown" if token.to_s.strip.empty?
+
+        build_api_client(token: token).authenticate.dig("token", "access_level").to_s
+      rescue NoMethodError, Omaship::ApiClient::Error
+        "unknown"
+      end
+
       def build_api_client(token:)
         Omaship::ApiClient.new(host: resolved_host, token: token)
       end
@@ -690,8 +840,9 @@ module Omaship
         client = build_api_client(token: token)
         90.times do
           ship_payload = client.ship(ship_id: ship_id).fetch("ship")
+          update_provisioning_activity(client: client, ship_payload: ship_payload)
           status = ship_payload.fetch("status")
-          if %w[live error].include?(status)
+          if %w[live error deploy_failed].include?(status)
             return ship_payload
           end
           sleep 2
@@ -700,53 +851,71 @@ module Omaship
         raise Thor::Error, "Provisioning timed out."
       end
 
-      def poll_until_deploy_finished(ship_id:, token:)
-        client = build_api_client(token: token)
-        last_status = nil
-        90.times do
-          deploy_payload = client.latest_deploy(ship_id: ship_id).fetch("deploy")
-          status = deploy_payload.fetch("status")
-          conclusion = deploy_payload["conclusion"]
-          if status != last_status
-            emit_deploy_status(status: status)
-            last_status = status
-          end
+      def update_provisioning_activity(client:, ship_payload:)
+        latest_voyage = ship_payload["latest_voyage"]
+        voyage_id = latest_voyage && latest_voyage["id"]
+        return if voyage_id.to_s.strip.empty?
 
-          if status == "completed"
-            if conclusion == "success"
-              progress_renderer.step("Live. 34 seconds, zero downtime.")
-              return
-            end
-            raise Thor::Error, "Deploy failed with conclusion: #{conclusion || 'unknown'}"
-          end
+        voyage_payload = client.voyage(voyage_id: voyage_id).fetch("voyage")
+        progress_renderer.update_activity(
+          message: provisioning_message_for(voyage_payload: voyage_payload),
+          eta: provisioning_eta_for(voyage_payload: voyage_payload)
+        )
+      rescue Omaship::ApiClient::Error
+      end
 
-          sleep 2
-        end
+      def provisioning_message_for(voyage_payload:)
+        step = current_voyage_step(voyage_payload:)
 
-        raise Thor::Error, "Deploy timed out."
+        if step
+          PROVISION_STEP_MESSAGES.fetch(step.fetch("step_key"), "Setting up your codebase")
+        elsif voyage_payload["status"] == "queued"
+          "Queueing your provisioning run"
+        else
+          "Setting up your codebase"
+        end
       end
 
-      def deploy_status_summary(deploy_payload)
-        status = deploy_payload.fetch("status")
-        conclusion = deploy_payload["conclusion"].to_s.strip
+      def provisioning_eta_for(voyage_payload:)
+        step = current_voyage_step(voyage_payload:)
 
-        if conclusion.empty?
-          status
+        if step
+          PROVISION_STEP_ETAS.fetch(step.fetch("step_key"), DEFAULT_PROVISIONING_ETA)
         else
-          "#{status} (#{conclusion})"
+          DEFAULT_PROVISIONING_ETA
         end
       end
 
-      def emit_deploy_status(status:)
-        if status == "not_found"
-          progress_renderer.step("Waiting for deploy workflow run.")
-        elsif %w[queued requested waiting pending].include?(status)
-          progress_renderer.step("Deploy queued.")
-        elsif status == "in_progress"
-          progress_renderer.step("Deploy in progress.")
-        elsif status != "completed"
-          progress_renderer.step("Deploy status: #{status}.")
-        end
+      def current_voyage_step(voyage_payload:)
+        steps = Array(voyage_payload["steps"])
+        running_step = steps.reverse.find { |step| step["status"] == "running" }
+        return running_step if running_step
+
+        queued_step = steps.reverse.find { |step| step["status"] == "queued" }
+        return queued_step if queued_step
+
+        steps.last
+      end
+
+      def requested_root_domain
+        options[:domain].to_s.strip.downcase
+      end
+
+      def generated_identifier_suffix
+        SecureRandom.hex(2)
+      end
+
+      def ship_display_name(ship, fallback:, suffix:)
+        display_name = ship["display_name"].to_s.strip
+        return display_name unless display_name.empty?
+
+        base_name = ship["name"].to_s.strip
+        return base_name unless base_name.empty?
+
+        normalized_fallback = fallback.to_s.parameterize
+        return normalized_fallback if normalized_fallback.end_with?("-#{suffix}")
+
+        "#{normalized_fallback}-#{suffix}"
       end
 
       def open_browser(url)
@@ -769,8 +938,75 @@ module Omaship
         end
       end
 
-      def normalize_orgs(orgs)
-        Array(orgs).map(&:to_s).map(&:strip).reject(&:empty?).uniq.sort
+      def current_default_ship_reference(token:, ships: nil)
+        default_ship_reference = credentials.default_ship.to_s.strip
+        return "" if default_ship_reference.empty?
+
+        if ships
+          normalize_default_ship_reference(default_ship_reference:, ships:)
+        elsif legacy_default_ship_reference?(default_ship_reference)
+          normalize_default_ship_reference(
+            default_ship_reference:,
+            ships: build_api_client(token: token).list_ships
+          )
+        else
+          default_ship_reference
+        end
+      end
+
+      def normalize_default_ship_reference(default_ship_reference:, ships:)
+        ship = match_ship(ships:, ship_reference: default_ship_reference)
+
+        if ship
+          normalized_reference = ship.fetch("reference")
+
+          if normalized_reference != default_ship_reference
+            credentials.write_default_ship(normalized_reference)
+          end
+
+          normalized_reference
+        else
+          credentials.clear_default_ship
+          ""
+        end
+      end
+
+      def legacy_default_ship_reference?(default_ship_reference)
+        default_ship_reference.include?("/")
+      end
+
+      def normalized_plan_label(plan:, admin: false)
+        return "Master" if admin
+
+        value = plan.to_s.strip
+
+        if value.empty?
+          "Unknown"
+        else
+          value.split(/[_-]/).map(&:capitalize).join(" ")
+        end
+      end
+
+      def ship_list_line(ship:, marker:)
+        line = "#{marker} #{ship.fetch("id")}  #{ship.fetch("reference")}"
+        display_name = ship.fetch("display_name").to_s.strip
+
+        if !display_name.empty? && display_name != ship.fetch("reference")
+          line = "#{line}  #{display_name}"
+        end
+
+        "#{line}  #{ship.fetch("status")}  #{ship.fetch("primary_url", "-") || "-"}"
+      end
+
+      def latest_voyage_summary_for(ship:)
+        voyage = ship["latest_voyage"]
+        return unless voyage
+
+        {
+          id: voyage["id"],
+          kind: voyage["kind"],
+          status: voyage["status"]
+        }
       end
   end
 end