deploio-cli 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4464fa0c5bfb5ca034fc5b7936d2b3d856224068fb984bea2bf03018b1e33841
+  data.tar.gz: 8b9a0dc13c1262ebc81b8bee5e4aac9d9d47e70fb2850a6259ded636a40ea3af
+SHA512:
+  metadata.gz: 61678961554d647509a198b88510862d178774814e2fe094aa42e891ed655f079a8216b9663addd75da1861a2d24d7d9c0419ec6abb50bed139cdbab1176dec3
+  data.tar.gz: 9fcedee868c9a4621b4e0441618267074dc6963cb7ff0f8e7d00565b9f2e4f01c8f926e38e1d8ec5029c4775f975cd687e40b13f7b6e35141c2c20d814841d18

data/.ruby-version

@@ -0,0 +1 @@
+3.4.8

data/README.md

@@ -0,0 +1,173 @@
+# deploio-cli (deploio / depl)
+
+A CLI for [Deploio](https://www.deplo.io/) that wraps [`nctl`](https://github.com/ninech/nctl) commands with a simpler interface.
+
+## Requirements
+
+- Ruby 3.3+
+- nctl version 1.10.0 or higher
+
+## Installation
+
+### From source (development)
+
+```bash
+git clone https://github.com/renuo/deploio-cli.git
+cd deploio-cli
+bundle install
+bundle exec bin/deploio --help
+```
+
+### As a gem (coming soon)
+
+```bash
+gem install deploio-cli
+```
+
+## Shell Completion
+
+Enable autocompletion by adding this to your `~/.zshrc` or `~/.bashrc`, or whatever you use:
+
+```bash
+eval "$(deploio completion)"
+```
+
+After setup, completions work for:
+- Commands: `deploio <TAB>` → shows all commands and subcommands
+- Options: `deploio logs --<TAB>` → shows --tail, --lines, --app, etc.
+- Apps (dynamic): `deploio logs --app <TAB>` → fetches available apps from server
+
+## Configuration
+
+### App naming convention
+
+Apps are referenced using `<project>-<app>` format, where:
+- `project` is your Deploio project name (e.g., `deploio-landing-page`)
+- `app` is the environment/app name (e.g., `develop`, `production`)
+
+Example: `deploio-landing-page-develop`
+
+### Automatic app detection
+
+When you run a command without `--app`, the CLI will automatically detect the app by matching your git remote URL against nctl apps:
+
+```bash
+cd ~/projects/deploio-landing-page
+deploio logs --tail  # Automatically detects app from git remote
+```
+
+If multiple apps match (e.g., develop and production), you'll be prompted to select one.
+
+## Usage
+
+```
+deploio - CLI for Deploio (wraps nctl)
+
+AUTHENTICATION
+  deploio auth:login              Authenticate with nctl
+  deploio auth:logout             Log out
+  deploio auth:whoami             Show current user and organization
+  deploio login                   Shortcut for auth:login
+
+APPS
+  deploio apps                    List all apps
+  deploio apps:info -a APP        Show app details
+
+LOGS
+  deploio logs -a APP             Show recent logs
+  deploio logs -a APP --tail      Stream logs continuously
+  deploio logs -a APP -n 200      Show last N lines
+
+EXECUTION
+  deploio exec -a APP -- CMD      Run command in app container
+  deploio run -a APP -- CMD       Alias for exec
+
+OTHER
+  deploio completion              Generate shell completion script
+  deploio version                 Show version
+
+FLAGS
+  -a, --app APP                   App in <project>-<app> format
+  -o, --org ORG                   Organization
+  --dry-run                       Print commands without executing
+  --no-color                      Disable colored output
+```
+
+## Examples
+
+### Authentication
+
+```bash
+# Login to nctl
+deploio login
+
+# Check current user
+deploio auth:whoami
+```
+
+### Working with apps
+
+```bash
+# List all apps
+deploio apps
+
+# Show app info
+deploio apps:info -a myproject-staging
+
+```
+
+### Logs and execution
+
+```bash
+# View logs
+deploio logs -a deploio-landing-page-develop
+
+# Stream logs
+deploio logs -a deploio-landing-page-develop --tail
+
+# Run a command
+deploio exec -a deploio-landing-page-develop -- rails console
+
+# With git remote matching (auto-detected)
+cd ~/projects/deploio-landing-page
+deploio logs --tail
+deploio exec -- rails console
+```
+
+## Development
+
+### Running tests
+
+```bash
+bundle exec rake test
+```
+
+### Building the gem
+
+```bash
+gem build deploio-cli.gemspec
+```
+
+### Testing commands
+
+The best way to test the commands in the shell is to temporarly set:
+
+```shell
+export PATH="$PWD/bin:$PATH"
+```
+
+to have the `deploio` command binded to the current one, and
+
+```shell
+eval "$(deploio completion)"
+```
+
+to refresh the autocompletion options.
+
+## License
+
+MIT
+
+## Copyright
+
+Renuo AG

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task default: :test

data/bin/deploio

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
+
+require 'deploio'
+
+$stdout.sync = true
+
+begin
+  Deploio::CLI.start(ARGV)
+rescue Deploio::Error => e
+  Deploio::Output.error(e.message)
+  exit 1
+rescue Interrupt
+  puts "\nInterrupted"
+  exit 130
+end

data/deploio-cli.gemspec

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "lib/deploio/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "deploio-cli"
+  spec.version = Deploio::VERSION
+  spec.authors = ["Renuo AG"]
+  spec.email = ["info@renuo.ch"]
+
+  spec.summary = "CLI for Deploio"
+  spec.description = "A Ruby CLI that provides an interface for managing Deploio applications."
+  spec.homepage = "https://github.com/renuo/deploio-cli"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .github appveyor Gemfile])
+    end
+  end
+  spec.bindir = "bin"
+  spec.executables = ["deploio"]
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "thor", "~> 1.3"
+  spec.add_dependency "tty-table", "~> 0.12"
+end

