gdkbox 0.1.0

data/lib/gdkbox/cli.rb

@@ -0,0 +1,410 @@
+# frozen_string_literal: true
+
+require "json"
+require "thor"
+require "gdkbox"
+
+module GDKBox
+  # The `gdkbox` command-line interface.
+  class CLI < Thor
+    def self.exit_on_failure?
+      true
+    end
+
+    class_option :verbose, type: :boolean, default: false,
+      desc: "Print extra diagnostic output"
+
+    desc "up NAME", "Spin up a new GDK box and wire it for SSH + VS Code"
+    long_desc <<~DESC
+      Pulls the official GDK-in-a-box image, starts a container named after
+      NAME, enables SSH access using a dedicated gdkbox key, installs the
+      chosen agent harness (--harness, default claude) inside the box, and
+      registers a `Host gdkbox-NAME` entry so VS Code Remote-SSH can connect.
+    DESC
+    option :image, type: :string, desc: "Override the GDK image to use"
+    option :ssh_port, type: :numeric, desc: "Host port to publish SSH on"
+    option :web_port, type: :numeric, desc: "Host port to publish the GDK web UI on"
+    option :harness, type: :string,
+      desc: "Agent harness to install (see `gdkbox harnesses`; default from config.yml or claude)"
+    option :agent, type: :boolean, default: true,
+      desc: "Install the agent harness inside the box"
+    option :json, type: :boolean, default: false,
+      desc: "Print the box descriptor as JSON (for orchestrators)"
+    option :api_key, type: :string,
+      desc: "Seed the harness API key for unattended dispatch (defaults to the provider env var)"
+    option :anthropic_api_key, type: :string, desc: "Alias of --api-key (kept for compatibility)"
+    option :skill, type: :array, default: [],
+      desc: "Skill name(s) or path(s) to install into the box for dispatched agents"
+    option :default_skills, type: :boolean, default: true,
+      desc: "Also install the default skills from ~/.gdkbox/config.yml"
+    def up(name)
+      ensure_docker!
+      box = build_box(name)
+      raise Error, "Box '#{name}' already exists. Use `gdkbox rm #{name}` first." if box.exists?
+      harness = Harness[options[:harness] || config.default_harness]
+      api_key = resolve_api_key(harness)
+
+      say "Spinning up GDK box '#{name}' (#{harness.summary}; first run pulls a large image)...", :green unless options[:json]
+      box.create!(
+        image: options[:image],
+        ssh_port: options[:ssh_port],
+        web_port: options[:web_port],
+        harness: harness.id,
+        install_agent: options[:agent],
+        api_key: api_key
+      )
+      rewrite_ssh_config
+      seed_skills(box)
+
+      if options[:json]
+        puts JSON.generate(box.summary)
+        return
+      end
+
+      say "\nBox '#{name}' is up.", :green
+      print_connection_details(box)
+      unless api_key
+        say "\n  No #{harness.key_env} seeded. Before unattended dispatch, run:", :yellow
+        say "    gdkbox set-key #{name}   (uses $#{harness.key_env})", :yellow
+      end
+    end
+
+    desc "ls", "List all GDK boxes and their status"
+    option :json, type: :boolean, default: false,
+      desc: "Print the fleet as a JSON array (for orchestrators)"
+    def ls
+      boxes = Box.all(config: config).sort_by(&:name)
+      docker = Docker.new
+
+      if options[:json]
+        summaries = boxes.map { |box| box.summary(state: docker.available? ? nil : "unknown") }
+        puts JSON.generate(summaries)
+        return
+      end
+
+      if boxes.empty?
+        say "No GDK boxes yet. Create one with `gdkbox up <name>`."
+        return
+      end
+
+      boxes.each do |box|
+        status = docker.available? ? box.state : "unknown"
+        say format("%-20s %-10s ssh:%-6s web:%-6s %s",
+          box.name, status, box.ssh_port, box.web_port, box.web_url)
+      end
+    end
+
+    desc "status NAME", "Show detailed status and connection info for a box"
+    option :json, type: :boolean, default: false, desc: "Print the box descriptor as JSON"
+    def status(name)
+      box = load_box!(name)
+      docker = Docker.new
+
+      if options[:json]
+        puts JSON.generate(box.summary(state: docker.available? ? nil : "unknown"))
+        return
+      end
+
+      say "Box:        #{box.name}"
+      say "Container:  #{box.container_name}"
+      say "State:      #{docker.available? ? box.state : 'unknown'}"
+      print_connection_details(box)
+    end
+
+    desc "dispatch NAME", "Dispatch an agent task headlessly into the box"
+    long_desc <<~DESC
+      Runs the box's agent harness non-interactively inside the GDK checkout
+      and streams the agent's output. This is the primitive an orchestrator
+      uses to hand a task to a box in the pool. Provide the task with --task or
+      --task-file. Exit status mirrors the agent's.
+    DESC
+    option :task, type: :string, desc: "The task/prompt to give the agent"
+    option :task_file, type: :string, desc: "Read the task from a local file"
+    option :json, type: :boolean, default: false,
+      desc: "Return the agent's structured JSON output"
+    option :timeout, type: :numeric, desc: "Abort the agent after N seconds"
+    option :yolo, type: :boolean, default: true,
+      desc: "Skip permission prompts (safe in an isolated box)"
+    def dispatch(name)
+      box = load_box!(name)
+      task = options[:task]
+      task = File.read(options[:task_file]) if options[:task_file]
+      raise Error, "Provide a task with --task or --task-file." if task.nil? || task.strip.empty?
+
+      result = box.run_agent(
+        task: task,
+        json: options[:json],
+        yolo: options[:yolo],
+        timeout: options[:timeout]
+      )
+      $stdout.print(result.stdout)
+      $stderr.print(result.stderr) unless result.stderr.to_s.empty?
+      exit(result.status)
+    end
+
+    desc "ssh NAME", "Open an interactive SSH session into the box"
+    def ssh(name)
+      box = load_box!(name)
+      exec(*box.ssh_command)
+    end
+
+    desc "code NAME", "Open the box in VS Code via Remote-SSH"
+    def code(name)
+      box = load_box!(name)
+      rewrite_ssh_config
+      vscode = VSCode.new
+      unless vscode.available?
+        say "The `code` CLI was not found on PATH.", :yellow
+        say "Open VS Code manually and connect to host: #{box.ssh_host_alias}"
+        say "Or run: #{vscode.open_command(box).join(' ')}"
+        return
+      end
+      say "Opening #{box.name} in VS Code (#{box.ssh_host_alias})...", :green
+      vscode.open(box)
+    end
+
+    desc "install-agent NAME", "(Re)install the box's agent harness inside it"
+    def install_agent(name)
+      box = load_box!(name)
+      say "Installing #{box.harness.summary} in '#{name}'...", :green
+      box.install_agent!
+      say "Done. SSH in and run `#{box.harness.bin}` to start an agent.", :green
+    end
+    map "install-agent" => :install_agent
+
+    desc "harnesses", "List the agent harnesses gdkbox can install"
+    def harnesses
+      Harness.all.each do |h|
+        say format("%-10s ", h.id), :green, false
+        say "#{h.summary} (key: $#{h.key_env})"
+      end
+    end
+
+    desc "set-key NAME", "Seed or rotate the agent API key inside the box"
+    long_desc <<~DESC
+      Stores the API key for the box's harness inside the box so dispatched
+      agents can authenticate without a human. The key is exported under the
+      provider's env var (e.g. ANTHROPIC_API_KEY, OPENAI_API_KEY), kept only
+      inside the container (a 0600 file owned by the GDK user) and never in
+      host-side metadata. Prefer the provider env var or --api-key over a flag
+      visible in shell history.
+    DESC
+    option :api_key, type: :string, desc: "API key to seed (defaults to the provider env var)"
+    option :anthropic_api_key, type: :string, desc: "Alias of --api-key (kept for compatibility)"
+    def set_key(name)
+      box = load_box!(name)
+      api_key = resolve_api_key(box.harness)
+      unless api_key
+        raise Error, "No API key. Pass --api-key, set $#{box.harness.key_env}, " \
+          "or add `#{box.harness.config_key}:` to ~/.gdkbox/config.yml."
+      end
+
+      say "Seeding #{box.harness.key_env} into '#{name}'...", :green
+      box.set_api_key!(api_key)
+      say "Done. Unattended `gdkbox dispatch #{name}` is ready.", :green
+    end
+    map "set-key" => :set_key
+
+    desc "start NAME", "Start a stopped box (and re-enable SSH)"
+    def start(name)
+      box = load_box!(name)
+      say "Starting '#{name}'...", :green
+      box.start!
+      print_connection_details(box)
+    end
+
+    desc "stop NAME", "Stop a running box"
+    def stop(name)
+      box = load_box!(name)
+      say "Stopping '#{name}'...", :green
+      box.stop!
+    end
+
+    desc "rm NAME", "Remove a box: its container, metadata, and SSH entry"
+    option :force, type: :boolean, default: false, desc: "Skip confirmation"
+    def rm(name)
+      box = load_box!(name)
+      unless options[:force]
+        return unless yes?("Remove box '#{name}' and its container? [y/N]")
+      end
+      box.destroy!
+      rewrite_ssh_config
+      say "Removed '#{name}'.", :green
+    end
+
+    desc "install-skill [NAME]", "Install the agent skill(s) bundled in this repo into Claude Code"
+    long_desc <<~DESC
+      Copies the agent skills shipped with this repo into a Claude Code skills
+      directory so anyone who has this repo can use them. With no NAME, every
+      bundled skill is installed; pass a NAME to install just one.
+
+      Installs into ~/.claude/skills (available everywhere) by default. Pass
+      --project to install into ./.claude/skills for the current project only.
+      Use --force to overwrite a skill that is already installed.
+    DESC
+    option :project, type: :boolean, default: false,
+      desc: "Install into ./.claude/skills instead of ~/.claude/skills"
+    option :force, type: :boolean, default: false,
+      desc: "Overwrite a skill that is already installed"
+    def install_skill(name = nil)
+      available = Skills.available
+      raise Error, "This repo ships no skills." if available.empty?
+
+      if name && !available.include?(name)
+        raise Error, "No skill named '#{name}'. Available: #{available.join(', ')}."
+      end
+
+      dest = options[:project] ? Skills.project_dest : Skills::GLOBAL_DEST
+      skills = Skills.new(dest: dest)
+
+      (name ? [name] : available).each do |skill_name|
+        target = skills.install(skill_name, force: options[:force])
+        say "Installed skill '#{skill_name}' -> #{target}", :green
+      end
+      say "\nStart a new Claude Code session to pick up the skill.", :cyan
+    end
+    map "install-skill" => :install_skill
+
+    desc "skills", "List agent skills available to install (bundled, ~/.claude, ./.claude)"
+    def skills
+      found = Skills.discover
+      if found.empty?
+        say "No skills found in this repo, ~/.claude/skills, or ./.claude/skills."
+        return
+      end
+      found.each do |skill|
+        say format("%-28s ", skill.name), :green, false
+        say "[#{skill.origin}]", :cyan
+        say "  #{skill.description}" if skill.description && !skill.description.empty?
+      end
+    end
+
+    desc "add-skill BOX [SKILL...]", "Install agent skill(s) into a box for dispatched agents"
+    long_desc <<~DESC
+      Copies skills into the box's harness skills directory so agents
+      dispatched into it (`gdkbox dispatch`) can use them. Each SKILL is a
+      discovered skill name (see `gdkbox skills`) or a path to a skill
+      directory. With no SKILL given, lists the available skills and lets you
+      pick interactively. Use --force to overwrite a skill already in the box.
+    DESC
+    option :force, type: :boolean, default: false,
+      desc: "Overwrite a skill already installed in the box"
+    def add_skill(box_name, *skill_tokens)
+      box = load_box!(box_name)
+      skill_tokens = prompt_for_skills if skill_tokens.empty?
+      raise Error, "No skills selected." if skill_tokens.empty?
+
+      skill_tokens.each do |token|
+        skill = box.install_skill(token, force: options[:force])
+        say "Installed skill '#{skill.name}' into box '#{box_name}'.", :green
+      end
+      say "\nDispatched agents in '#{box_name}' can now use these skills.", :cyan
+    end
+    map "add-skill" => :add_skill
+
+    desc "completion SHELL", "Print a shell completion script (bash or zsh)"
+    long_desc <<~DESC
+      Outputs a completion script for SHELL. It completes subcommands, flags,
+      and — dynamically — live box names and skill names.
+
+      Bash:  echo 'eval "$(gdkbox completion bash)"' >> ~/.bashrc
+      Zsh:   echo 'eval "$(gdkbox completion zsh)"'  >> ~/.zshrc
+             (run after `compinit`)
+    DESC
+    def completion(shell)
+      puts Completion.new(self.class).script(shell)
+    end
+
+    desc "version", "Print the gdkbox version"
+    def version
+      say GDKBox::VERSION
+    end
+
+    private
+
+    # Seed skills into a freshly created box: the config.yml defaults (unless
+    # --no-default-skills) plus any --skill. All harnesses support SKILL.md
+    # skills; the box's harness decides the destination directory. Failures are
+    # non-fatal: the box is already up, and a stale config entry should not
+    # abort `gdkbox up`. Progress is muted when emitting JSON.
+    def seed_skills(box)
+      tokens = []
+      tokens.concat(config.default_skills) if options[:default_skills]
+      tokens.concat(options[:skill])
+      tokens.uniq!
+
+      tokens.each do |token|
+        skill = box.install_skill(token)
+        say "Seeded skill '#{skill.name}' into '#{box.name}'.", :green unless options[:json]
+      rescue Error => e
+        say "Skipped skill '#{token}': #{e.message}", :yellow unless options[:json]
+      end
+    end
+
+    # Show the discovered skills and let the user pick by number (or "all").
+    def prompt_for_skills
+      found = Skills.discover
+      raise Error, "No skills available to install." if found.empty?
+
+      say "Available skills:"
+      found.each_with_index do |skill, i|
+        say format("  %2d) %-26s [%s]", i + 1, skill.name, skill.origin)
+      end
+      answer = ask("Select skills (comma-separated numbers, or 'all'):").to_s.strip
+      return found.map(&:name) if answer.casecmp("all").zero?
+
+      answer.split(/[,\s]+/).reject(&:empty?).map do |n|
+        idx = Integer(n, exception: false)
+        raise Error, "Invalid selection: '#{n}'." unless idx && found[idx - 1]
+
+        found[idx - 1].name
+      end
+    end
+
+    def config
+      @config ||= Config.new
+    end
+
+    def build_box(name)
+      Box.new(name, config: config)
+    end
+
+    def load_box!(name)
+      box = build_box(name)
+      raise Error, "No box named '#{name}'. Run `gdkbox ls` to see boxes." unless box.exists?
+
+      box
+    end
+
+    def ensure_docker!
+      return if Docker.new.available?
+
+      raise Error, "Docker does not appear to be installed or on PATH."
+    end
+
+    # The API key to seed for the given harness, resolved in priority order:
+    # --api-key (or its --anthropic-api-key alias), then the provider env var,
+    # then config.yml. Returns nil when none is set. config.yml is last because
+    # it is a plaintext file.
+    def resolve_api_key(harness)
+      [
+        options[:api_key],
+        options[:anthropic_api_key],
+        ENV[harness.key_env],
+        config.api_key(harness.config_key)
+      ].find { |key| key && !key.to_s.strip.empty? }&.to_s
+    end
+
+    def rewrite_ssh_config
+      SSHConfig.new(config: config).write(Store.new(config: config).all)
+    end
+
+    def print_connection_details(box)
+      say ""
+      say "  SSH:       ssh #{box.ssh_host_alias}", :cyan
+      say "  VS Code:   gdkbox code #{box.name}", :cyan
+      say "  Web UI:    #{box.web_url}", :cyan
+      say "  Agent:     ssh #{box.ssh_host_alias} -t #{box.harness.bin}", :cyan
+    end
+  end
+end

