kyper 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 48a5c2c1884d61917d62514a4cdedab308dce0c15cab578d5b9ca1d34d80b823
+  data.tar.gz: 1a6814b989f4237596c2848fd366b4f92d2a9c6be71e73c0b9fd9d0bb6bada11
+SHA512:
+  metadata.gz: 4fee94e7ae2d97f3376a4e58904de70c527522ce7aa147bf917f3700f23b0f35ad8f01ca9bf4ea754425f15cd2c9e670b18da846e32fd56d08c10ba770d711b9
+  data.tar.gz: 5da228cff5fc62b9ea4ace2597f650b1e757a11ffa61391ee348d1a270ba6900d5b1aea2c4578cdbb219765413e5085484a0649f6bf3d9336af0d56a95d37ecf

data/exe/kyper

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.join(__dir__, "../lib")
+require "kyper_cli"
+KyperCli::CLI.start(ARGV)

data/lib/kyper_cli/cli.rb

@@ -0,0 +1,71 @@
+module KyperCli
+  class CLI < Thor
+    include Thor::Actions
+
+    package_name "kyper"
+
+    desc "login", "Authenticate with your Kyper account"
+    def login
+      Commands::Login.new.login
+    end
+
+    desc "init", "Create a kyper.yml in the current directory"
+    def init
+      Commands::Init.new.init
+    end
+
+    desc "push", "Validate, package, and submit the current version for review"
+    def push
+      Commands::Push.new.push
+    end
+
+    desc "validate", "Validate kyper.yml without pushing"
+    def validate
+      passed = Commands::Validate.new.validate
+      exit 1 unless passed
+    end
+
+    desc "status", "Show the review status of your app"
+    def status
+      Commands::Status.new.status
+    end
+
+    desc "logs", "Show the build log for the latest version"
+    def logs
+      Commands::Logs.new.logs
+    end
+
+    desc "retry", "Retry a failed build"
+    def retry
+      Commands::RetryBuild.new.retry_build
+    end
+
+    desc "whoami", "Show the currently authenticated user"
+    def whoami
+      token = Config.api_token
+      unless token
+        say "Not logged in. Run `kyper login`.", :red
+        exit 1
+      end
+      user = Client.new.me
+      say "#{user["email"]} (#{user["role"]})"
+    rescue KyperCli::Error => e
+      say "Error: #{e.message}", :red
+      exit 1
+    end
+
+    desc "env SUBCOMMAND", "Manage environment variables declared by your app"
+    subcommand "env", Commands::Env
+
+    desc "versions SUBCOMMAND", "Manage app versions"
+    subcommand "versions", Commands::Versions
+
+    map %w[--version -v] => :version
+    desc "version", "Print the kyper CLI version"
+    def version
+      say KyperCli::VERSION
+    end
+
+    def self.exit_on_failure? = true
+  end
+end

data/lib/kyper_cli/client.rb