data/lib/deploio/app_ref.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "did_you_mean"
+
+# AppRef represents a reference to a deploio application.
+module Deploio
+  class AppRef
+    attr_reader :project_name, :app_name
+
+    # The input is given in the format "<project>-<app>"
+    def initialize(input, available_apps: {})
+      @input = input.to_s
+      parse_from_available_apps(available_apps)
+    end
+
+    def full_name
+      "#{project_name}-#{app_name}"
+    end
+
+    def to_s
+      full_name
+    end
+
+    def ==(other)
+      return false unless other.is_a?(AppRef)
+
+      project_name == other.project_name && app_name == other.app_name
+    end
+
+    private
+
+    def parse_from_available_apps(available_apps)
+      if available_apps.key?(@input)
+        match = available_apps[@input]
+        @project_name = match[:project_name]
+        @app_name = match[:app_name]
+        return
+      end
+
+      # If available_apps provided but no match, raise error with suggestions
+      raise_not_found_error(@input, available_apps.keys) unless available_apps.empty?
+
+      raise_not_found_error(@input, [])
+    end
+
+    def raise_not_found_error(input, available_app_names)
+      message = "App not found: '#{input}'"
+
+      suggestions = suggest_similar(input, available_app_names)
+      unless suggestions.empty?
+        message += "\n\nDid you mean?"
+        suggestions.each { |s| message += "\n  #{s}" }
+      end
+
+      message += "\n\nRun 'deploio apps' to see available apps."
+
+      raise Deploio::AppNotFoundError, message
+    end
+
+    def suggest_similar(input, dictionary)
+      return [] if dictionary.empty?
+
+      spell_checker = DidYouMean::SpellChecker.new(dictionary: dictionary)
+      spell_checker.correct(input)
+    end
+  end
+end