data/lib/gdkbox/completion.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module GDKBox
+  # Generates shell completion scripts for the `gdkbox` CLI.
+  #
+  # The list of subcommands and their flags is introspected from the Thor CLI
+  # so it stays in sync automatically. Box names and skill names are completed
+  # dynamically at completion time by shelling back out to `gdkbox ls` and
+  # `gdkbox skills`.
+  class Completion
+    SHELLS = %w[bash zsh].freeze
+
+    # Subcommands whose first positional argument is an existing box.
+    BOX_COMMANDS = %w[status dispatch ssh code install-agent set-key start stop rm add-skill].freeze
+
+    def initialize(cli_class = CLI)
+      @cli = cli_class
+    end
+
+    # The completion script for the given shell.
+    def script(shell)
+      unless SHELLS.include?(shell)
+        raise Error, "Unsupported shell '#{shell}'. Supported: #{SHELLS.join(', ')}."
+      end
+
+      body = function + "\ncomplete -F _gdkbox gdkbox\n"
+      return body if shell == "bash"
+
+      # zsh can run bash-style completion functions via bashcompinit.
+      "autoload -U +X bashcompinit && bashcompinit\n#{body}"
+    end
+
+    private
+
+    # User-facing subcommand names (dashed), sorted.
+    def commands
+      (@cli.commands.keys + ["help"]).uniq.map { |c| c.tr("_", "-") }.sort
+    end
+
+    # The flag switches accepted by a single command, including global options.
+    def flags_for(command)
+      opts = command.options.values + @cli.class_options.values
+      opts.flat_map do |opt|
+        base = "--#{opt.name.tr('_', '-')}"
+        opt.type == :boolean ? [base, "--no-#{opt.name.tr('_', '-')}"] : [base]
+      end.uniq.sort
+    end
+
+    # `case` arms mapping each command to its flags, for the bash function.
+    def flag_cases
+      @cli.commands.map do |name, command|
+        "    #{name.tr('_', '-')}) flags=\"#{flags_for(command).join(' ')}\";;"
+      end.join("\n")
+    end
+
+    def function
+      <<~BASH
+        _gdkbox() {
+          local cur prev cmd i
+          cur="${COMP_WORDS[COMP_CWORD]}"
+          prev="${COMP_WORDS[COMP_CWORD-1]}"
+          COMPREPLY=()
+
+          local commands="#{commands.join(' ')}"
+
+          # Find the subcommand: the first non-flag word after "gdkbox".
+          cmd=""
+          for ((i=1; i<COMP_CWORD; i++)); do
+            case "${COMP_WORDS[i]}" in
+              -*) ;;
+              *) cmd="${COMP_WORDS[i]}"; break;;
+            esac
+          done
+
+          if [[ -z "$cmd" ]]; then
+            COMPREPLY=( $(compgen -W "$commands" -- "$cur") )
+            return
+          fi
+
+          # Complete flags when the current word looks like one.
+          if [[ "$cur" == -* ]]; then
+            local flags=""
+            case "$cmd" in
+        #{flag_cases}
+              *) flags="--verbose";;
+            esac
+            COMPREPLY=( $(compgen -W "$flags" -- "$cur") )
+            return
+          fi
+
+          # Complete the value an option expects.
+          case "$prev" in
+            --skill) COMPREPLY=( $(compgen -W "$(__gdkbox_skills)" -- "$cur") ); return;;
+            --harness) COMPREPLY=( $(compgen -W "#{@cli ? GDKBox::Harness.ids.join(' ') : ''}" -- "$cur") ); return;;
+            --task-file) COMPREPLY=( $(compgen -f -- "$cur") ); return;;
+          esac
+
+          # Positional-argument completions.
+          case "$cmd" in
+            #{(BOX_COMMANDS - ['add-skill']).join('|')})
+              COMPREPLY=( $(compgen -W "$(__gdkbox_boxes)" -- "$cur") );;
+            add-skill)
+              if [[ "$prev" == "add-skill" ]]; then
+                COMPREPLY=( $(compgen -W "$(__gdkbox_boxes)" -- "$cur") )
+              else
+                COMPREPLY=( $(compgen -W "$(__gdkbox_skills)" -- "$cur") )
+              fi;;
+            install-skill)
+              COMPREPLY=( $(compgen -W "$(__gdkbox_skills)" -- "$cur") );;
+            completion)
+              COMPREPLY=( $(compgen -W "bash zsh" -- "$cur") );;
+          esac
+        }
+
+        __gdkbox_boxes() {
+          gdkbox ls --json 2>/dev/null | grep -oE '"name":"[^"]+"' | sed -E 's/.*:"([^"]+)"/\\1/'
+        }
+
+        __gdkbox_skills() {
+          gdkbox skills 2>/dev/null | awk '/^[^[:space:]]/{print $1}'
+        }
+      BASH
+    end
+  end
+end