@@ -0,0 +1,139 @@
+require "faraday/multipart"
+
+module KyperCli
+  class Client
+    def self.new_unauthenticated
+      new(nil)
+    end
+
+    def initialize(token = Config.api_token)
+      @token = token
+    end
+
+    def me
+      get("/api/v1/me")
+    end
+
+    def create_app(params)
+      post("/api/v1/apps", app: params)
+    end
+
+    def push_version(slug, kyper_yml_content, zip_path: nil)
+      if zip_path
+        response = multipart_connection.post("/api/v1/apps/#{slug}/versions") do |req|
+          req.headers["Authorization"] = "Bearer #{@token}"
+          req.body = {
+            source_zip: Faraday::Multipart::FilePart.new(zip_path, "application/zip"),
+            kyper_yml:  kyper_yml_content
+          }
+        end
+        handle(response)
+      else
+        post("/api/v1/apps/#{slug}/versions", { kyper_yml: kyper_yml_content })
+      end
+    end
+
+    def app_status(slug)
+      get("/api/v1/apps/#{slug}/status")
+    end
+
+    def app_env(slug)
+      get("/api/v1/apps/#{slug}/env")
+    end
+
+    # cursor: byte offset of last-seen log content (0 = from start)
+    def version_build_log(version_id, cursor: 0)
+      get("/api/v1/versions/#{version_id}/build_log?cursor=#{cursor}")
+    end
+
+    def version_retry(version_id)
+      post("/api/v1/versions/#{version_id}/retry")
+    end
+
+    def version_withdraw(version_id)
+      delete("/api/v1/versions/#{version_id}")
+    end
+
+    # Device auth — unauthenticated calls used by `kyper login`
+    def request_device_code
+      post_unauthenticated("/api/v1/device/authorize")
+    end
+
+    def poll_device_token(code)
+      get_unauthenticated("/api/v1/device/token?code=#{code}")
+    end
+
+    private
+
+    def get(path)
+      response = connection.get(path)
+      handle(response)
+    rescue Faraday::Error => e
+      raise KyperCli::Error, "Cannot reach Kyper — check your connection (#{e.message})"
+    end
+
+    def post(path, body = {})
+      response = connection.post(path) do |req|
+        req.headers["Content-Type"] = "application/json"
+        req.body = body.to_json
+      end
+      handle(response)
+    rescue Faraday::Error => e
+      raise KyperCli::Error, "Cannot reach Kyper — check your connection (#{e.message})"
+    end
+
+    def delete(path)
+      response = connection.delete(path)
+      handle(response)
+    rescue Faraday::Error => e
+      raise KyperCli::Error, "Cannot reach Kyper — check your connection (#{e.message})"
+    end
+
+    def get_unauthenticated(path)
+      response = unauthenticated_connection.get(path)
+      handle(response)
+    end
+
+    def post_unauthenticated(path, body = {})
+      response = unauthenticated_connection.post(path) do |req|
+        req.headers["Content-Type"] = "application/json"
+        req.body = body.to_json
+      end
+      handle(response)
+    end
+
+    def handle(response)
+      body = JSON.parse(response.body) rescue response.body
+      raise Error, body["error"] || body.to_s if response.status >= 400
+      body
+    end
+
+    def connection
+      @connection ||= Faraday.new(url: Config.api_host) do |f|
+        f.headers["Authorization"] = "Bearer #{@token}" if @token
+        f.headers["Accept"] = "application/json"
+        f.request :url_encoded
+        f.adapter Faraday.default_adapter
+      end
+    end
+
+    def multipart_connection
+      @multipart_connection ||= Faraday.new(url: Config.api_host) do |f|
+        f.headers["Authorization"] = "Bearer #{@token}" if @token
+        f.headers["Accept"] = "application/json"
+        f.request :multipart
+        f.adapter Faraday.default_adapter
+      end
+    end
+
+    def unauthenticated_connection
+      @unauthenticated_connection ||= Faraday.new(url: Config.api_host) do |f|
+        f.headers["Accept"] = "application/json"
+        f.request :url_encoded
+        f.adapter Faraday.default_adapter
+      end
+    end
+  end
+
+  Error = Class.new(StandardError)
+end

data/lib/kyper_cli/commands/env.rb

@@ -0,0 +1,38 @@
+module KyperCli
+  module Commands
+    class Env < Thor
+      include Helpers
+
+      desc "list", "List environment variables declared by your app"
+      def list
+        # Try local kyper.yml first (works offline)
+        yml = Config.kyper_yml
+        env_keys = yml&.dig("env")
+
+        if env_keys.nil? && !Config.api_token.to_s.empty?
+          # Fall back to API if kyper.yml has no env section but we're logged in
+          slug = to_slug(yml["name"]) if yml
+          env_keys = Client.new.app_env(slug)["env"] if slug
+        end
+
+        env_keys = Array(env_keys)
+
+        say ""
+        if env_keys.empty?
+          say "  No environment variables declared.", :yellow
+          say "  Add an \"env:\" section to kyper.yml to declare required env vars."
+        else
+          say "  Environment variables:"
+          say ""
+          env_keys.each { |key| say "    #{key}" }
+          say ""
+          say "  Consumers set these values when configuring their deployment.", :cyan
+        end
+        say ""
+      rescue KyperCli::Error => e
+        say "Error: #{e.message}", :red
+        exit 1
+      end
+    end
+  end
+end

data/lib/kyper_cli/commands/helpers.rb

@@ -0,0 +1,22 @@
+module KyperCli
+  module Commands
+    module Helpers
+      def require_auth!
+        return if !Config.api_token.to_s.empty?
+        say "Error: Not logged in. Run `kyper login` first.", :red
+        exit 1
+      end
+
+      def load_kyper_yml!
+        yml = Config.kyper_yml
+        return yml if yml
+        say "Error: No kyper.yml found. Run `kyper init` to create one.", :red
+        exit 1
+      end
+
+      def to_slug(name)
+        name.to_s.downcase.gsub(/[^a-z0-9]+/, "-").gsub(/\A-|-\z/, "")
+      end
+    end
+  end
+end

