kyper 0.1.0

data/lib/kyper_cli/commands/logs.rb

@@ -0,0 +1,91 @@
+module KyperCli
+  module Commands
+    class Logs < Thor
+      include Helpers
+
+      POLL_INTERVAL = 2 # seconds between log-polling requests
+
+      no_commands do
+        # Streams build log to stdout via cursor-based polling.
+        # Returns the final status string (e.g. "in_review", "build_failed").
+        # Called by Push and RetryBuild commands to stream log in real time.
+        def tail_log(version_id, from: 0)
+          client    = Client.new
+          cursor    = from
+          printed   = false
+          last_data = nil
+
+          deadline = Time.now + (30 * 60) # 30 minute max
+          loop do
+            if Time.now > deadline
+              say "\nTimed out waiting for build to complete (30 min). Check status with `kyper versions`.", :red
+              exit 1
+            end
+
+            last_data = client.version_build_log(version_id, cursor: cursor)
+            chunk     = last_data["log"].to_s
+            cursor    = last_data["cursor"].to_i
+
+            if chunk.length.positive?
+              print chunk
+              $stdout.flush
+              printed = true
+            end
+
+            break if last_data["complete"]
+            sleep POLL_INTERVAL
+          end
+
+          puts "" if printed
+          say "  " + ("─" * 56)
+
+          final_status = last_data["status"]
+          case final_status
+          when "in_review"
+            say "  ✔ Build complete! Submitted for review.", :green
+          when "build_failed"
+            say "  ✗ Build failed.", :red
+            say "  Run `kyper retry` to try again.", :yellow
+          when "published"
+            say "  ✔ Published.", :green
+          else
+            say "  Status: #{final_status}"
+          end
+          say ""
+
+          final_status
+        end
+      end
+
+      desc "logs", "Show the build log for the latest version of your app"
+      def logs
+        require_auth!
+        yml = load_kyper_yml!
+        slug = to_slug(yml["name"])
+
+        status_data = Client.new.app_status(slug)
+        version_data = status_data["latest_version"]
+
+        unless version_data
+          say "No versions pushed yet.", :yellow
+          exit 0
+        end
+
+        version_id = version_data["id"]
+        unless version_id
+          say "Build log unavailable (update your Kyper CLI).", :yellow
+          exit 0
+        end
+
+        say ""
+        say "  Build log — #{status_data["app"]} v#{version_data["version"]} (#{version_data["status"]})"
+        say "  " + ("─" * 56)
+
+        tail_log(version_id, from: 0)
+      rescue KyperCli::Error => e
+        say "Error: #{e.message}", :red
+        exit 1
+      end
+    end
+  end
+end

data/lib/kyper_cli/commands/push.rb

@@ -0,0 +1,120 @@
+require "tty-spinner"
+
+module KyperCli
+  module Commands
+    class Push < Thor
+      include Helpers
+
+      desc "push", "Validate, package, and submit the current version to Kyper for review"
+      def push
+        require_auth!
+
+        unless File.exist?(Config::KYPER_FILE)
+          say "Error: No kyper.yml found. Run `kyper init` to create one.", :red
+          exit 1
+        end
+
+        raw_yml = File.read(Config::KYPER_FILE)
+        yml     = YAML.safe_load(raw_yml)
+        slug    = to_slug(yml["name"])
+
+        say ""
+        say "  Validating kyper.yml..."
+        validator = Commands::Validate.new
+        unless validator.validate_yml(yml)
+          say ""
+          say "  Fix the errors above, then run `kyper push` again.", :red
+          say ""
+          exit 1
+        end
+        say ""
+
+        zip_path = nil
+        version_id = nil
+        client = Client.new
+
+        begin
+          zip_path   = build_zip_with_spinner!
+          version_id = upload_with_spinner!(client, slug, yml, raw_yml, zip_path)
+        ensure
+          File.delete(zip_path) if zip_path && File.exist?(zip_path)
+        end
+
+        say ""
+        say "  Following build log... (Ctrl+C to stop)"
+        say "  " + ("─" * 56)
+        final_status = Commands::Logs.new.tail_log(version_id, from: 0)
+
+        offer_retry(version_id, client, final_status)
+      rescue KyperCli::Error => e
+        say ""
+        say "  Error: #{e.message}", :red
+        say ""
+        exit 1
+      end
+
+      private
+
+      def build_zip_with_spinner!
+        zip_path = File.join(Dir.tmpdir, "kyper_push_#{Process.pid}.zip")
+        spinner  = new_spinner("Building archive")
+        ignore   = load_kyperignore
+        exclude_args = (ignore + [ ".git/*", "*.log", "tmp/*" ]).flat_map { |p| [ "--exclude", p ] }
+
+        ok = system("zip", "-r", zip_path, ".", *exclude_args, "-q")
+        unless ok
+          spinner.error("Failed to build archive")
+          raise KyperCli::Error, "zip command failed — is `zip` installed?"
+        end
+
+        size_mb = (File.size(zip_path).to_f / (1024 * 1024)).round(1)
+        spinner.success("#{size_mb} MB packed")
+        zip_path
+      end
+
+      def upload_with_spinner!(client, slug, yml, raw_yml, zip_path)
+        spinner = new_spinner("Uploading")
+        begin
+          ensure_app_exists!(client, slug, yml)
+          result     = client.push_version(slug, raw_yml, zip_path: zip_path)
+          version_id = result["id"]
+          spinner.success("Uploaded — build queued (version ##{version_id})")
+          version_id
+        rescue KyperCli::Error
+          spinner.error("Upload failed")
+          raise
+        end
+      end
+
+      def ensure_app_exists!(client, slug, yml)
+        client.app_status(slug)
+      rescue KyperCli::Error
+        client.create_app(name: yml["name"], slug: slug)
+      end
+
+      def offer_retry(version_id, client, final_status)
+        return unless final_status == "build_failed"
+
+        say ""
+        return unless TTY::Prompt.new.yes?("  Retry build?")
+
+        say ""
+        client.version_retry(version_id)
+        say "  ✔ Build queued.", :green
+        say ""
+        say "  Following build log..."
+        say "  " + ("─" * 56)
+        Commands::Logs.new.tail_log(version_id, from: 0)
+      end
+
+      def new_spinner(label)
+        TTY::Spinner.new("  [:spinner] #{label}...", format: :dots, success_mark: "✔", error_mark: "✗").tap(&:auto_spin)
+      end
+
+      def load_kyperignore
+        return [] unless File.exist?(".kyperignore")
+        File.readlines(".kyperignore").map(&:strip).reject { |l| l.empty? || l.start_with?("#") }
+      end
+    end
+  end
+end