data/lib/gdkbox/config.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "yaml"
+
+module GDKBox
+  # Central configuration: filesystem paths, defaults, and naming conventions.
+  #
+  # The home directory can be overridden with the GDKBOX_HOME environment
+  # variable (useful for tests and for running multiple isolated setups).
+  #
+  # User-tunable defaults can be set in `<home>/config.yml` (by default
+  # `~/.gdkbox/config.yml`), for example:
+  #
+  #   # ~/.gdkbox/config.yml
+  #   image: registry.example.com/my-gdk:latest   # default image for `up`
+  #   skills:                                      # transferred into every box
+  #     - gdkbox-fleet
+  #     - code-history
+  class Config
+    # The official "GDK in a box" container image published by GitLab.
+    DEFAULT_IMAGE =
+      "registry.gitlab.com/gitlab-org/gitlab-development-kit/gitlab-gdk-in-a-box:main"
+
+    CONTAINER_PREFIX = "gdkbox-"
+    HOST_ALIAS_PREFIX = "gdkbox-"
+
+    # Inside the official image GDK lives under the `gdk` user.
+    SSH_USER = "gdk"
+    REMOTE_PATH = "/home/gdk/gitlab-development-kit"
+
+    # Ports as seen from inside the container.
+    SSH_CONTAINER_PORT = 22
+    GDK_WEB_CONTAINER_PORT = 3000
+
+    # Starting points for the host-side published ports. Each new box claims
+    # the next free port at or above these bases.
+    SSH_PORT_BASE = 2222
+    WEB_PORT_BASE = 3000
+
+    attr_reader :home
+
+    def initialize(home: nil)
+      @home = File.expand_path(
+        home || ENV["GDKBOX_HOME"] || File.join(Dir.home, ".gdkbox")
+      )
+    end
+
+    def boxes_dir
+      File.join(home, "boxes")
+    end
+
+    def keys_dir
+      File.join(home, "keys")
+    end
+
+    def ssh_config_path
+      File.join(home, "ssh_config")
+    end
+
+    # Lock file guarding host-port allocation against concurrent `gdkbox up`.
+    def lock_path
+      File.join(home, "create.lock")
+    end
+
+    # Path to the optional user config file.
+    def config_file
+      File.join(home, "config.yml")
+    end
+
+    # Parsed contents of config.yml, or an empty hash when it is absent or
+    # unreadable. Memoized for the life of the Config instance.
+    def file_settings
+      @file_settings ||= begin
+        if File.file?(config_file)
+          data = begin
+            YAML.safe_load(File.read(config_file))
+          rescue StandardError
+            nil
+          end
+          data.is_a?(Hash) ? data : {}
+        else
+          {}
+        end
+      end
+    end
+
+    # Skill names/paths to transfer into every box by default, from config.yml.
+    def default_skills
+      Array(file_settings["skills"]).map(&:to_s).reject(&:empty?)
+    end
+
+    # The default agent harness for `gdkbox up`, from config.yml.
+    def default_harness
+      key = file_settings["harness"].to_s
+      key.empty? ? Harness.default : key
+    end
+
+    # An API key read from config.yml under `config_key` (e.g.
+    # "anthropic_api_key", "openai_api_key"), or nil. This is a plaintext
+    # secret on disk, so it is the lowest-priority source (a flag or the
+    # provider's env var wins); keep config.yml mode 600 if you use it.
+    def api_key(config_key)
+      key = file_settings[config_key.to_s]
+      key.to_s.strip.empty? ? nil : key.to_s
+    end
+
+    # Back-compat convenience for the Anthropic key.
+    def anthropic_api_key
+      api_key("anthropic_api_key")
+    end
+
+    def private_key_path
+      File.join(keys_dir, "id_ed25519")
+    end
+
+    def public_key_path
+      "#{private_key_path}.pub"
+    end
+
+    def user_ssh_config
+      File.join(Dir.home, ".ssh", "config")
+    end
+
+    def ensure_dirs!
+      FileUtils.mkdir_p(boxes_dir)
+      FileUtils.mkdir_p(keys_dir)
+    end
+
+    def container_name(name)
+      "#{CONTAINER_PREFIX}#{name}"
+    end
+
+    def ssh_host_alias(name)
+      "#{HOST_ALIAS_PREFIX}#{name}"
+    end
+
+    def ssh_user
+      SSH_USER
+    end
+
+    def remote_path
+      REMOTE_PATH
+    end
+
+    def default_image
+      ENV["GDKBOX_IMAGE"] || file_settings["image"] || DEFAULT_IMAGE
+    end
+  end
+end