data/lib/kyper_cli/commands/init.rb

@@ -0,0 +1,317 @@
+require "yaml"
+require "json"
+require "tty-prompt"
+
+module KyperCli
+  module Commands
+    class Init < Thor
+      KNOWN_DEPS = %w[postgres mysql redis elasticsearch opensearch].freeze
+      DB_DEPS    = %w[postgres mysql].freeze
+
+      STACK_DEPLOY_HOOKS = {
+        rails:  "bundle exec rails db:migrate",
+        django: "python manage.py migrate",
+        prisma: "npx prisma migrate deploy"
+      }.freeze
+
+      IMAGE_TO_DEP = {
+        "postgres"      => "postgres",
+        "mysql"         => "mysql",
+        "redis"         => "redis",
+        "elasticsearch" => "elasticsearch",
+        "opensearch"    => "opensearch"
+      }.freeze
+
+      CATEGORIES = {
+        "developer_tools"      => "Developer Tools",
+        "productivity"         => "Productivity",
+        "finance"              => "Finance",
+        "health"               => "Health",
+        "media"                => "Media",
+        "education"            => "Education",
+        "business_operations"  => "Business Operations",
+        "data_analytics"       => "Data & Analytics",
+        "gaming"               => "Gaming"
+      }.freeze
+
+      TEMPLATE = <<~YAML
+        name: "%<name>s"
+        version: "0.1.0"
+        category: %<category>s
+        description: "A short description of your app"
+
+        docker:
+          dockerfile: "./Dockerfile"   # Kyper builds from source — no registry account needed
+
+        # Define your process types. "web" is required and must bind to $PORT.
+        processes:
+        %<processes>s
+        # Managed backing services. Allowed values: #{KNOWN_DEPS.join(", ")}
+        deps:%<deps>s
+        %<hooks>s%<healthcheck>s%<pricing>s
+        resources:
+          min_memory_mb: 512
+          min_cpu: 1
+      YAML
+
+      desc "init", "Create a kyper.yml in the current directory"
+      def init
+        if File.exist?(Config::KYPER_FILE)
+          say "  kyper.yml already exists. Edit it directly.", :yellow
+          exit 0
+        end
+
+        prompt = TTY::Prompt.new(interrupt: :exit)
+
+        say ""
+        say "  Kyper — New App Setup"
+        say "  " + ("─" * 30)
+        say ""
+
+        # App name
+        default_name = File.basename(Dir.pwd)
+        name = prompt.ask("  App name:", default: default_name) { |q| q.required(true) }.strip
+
+        # Category (arrow-key selection)
+        category = prompt.select("  Category:", CATEGORIES.invert, per_page: CATEGORIES.size, cycle: true)
+
+        # Detect processes from Procfile
+        processes = detect_processes
+        if processes.any? && processes != { "web" => "bundle exec puma -C config/puma.rb" }
+          say ""
+          say "  Auto-detected from Procfile:", :cyan
+          processes.each { |k, v| say "    ✔ #{k}: #{v}", :cyan }
+          keep = prompt.yes?("  Use these processes?", default: true)
+          processes = { "web" => "bundle exec puma -C config/puma.rb" } unless keep
+        end
+
+        # Detect deps from docker-compose
+        deps = detect_deps
+        if deps.any?
+          say ""
+          say "  Auto-detected from docker-compose:", :cyan
+          deps.each { |d| say "    ✔ #{d}", :cyan }
+          keep = prompt.yes?("  Include these dependencies?", default: true)
+          deps = [] unless keep
+        end
+
+        # Suggest dep versions from lockfiles
+        dep_versions = suggest_dep_versions(deps)
+        if dep_versions.any?
+          say ""
+          say "  Suggested dep versions (from project lockfiles):", :cyan
+          dep_versions.each { |dep, ver| say "    ✔ #{dep}: \"#{ver}\"", :cyan }
+        end
+
+        # Deploy hooks (only prompted when a DB dep is present)
+        hooks_block = prompt_hooks(prompt, deps)
+
+        # Health check path
+        healthcheck_block = prompt_healthcheck(prompt)
+
+        # Pricing
+        say ""
+        one_time_raw = prompt.ask("  One-time price in USD (leave blank to skip):") do |q|
+          q.convert(:float?) { |v| v.to_s.strip.empty? ? nil : v.to_f }
+        end
+        sub_raw = prompt.ask("  Monthly subscription price in USD (leave blank to skip):") do |q|
+          q.convert(:float?) { |v| v.to_s.strip.empty? ? nil : v.to_f }
+        end
+
+        pricing_lines = build_pricing_block(one_time_raw, sub_raw)
+
+        content = format(TEMPLATE,
+          name:        name,
+          category:    category,
+          processes:   format_processes(processes),
+          deps:        format_deps(deps, dep_versions),
+          hooks:       hooks_block,
+          healthcheck: healthcheck_block,
+          pricing:     pricing_lines)
+
+        # Preview before writing
+        say ""
+        say "  Generated kyper.yml preview:", :cyan
+        say "  " + ("─" * 40)
+        content.each_line { |line| say "  #{line}" }
+        say "  " + ("─" * 40)
+        say ""
+
+        write = prompt.yes?("  Write kyper.yml?", default: true)
+        unless write
+          say "  Aborted — nothing written.", :yellow
+          say ""
+          exit 0
+        end
+
+        File.write(Config::KYPER_FILE, content)
+
+        say ""
+        say "  ✔ kyper.yml created!", :green
+        say ""
+        say "  Next steps:", :cyan
+        say "    1. Add a Dockerfile if you don't have one"
+        say "    2. Run `kyper validate` to check your config"
+        say "    3. Run `kyper push` to submit for review"
+        say ""
+      rescue TTY::Reader::InputInterrupt
+        say ""
+        say "  Aborted.", :yellow
+        say ""
+        exit 0
+      end
+
+      private
+
+      def build_pricing_block(one_time, subscription)
+        return "pricing:\n  one_time: 49.00         # USD — omit to disable\n  # subscription: 12.00  # USD/month — omit to disable\n" if one_time.nil? && subscription.nil?
+
+        lines = [ "pricing:" ]
+        lines << "  one_time: #{one_time}"         if one_time
+        lines << "  subscription: #{subscription}" if subscription
+        lines.join("\n") + "\n"
+      end
+
+      def detect_processes
+        return { "web" => "bundle exec puma -C config/puma.rb" } unless File.exist?("Procfile")
+
+        processes = {}
+        File.each_line("Procfile") do |line|
+          line.chomp!
+          next if line.strip.empty? || line.start_with?("#")
+
+          name, _, command = line.partition(":")
+          name    = name.strip
+          command = command.strip
+          processes[name] = command if !name.empty? && !command.empty?
+        end
+
+        processes["web"] ||= "bundle exec puma -C config/puma.rb"
+        processes
+      end
+
+      def detect_deps
+        compose_file = %w[docker-compose.yml docker-compose.yaml compose.yml compose.yaml].find { |f| File.exist?(f) }
+        return [] unless compose_file
+
+        compose  = YAML.safe_load(File.read(compose_file), permitted_classes: []) || {}
+        services = compose["services"] || {}
+
+        detected = []
+        services.each_value do |svc|
+          next unless svc.is_a?(Hash)
+
+          image = svc["image"].to_s.downcase
+          IMAGE_TO_DEP.each do |fragment, dep|
+            detected << dep if image.include?(fragment) && !detected.include?(dep)
+          end
+        end
+        detected
+      end
+
+      def format_processes(processes)
+        processes.map { |name, cmd| "  #{name}: \"#{cmd}\"" }.join("\n")
+      end
+
+      def format_deps(deps, versions = {})
+        return "\n  # - postgres\n  # - redis" if deps.empty?
+
+        "\n" + deps.map { |d|
+          ver = versions[d]
+          ver ? "  - #{d}: \"#{ver}\"" : "  - #{d}"
+        }.join("\n")
+      end
+
+      # Suggests dep major version pins based on detected project lockfiles.
+      # Returns a hash of {dep_name => version_string} for deps with clear signals.
+      def suggest_dep_versions(deps)
+        versions = {}
+        has_gemfile_lock = File.exist?("Gemfile.lock")
+
+        deps.each do |dep|
+          case dep
+          when "postgres"
+            # Rails (Gemfile.lock) and Node+Prisma apps default to Postgres 16
+            versions["postgres"] = "16" if has_gemfile_lock || prisma_project?
+          when "mysql"
+            versions["mysql"] = "8"
+          end
+        end
+
+        versions
+      end
+
+      # Prompts for a deploy hook command when the app has a database dep.
+      # Returns a formatted YAML block string (empty string if no hook configured).
+      def prompt_hooks(prompt, deps)
+        return "" unless (deps & DB_DEPS).any?
+
+        say ""
+        needs_hook = prompt.yes?(
+          "  Does your app need a deploy command (e.g. database migrations)?",
+          default: true
+        )
+        return "" unless needs_hook
+
+        stack    = detect_stack
+        suggest  = STACK_DEPLOY_HOOKS[stack]
+
+        command = if suggest
+          say "  Auto-detected: #{suggest}", :cyan
+          use_it = prompt.yes?("  Use this deploy command?", default: true)
+          use_it ? suggest : prompt.ask("  Deploy command:", required: true)&.strip
+        else
+          prompt.ask("  Deploy command (e.g. bundle exec rails db:migrate):", required: true)&.strip
+        end
+
+        return "" if command.to_s.empty?
+
+        "hooks:\n  on_deploy: \"#{command}\"\n  on_update: \"#{command}\"\n\n"
+      end
+
+      # Detects the likely application stack from files in the working directory.
+      # Prompts for a health check path. Returns an empty string when the developer
+      # accepts the default (/up) to keep the YAML minimal.
+      def prompt_healthcheck(prompt)
+        suggested = stack_health_path
+        say ""
+        path = prompt.ask(
+          "  Health check path:",
+          default: suggested
+        ) { |q| q.required(true) }.strip
+
+        return "" if path == "/up"
+
+        "healthcheck:\n  path: \"#{path}\"\n\n"
+      end
+
+      # Returns the conventional health path for the detected stack.
+      def stack_health_path
+        stack = detect_stack
+        case stack
+        when :django then "/health/"
+        when :rails  then "/up"
+        else
+          # Node/Express/Fastify and unknown stacks default to /health
+          File.exist?("package.json") ? "/health" : "/up"
+        end
+      end
+
+      def detect_stack
+        return :prisma if prisma_project?
+        return :django if File.exist?("manage.py")
+        return :rails  if File.exist?("Gemfile")
+
+        nil
+      end
+
+      def prisma_project?
+        return false unless File.exist?("package.json")
+
+        json = JSON.parse(File.read("package.json")) rescue {}
+        !json.dig("dependencies", "@prisma/client").nil? ||
+          !json.dig("devDependencies", "prisma").nil?
+      end
+    end
+  end
+end