data/lib/kyper_cli/commands/retry_build.rb

@@ -0,0 +1,42 @@
+module KyperCli
+  module Commands
+    class RetryBuild < Thor
+      include Helpers
+
+      desc "retry", "Retry a failed build for the current app"
+      def retry_build
+        require_auth!
+        yml = load_kyper_yml!
+        slug = to_slug(yml["name"])
+
+        status_data = Client.new.app_status(slug)
+        version_data = status_data["latest_version"]
+
+        unless version_data
+          say "No versions pushed yet.", :yellow
+          exit 0
+        end
+
+        unless version_data["status"] == "build_failed"
+          say "Latest version (#{version_data["version"]}) is not in a failed state — status: #{version_data["status"]}.", :yellow
+          exit 0
+        end
+
+        version_id = version_data["id"]
+        say ""
+        say "  Retrying build for #{status_data["app"]} v#{version_data["version"]}..."
+
+        Client.new.version_retry(version_id)
+        say "  ✔ Build queued.", :green
+        say ""
+
+        say "  Following build log... (Ctrl+C to stop)"
+        say "  " + ("─" * 56)
+        Commands::Logs.new.tail_log(version_id, from: 0)
+      rescue KyperCli::Error => e
+        say "Error: #{e.message}", :red
+        exit 1
+      end
+    end
+  end
+end

data/lib/kyper_cli/commands/status.rb

@@ -0,0 +1,33 @@
+module KyperCli
+  module Commands
+    class Status < Thor
+      include Helpers
+
+      desc "status", "Show the review status of your app"
+      def status
+        require_auth!
+        yml = load_kyper_yml!
+
+        slug = to_slug(yml["name"])
+
+        begin
+          data = Client.new.app_status(slug)
+          say ""
+          say "#{data["app"]} — #{data["status"].upcase}"
+
+          if (v = data["latest_version"])
+            say "  Latest version : #{v["version"]}"
+            say "  Review status  : #{v["status"]}"
+            say "  Notes          : #{v["review_notes"]}" if !v["review_notes"].to_s.empty?
+          else
+            say "  No versions pushed yet."
+          end
+          say ""
+        rescue KyperCli::Error => e
+          say "Error: #{e.message}", :red
+          exit 1
+        end
+      end
+    end
+  end
+end

data/lib/kyper_cli/commands/validate.rb