data/lib/deploio/app_resolver.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Deploio
+  class AppResolver
+    attr_reader :nctl, :git_remote_url, :current_org
+
+    def initialize(nctl_client:)
+      @nctl = nctl_client
+      @git_remote_url = Utils.detect_git_remote
+      @current_org = @nctl.current_org
+    end
+
+    def resolve(app_name: nil)
+      # 1. Explicit --app flag
+      if app_name
+        return AppRef.new(app_name, available_apps: available_apps_hash)
+      end
+
+      # 2. Match git remote against nctl apps
+      if git_remote_url
+        matches = find_apps_by_git_remote(git_remote_url)
+
+        case matches.size
+        when 0
+          raise Deploio::AppNotFoundError,
+            "No deploio apps found matching git remote: #{git_remote_url}\n" \
+            "Use --app to specify the app explicitly.\n" \
+            "Run 'deploio apps' to see available apps."
+        when 1
+          return build_app_ref_from_match(matches.first)
+        else
+          app_names = matches.map { |m| format_match(m) }
+          raise Deploio::Error,
+            "Multiple apps found for this repo. Use --app to specify which one:\n" \
+            "#{app_names.map { |name| "  #{name}" }.join("\n")}"
+        end
+      end
+
+      raise Deploio::Error,
+        "No app specified. Use --app <project-app> or run from a git repo with a matching remote."
+    end
+
+    # Returns hash mapping app names -> {project_name:, app_name:}
+    # Supports both full names (org-project-app) and short names (project-app)
+    def available_apps_hash
+      @available_apps_hash ||= begin
+        hash = {}
+        current_org = @nctl.current_org
+        @nctl.get_all_apps.each do |app|
+          metadata = app["metadata"] || {}
+          project_name = metadata["namespace"] || ""
+          app_name = metadata["name"]
+          full_name = "#{project_name}-#{app_name}"
+          hash[full_name] = {project_name: project_name, app_name: app_name}
+
+          # Also index by short name (without org prefix) for convenience
+          if current_org && project_name.start_with?("#{current_org}-")
+            project = project_name.delete_prefix("#{current_org}-")
+            short_name = "#{project}-#{app_name}"
+            hash[short_name] ||= {project_name: project_name, app_name: app_name}
+          end
+        end
+        hash
+      end
+    rescue
+      {}
+    end
+
+    def short_name_for(namespace, app_name)
+      org = current_org
+      if org && namespace.start_with?("#{org}-")
+        project = namespace.delete_prefix("#{org}-")
+        "#{project}-#{app_name}"
+      else
+        "#{namespace}-#{app_name}"
+      end
+    end
+
+    private
+
+    def find_apps_by_git_remote(git_url)
+      normalized_url = normalize_git_url(git_url)
+      @nctl.get_all_apps.select do |app|
+        app_git_url = app.dig("spec", "forProvider", "git", "url")
+        normalize_git_url(app_git_url) == normalized_url
+      end
+    end
+
+    def normalize_git_url(url)
+      return nil if url.nil?
+
+      url.strip
+        .sub(/\.git$/, "")
+        .sub(%r{^https://github\.com/}, "git@github.com:")
+        .downcase
+    end
+
+    def build_app_ref_from_match(match)
+      metadata = match["metadata"] || {}
+      namespace = metadata["namespace"] || ""
+      name = metadata["name"]
+      AppRef.new("#{namespace}-#{name}", available_apps: available_apps_hash)
+    end
+
+    def format_match(match)
+      metadata = match["metadata"] || {}
+      namespace = metadata["namespace"] || ""
+      name = metadata["name"]
+      short_name_for(namespace, name)
+    end
+  end
+end

data/lib/deploio/cli.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "thor"
+require_relative "commands/auth"
+require_relative "commands/apps"
+require_relative "commands/orgs"
+require_relative "completion_generator"
+
+module Deploio
+  class CLI < Thor
+    include SharedOptions
+
+    desc "version", "Show version"
+    def version
+      puts "deploio-cli #{Deploio::VERSION}"
+    end
+    map %w[-v --version] => :version
+
+    desc "completion", "Generate shell completion script"
+    method_option :shell, aliases: "-s", type: :string, default: "zsh",
+      desc: "Shell type (zsh, bash, fish)"
+    def completion
+      case options[:shell].downcase
+      when "zsh"
+        puts CompletionGenerator.new.generate
+      when "bash", "fish"
+        Output.error("#{options[:shell]} completion is not yet supported. Only zsh is available.")
+        exit 1
+      else
+        Output.error("Unknown shell: #{options[:shell]}. Supported: zsh")
+        exit 1
+      end
+    end
+
+    desc "auth COMMAND", "Authentication commands"
+    subcommand "auth", Commands::Auth
+
+    desc "apps COMMAND", "Apps management commands"
+    subcommand "apps", Commands::Apps
+    desc "orgs COMMAND", "Organization management commands"
+    subcommand "orgs", Commands::Orgs
+
+    # Shortcut for auth:login
+    desc "login", "Authenticate with nctl (alias for auth:login)"
+    def login
+      Commands::Auth.start(["login"] + build_option_args)
+    end
+
+    # Shortcut for auth:whoami
+    desc "whoami", "Show current user (alias for auth:whoami)"
+    def whoami
+      Commands::Auth.start(["whoami"] + build_option_args)
+    end
+
+    # Shortcut for auth:logout
+    desc "logout", "Log out from nctl (alias for auth:logout)"
+    def logout
+      Commands::Auth.start(["logout"] + build_option_args)
+    end
+
+    # Logs command
+    desc "logs", "Show logs for an app"
+    method_option :tail, aliases: "-t", type: :boolean, default: false, desc: "Stream logs continuously"
+    method_option :lines, aliases: "-n", type: :numeric, default: 100, desc: "Number of lines to show"
+    def logs
+      setup_options
+      app_ref = resolve_app
+      @nctl.logs(app_ref, tail: options[:tail], lines: options[:lines])
+    end
+
+    # Exec command
+    desc "exec [-- COMMAND]", "Run command in app container"
+    def exec(*args)
+      setup_options
+      app_ref = resolve_app
+      if args.empty?
+        Output.error("No command specified. Usage: deploio exec -a APP -- COMMAND")
+        exit 1
+      end
+      @nctl.exec_command(app_ref, args)
+    end
+    map "run" => :exec
+
+    private
+
+    def build_option_args
+      args = []
+      args << "--dry-run" if options[:dry_run]
+      args << "--no-color" if options[:no_color]
+      args << "--app" << options[:app] if options[:app]
+      args << "--org" << options[:org] if options[:org]
+      args
+    end
+  end
+end

data/lib/deploio/commands/apps.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Deploio
+  module Commands
+    class Apps < Thor
+      include SharedOptions
+
+      namespace "apps"
+
+      class_option :json, type: :boolean, default: false, desc: "Output as JSON"
+
+      default_task :list
+
+      desc "list", "List all apps"
+      def list
+        setup_options
+        raw_apps = @nctl.get_all_apps
+
+        if options[:json]
+          puts JSON.pretty_generate(raw_apps)
+          return
+        end
+
+        if raw_apps.empty?
+          Output.warning("No apps found") unless merged_options[:dry_run]
+          return
+        end
+
+        resolver = AppResolver.new(nctl_client: @nctl)
+
+        rows = raw_apps.map do |app|
+          metadata = app["metadata"] || {}
+          spec = app["spec"] || {}
+          for_provider = spec["forProvider"] || {}
+          git = for_provider["git"] || {}
+          config = for_provider["config"] || {}
+          namespace = metadata["namespace"] || ""
+          name = metadata["name"] || ""
+
+          [
+            resolver.short_name_for(namespace, name),
+            project_from_namespace(namespace, resolver.current_org),
+            presence(config["size"], default: "micro"),
+            presence(git["revision"])
+          ]
+        end
+
+        Output.table(rows, headers: %w[APP PROJECT SIZE REVISION])
+      end
+
+      desc "info", "Show app details"
+      def info
+        setup_options
+        app_ref = resolve_app
+        data = @nctl.get_app(app_ref)
+
+        if options[:json]
+          puts JSON.pretty_generate(data)
+          return
+        end
+
+        display_app_info(data, app_ref)
+      end
+
+      private
+
+      def display_app_info(data, app_ref)
+        metadata = data["metadata"] || {}
+        spec = data["spec"] || {}
+        status = data["status"] || {}
+        for_provider = spec["forProvider"] || {}
+        git = for_provider["git"] || {}
+        config = for_provider["config"] || {}
+        build_env = for_provider["buildEnv"] || []
+        at_provider = status["atProvider"] || {}
+
+        Output.header("App: #{app_ref.full_name}")
+        puts
+
+        Output.header("General")
+        Output.table([
+          ["Name", presence(metadata["name"])],
+          ["Project", presence(metadata["namespace"])],
+          ["Size", presence(config["size"], default: "micro")],
+          ["Replicas", presence(for_provider["replicas"], default: "1")],
+          ["Port", presence(config["port"], default: "8080")]
+        ])
+
+        puts
+
+        Output.header("Status")
+        conditions = status["conditions"] || []
+        ready_condition = conditions.find { |c| c["type"] == "Ready" }
+        synced_condition = conditions.find { |c| c["type"] == "Synced" }
+
+        Output.table([
+          ["Ready", presence(ready_condition&.dig("status"))],
+          ["Synced", presence(synced_condition&.dig("status"))],
+          ["Default URL", presence(at_provider["defaultURL"])],
+          ["Latest Build", presence(at_provider["latestBuild"])],
+          ["Latest Release", presence(at_provider["latestRelease"])]
+        ])
+
+        puts
+
+        hosts = for_provider["hosts"] || []
+        if hosts.any?
+          Output.header("Hosts")
+          Output.table(hosts.map { |h| [presence(h)] })
+          puts
+        end
+
+        Output.header("Git")
+        Output.table([
+          ["Repository", presence(git["url"])],
+          ["Revision", presence(git["revision"])],
+          ["Sub Path", presence(git["subPath"])]
+        ])
+        puts
+
+        if build_env.any? || for_provider["dockerfilePath"]
+          Output.header("Build")
+          rows = []
+          rows << ["Dockerfile", presence(for_provider["dockerfilePath"])] if for_provider["dockerfilePath"]
+          build_env.each do |env|
+            rows << [env["name"], presence(env["value"], max_length: 60)]
+          end
+          Output.table(rows, headers: %w[SETTING VALUE]) if rows.any?
+          puts
+        end
+      end
+
+      def presence(value, default: "-", max_length: nil)
+        return default if value.nil? || value.to_s.empty?
+
+        str = value.to_s
+        (max_length && str.length > max_length) ? "#{str[0, max_length - 3]}..." : str
+      end
+
+      def project_from_namespace(namespace, current_org)
+        if current_org && namespace.start_with?("#{current_org}-")
+          namespace.delete_prefix("#{current_org}-")
+        else
+          namespace
+        end
+      end
+    end
+  end
+end

data/lib/deploio/commands/auth.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Deploio
+  module Commands
+    class Auth < Thor
+      include SharedOptions
+
+      namespace "auth"
+
+      desc "login", "Authenticate with nctl"
+      def login
+        setup_options
+        @nctl.auth_login
+      end
+
+      desc "logout", "Log out from nctl"
+      def logout
+        setup_options
+        @nctl.auth_logout
+        Output.success("Logged out successfully")
+      end
+
+      desc "whoami", "Show current user and organization"
+      def whoami
+        setup_options
+        @nctl.auth_whoami
+      end
+    end
+  end
+end