data/lib/kyper_cli/commands/login.rb

@@ -0,0 +1,83 @@
+module KyperCli
+  module Commands
+    class Login < Thor
+      desc "login", "Authenticate with your Kyper account via browser"
+      def login
+        client = Client.new_unauthenticated
+
+        spinner = TTY::Spinner.new("[:spinner] Requesting authorization code…", format: :dots)
+        spinner.auto_spin
+
+        grant = client.request_device_code
+        code  = grant["code"]
+        uri   = grant["verification_uri"]
+
+        spinner.success("Done")
+
+        say ""
+        say "Open this URL in your browser to authorize the CLI:", :cyan
+        say "  #{uri}", :bold
+        say ""
+
+        open_browser(uri)
+
+        say "Waiting for authorization", :cyan
+        poll_spinner = TTY::Spinner.new("[:spinner] Polling…", format: :dots)
+        poll_spinner.auto_spin
+
+        deadline = Time.now + 300 # 5 minutes
+        token = nil
+
+        loop do
+          if Time.now > deadline
+            poll_spinner.error("Timed out")
+            say "Authorization timed out. Please run `kyper login` again.", :red
+            exit 1
+          end
+
+          begin
+            result = client.poll_device_token(code)
+            if result["api_token"]
+              token = result["api_token"]
+              break
+            end
+          rescue KyperCli::Error => e
+            if e.message.include?("not found") || e.message.include?("expired")
+              poll_spinner.error("Grant expired")
+              say "Authorization expired. Please run `kyper login` again.", :red
+              exit 1
+            end
+            # Other errors — keep polling
+          end
+
+          sleep 2
+        end
+
+        poll_spinner.success("Authorized")
+
+        Config.save("api_token" => token)
+
+        # Verify the token works
+        user = Client.new(token).me
+        say "Logged in as #{user["email"]} (#{user["role"]})", :green
+      rescue KyperCli::Error => e
+        say "Error: #{e.message}", :red
+        exit 1
+      end
+
+      private
+
+      no_commands do
+        def open_browser(uri)
+          if RUBY_PLATFORM =~ /darwin/
+            system("open", uri)
+          elsif RUBY_PLATFORM =~ /linux/
+            system("xdg-open", uri)
+          end
+        rescue StandardError
+          # Silently fail — user can copy-paste the URL
+        end
+      end
+    end
+  end
+end