@@ -0,0 +1,174 @@
+require "yaml"
+
+module KyperCli
+  module Commands
+    class Validate < Thor
+      SEMVER_RE = /\A\d+\.\d+\.\d+\z/
+
+      CATEGORIES = %w[
+        developer_tools productivity finance health media
+        education business_operations data_analytics gaming
+      ].freeze
+
+      KNOWN_DEPS = %w[postgres mysql redis elasticsearch opensearch].freeze
+      DB_DEPS    = %w[postgres mysql].freeze
+
+      ALLOWED_DEP_VERSIONS = {
+        "postgres"      => %w[14 15 16],
+        "mysql"         => %w[8],
+        "redis"         => %w[6 7],
+        "elasticsearch" => %w[8],
+        "opensearch"    => %w[2]
+      }.freeze
+
+      desc "validate", "Validate kyper.yml before pushing"
+      def validate
+        yml = load_kyper_yml!
+        errors, warnings = run_checks(yml)
+
+        if errors.empty?
+          if warnings.any?
+            say ""
+            warnings.each { |w| say "  ⚠ #{w}", :yellow }
+          end
+          say ""
+          say "  All checks passed — ready to push.", :green
+          say ""
+          true
+        else
+          say ""
+          errors.each { |e| say "  #{e}", :red }
+          say ""
+          false
+        end
+      end
+
+      no_commands do
+        # Called by Push command — returns true/false without re-printing header.
+        def validate_yml(yml)
+          errors, _warnings = run_checks(yml)
+          errors.empty?
+        end
+      end
+
+      private
+
+      def run_checks(yml)
+        errors   = []
+        warnings = []
+
+        check("name present", yml["name"].to_s.strip.length.positive?) { errors << "name is required" }
+        check("name ≤ 100 chars", yml["name"].to_s.length <= 100) { errors << "name must be 100 characters or fewer" }
+
+        v = yml["version"].to_s
+        check("version present", v.length.positive?) { errors << "version is required" }
+        check("version is semver", !v.empty? && SEMVER_RE.match?(v)) { errors << "version must be semver (e.g. 1.0.0)" }
+
+        cat = yml["category"].to_s
+        check("category present", cat.length.positive?) { errors << "category is required" }
+        if cat.length.positive? && !CATEGORIES.include?(cat)
+          say_check(false, "category valid")
+          errors << "category must be one of: #{CATEGORIES.join(", ")}"
+        end
+
+        docker = yml["docker"] || {}
+        if docker["image"].to_s.length.positive?
+          say_check(false, "docker section")
+          errors << "docker.image is not supported — provide a dockerfile path (see ADR-001)"
+        else
+          df = docker["dockerfile"].to_s
+          check("docker.dockerfile set", df.length.positive?) { errors << "docker.dockerfile is required" }
+          if df.length.positive?
+            check("Dockerfile exists at #{df}", File.exist?(df)) { errors << "Dockerfile not found at #{df}" }
+          end
+        end
+
+        procs = yml["processes"]
+        if procs
+          has_web = procs.is_a?(Hash) && (procs.key?("web") || procs.key?(:web))
+          check("processes.web defined", has_web) { errors << "processes must include a \"web\" key" }
+        else
+          say_check(false, "processes.web defined")
+          errors << "processes section is required (must include at least a \"web\" key)"
+        end
+
+        deps = yml["deps"]
+        if deps.is_a?(Array) && deps.any?
+          # Support plain strings ("postgres"), version hashes ({"postgres" => "15"}),
+          # and version+storage hashes ({"postgres" => "15", "storage_gb" => 50}).
+          dep_names = deps.map do |d|
+            d.is_a?(Hash) ? (d.keys.map(&:to_s) - %w[storage_gb]).first.to_s : d.to_s
+          end
+          unknown = dep_names - KNOWN_DEPS
+          if unknown.any?
+            say_check(false, "deps valid")
+            errors << "unknown deps: #{unknown.join(", ")}. Allowed: #{KNOWN_DEPS.join(", ")}"
+          else
+            deps.each do |d|
+              next unless d.is_a?(Hash)
+              name    = (d.keys.map(&:to_s) - %w[storage_gb]).first.to_s
+              version = (d[name] || d[name.to_sym]).to_s
+              next if version.empty?
+              allowed = ALLOWED_DEP_VERSIONS.fetch(name, [])
+              unless allowed.include?(version)
+                say_check(false, "#{name} version")
+                errors << "#{name}: version \"#{version}\" is not supported. Allowed: #{allowed.join(", ")}"
+              end
+            end
+
+            dep_labels = deps.map do |d|
+              if d.is_a?(Hash)
+                name = (d.keys.map(&:to_s) - %w[storage_gb]).first.to_s
+                ver  = d[name] || d[name.to_sym]
+                gb   = d["storage_gb"] || d[:storage_gb]
+                [ name, ver && "v#{ver}", gb && "#{gb}GB" ].compact.join(":")
+              else
+                d.to_s
+              end
+            end
+            say_check(true, "deps: #{dep_labels.join(", ")}")
+          end
+
+          # Warn if a DB dep is present but no on_deploy hook is configured.
+          if (dep_names & DB_DEPS).any?
+            on_deploy = (yml["hooks"] || {})["on_deploy"].to_s.strip
+            if on_deploy.empty?
+              say_check(false, "hooks.on_deploy (warning)")
+              warnings << "hooks.on_deploy is not set — apps with a database dep typically need " \
+                          "a migration command (e.g. 'bundle exec rails db:migrate')"
+            else
+              say_check(true, "hooks.on_deploy: #{on_deploy}")
+            end
+          end
+        end
+
+        [ errors, warnings ]
+      end
+
+      # Runs a boolean check, prints ✔/✗ with label, yields error message block on failure.
+      def check(label, condition, &block)
+        if condition
+          say_check(true, label)
+        else
+          say_check(false, label)
+          block.call
+        end
+      end
+
+      def say_check(passed, label)
+        mark  = passed ? "✔" : "✗"
+        color = passed ? :green : :red
+        say "  #{mark} #{label}", color
+      end
+
+      def load_kyper_yml!
+        yml = Config.kyper_yml
+        unless yml
+          say "  ✗ kyper.yml not found — run `kyper init` to create one.", :red
+          exit 1
+        end
+        yml
+      end
+    end
+  end
+end

data/lib/kyper_cli/commands/versions.rb

@@ -0,0 +1,45 @@
+module KyperCli
+  module Commands
+    class Versions < Thor
+      include Helpers
+
+      desc "withdraw VERSION", "Withdraw the latest version from review (must not be published or building)"
+      def withdraw(version_string)
+        require_auth!
+        yml = load_kyper_yml!
+        slug = to_slug(yml["name"])
+
+        status_data = Client.new.app_status(slug)
+        version_data = status_data["latest_version"]
+
+        if version_data.nil? || version_data["version"] != version_string
+          say "Error: Version #{version_string} not found (only the latest version can be withdrawn).", :red
+          exit 1
+        end
+
+        if %w[published building].include?(version_data["status"])
+          say "Cannot withdraw a #{version_data["status"]} version.", :red
+          exit 1
+        end
+
+        say ""
+        say "  Withdraw #{status_data["app"]} v#{version_string}?", :yellow
+        say "  This will remove it from the review queue and cannot be undone."
+        say ""
+
+        unless TTY::Prompt.new.yes?("  Confirm withdraw?", default: false)
+          say "  Aborted.", :yellow
+          exit 0
+        end
+
+        Client.new.version_withdraw(version_data["id"])
+        say ""
+        say "  ✔ Version #{version_string} withdrawn.", :green
+        say ""
+      rescue KyperCli::Error => e
+        say "Error: #{e.message}", :red
+        exit 1
+      end
+    end
+  end
+end

data/lib/kyper_cli/config.rb

@@ -0,0 +1,32 @@
+module KyperCli
+  module Config
+    CONFIG_DIR  = File.join(Dir.home, ".kyper")
+    CONFIG_FILE = File.join(CONFIG_DIR, "config.yml")
+    KYPER_FILE  = "kyper.yml"
+
+    def self.api_host
+      ENV.fetch("KYPER_HOST", "https://kyper.shop")
+    end
+
+    def self.load
+      return {} unless File.exist?(CONFIG_FILE)
+      @config ||= YAML.safe_load(File.read(CONFIG_FILE)) || {}
+    end
+
+    def self.api_token
+      load["api_token"]
+    end
+
+    def self.save(data)
+      @config = nil
+      FileUtils.mkdir_p(CONFIG_DIR)
+      File.write(CONFIG_FILE, data.to_yaml)
+      FileUtils.chmod(0o600, CONFIG_FILE)
+    end
+
+    def self.kyper_yml
+      return nil unless File.exist?(KYPER_FILE)
+      YAML.safe_load(File.read(KYPER_FILE))
+    end
+  end
+end

data/lib/kyper_cli/version.rb

@@ -0,0 +1,3 @@
+module KyperCli
+  VERSION = "0.1.0"
+end

data/lib/kyper_cli.rb

@@ -0,0 +1,19 @@
+require "thor"
+require "faraday"
+require "yaml"
+require "json"
+
+require_relative "kyper_cli/version"
+require_relative "kyper_cli/config"
+require_relative "kyper_cli/client"
+require_relative "kyper_cli/commands/helpers"
+require_relative "kyper_cli/commands/login"
+require_relative "kyper_cli/commands/validate"
+require_relative "kyper_cli/commands/init"
+require_relative "kyper_cli/commands/push"
+require_relative "kyper_cli/commands/status"
+require_relative "kyper_cli/commands/logs"
+require_relative "kyper_cli/commands/retry_build"
+require_relative "kyper_cli/commands/env"
+require_relative "kyper_cli/commands/versions"
+require_relative "kyper_cli/cli"