depot-linux 0.1.0

data/lib/depot/backends/rpm.rb

@@ -0,0 +1,280 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "time"
+require_relative "../desktop_entry"
+require_relative "../paths"
+require_relative "../result"
+require_relative "../packages/rpm"
+require_relative "../util"
+require_relative "support"
+
+module Depot
+  module Backends
+    class Rpm
+      include Support
+
+      def initialize(store:)
+        @store = store
+      end
+
+      def install(inspection, settings: {})
+        return Result.err("RPM backend cannot install #{inspection.format}") unless inspection.rpm?
+
+        Paths.ensure_base_dirs
+        package = RpmPackage.new(inspection.input)
+        return Result.err("Invalid RPM package.") unless package.valid?
+
+        app_id = Util.unique_id(Util.slug("#{package.display_name}-#{package.version_label}"), @store.ids)
+        app_dir = File.join(Paths.apps_dir, app_id)
+        root_dir = File.join(app_dir, "root")
+        FileUtils.mkdir_p(app_dir)
+
+        package.extract_to(root_dir)
+
+        desktop_source = package.primary_desktop_entry
+        desktop_contents = desktop_source && read_extracted_entry(root_dir, desktop_source)
+        display_name = desktop_name(desktop_contents) || package.display_name
+        preferred_icon = desktop_contents&.[]( /^Icon=(.+)$/, 1)&.strip
+        icon_name = install_icons(package, root_dir, app_id, preferred_icon)
+        executable = executable_for(package, root_dir, desktop_contents)
+
+        desktop_path = nil
+        if settings.fetch("desktop_integration", true) && executable
+          desktop_path = File.join(Paths.desktop_entries_dir, "depot-#{app_id}.desktop")
+          contents = desktop_contents ? rewrite_desktop(desktop_contents, root_dir, app_id, display_name, icon_name) : generated_desktop(app_id, display_name, executable, icon_name)
+          File.write(desktop_path, contents)
+        end
+
+        warnings = inspection.warnings + portable_warnings(package, executable, desktop_source)
+        manifest = {
+          "schema_version" => 1,
+          "app_id" => app_id,
+          "display_name" => display_name,
+          "default_display_name" => display_name,
+          "backend" => "rpm-portable",
+          "install_source" => File.expand_path(inspection.input),
+          "source_sha256" => inspection.sha256,
+          "source_size" => inspection.size,
+          "installed_executable" => executable,
+          "desktop_entry" => desktop_path,
+          "icons" => installed_icon_paths(app_id, preferred_icon),
+          "default_icon_name" => icon_name,
+          "created_files" => [desktop_path].compact + installed_icon_paths(app_id, preferred_icon),
+          "created_dirs" => [app_dir],
+          "installed_at" => Time.now.utc.iso8601,
+          "package" => package.package_fields.merge("Requires" => package.requires),
+          "desktop_source" => desktop_source,
+          "portable_root" => root_dir,
+          "permissions" => {
+            "executable" => executable ? File.executable?(executable) : false,
+            "requires_sudo" => false,
+            "writes_outside_depot" => false,
+            "notes" => ["RPM payload extracted user-locally. RPM scriptlets were not executed."]
+          },
+          "sandbox" => {
+            "enabled" => false,
+            "preference" => settings.fetch("sandbox_preference", "ask")
+          },
+          "update" => {
+            "mechanism" => "manual",
+            "source" => File.expand_path(inspection.input)
+          },
+          "warnings" => warnings
+        }
+
+        manifest_path = @store.write(manifest)
+        refresh_desktop_caches if settings.fetch("desktop_integration", true)
+        Result.ok(manifest.merge("manifest_path" => manifest_path), warnings:)
+      rescue RpmPackage::FormatError, SystemCallError => e
+        Result.err("RPM install failed: #{e.message}")
+      end
+
+      private
+
+      def read_extracted_entry(root_dir, entry)
+        path = File.join(root_dir, entry)
+        return nil unless File.file?(path)
+
+        File.read(path)
+      end
+
+      def desktop_name(contents)
+        return nil unless contents
+
+        line = contents.lines.find { |candidate| candidate.start_with?("Name=") }
+        line&.split("=", 2)&.last&.strip
+      rescue SystemCallError
+        nil
+      end
+
+      def executable_for(package, root_dir, desktop_contents)
+        exec_line = desktop_contents&.lines&.find { |line| line.start_with?("Exec=") }
+        command = exec_line&.split("=", 2)&.last.to_s.strip
+        rewritten = rewrite_exec_value(command, root_dir)
+        first = first_exec_token(rewritten)
+        return first if first && File.exist?(first)
+
+        package.executable_candidates.map { |entry| File.join(root_dir, entry) }.find { |path| File.file?(path) && File.executable?(path) }
+      rescue SystemCallError
+        nil
+      end
+
+      def generated_desktop(app_id, display_name, executable, icon_name)
+        DesktopEntry.new(app_id:, name: display_name, exec_path: executable, icon_name:).contents
+      end
+
+      def rewrite_desktop(contents, root_dir, app_id, display_name, icon_name)
+        seen_depot_id = false
+        current_group = nil
+        lines = []
+        contents.lines.each do |line|
+          if line.start_with?("[")
+            lines << "X-Depot-AppID=#{app_id}\n" if current_group == "[Desktop Entry]" && !seen_depot_id
+            current_group = line.strip
+          end
+
+          lines << if line.start_with?("Name=") && current_group == "[Desktop Entry]"
+                     "Name=#{display_name}\n"
+                   elsif line.match?(/\AExec=/)
+                     "Exec=#{rewrite_exec_value(line.split("=", 2).last.strip, root_dir)}\n"
+                   elsif line.match?(/\ATryExec=/)
+                     "TryExec=#{rewrite_exec_value(line.split("=", 2).last.strip, root_dir)}\n"
+                   elsif line.start_with?("Icon=")
+                     icon_name ? "Icon=#{icon_name}\n" : line
+                   elsif line.start_with?("X-Depot-AppID=")
+                     seen_depot_id = true
+                     "X-Depot-AppID=#{app_id}\n"
+                   else
+                     line
+                   end
+        end
+        lines << "X-Depot-AppID=#{app_id}\n" if current_group == "[Desktop Entry]" && !seen_depot_id
+        lines.join
+      end
+
+      def rewrite_exec_value(value, root_dir)
+        token, rest = split_exec(value)
+        return value if token.to_s.empty?
+
+        mapped = if token.start_with?("/")
+                   File.join(root_dir, token.delete_prefix("/"))
+                 elsif token.include?("/")
+                   File.join(root_dir, token)
+                 else
+                   candidate = find_executable(root_dir, token)
+                   candidate || token
+                 end
+        "#{Util.desktop_exec_quote(mapped)}#{rest}"
+      end
+
+      def split_exec(value)
+        if value.start_with?('"')
+          closing = value.index('"', 1)
+          return [value[1...closing], value[(closing + 1)..].to_s] if closing
+        end
+        token, rest = value.split(/\s+/, 2)
+        [token, rest ? " #{rest}" : ""]
+      end
+
+      def first_exec_token(value)
+        token, = split_exec(value)
+        token
+      end
+
+      def find_executable(root_dir, token)
+        Dir.glob(File.join(root_dir, "**", token)).find { |path| File.file?(path) && File.executable?(path) }
+      end
+
+      def install_icons(package, root_dir, app_id, preferred)
+        icons = package.icon_entries
+        icons = fallback_icon_entries(package, preferred) if icons.empty?
+        icons.sort_by { |entry| icon_score(entry, preferred) }.first(8).each do |entry|
+          ext = File.extname(entry).downcase
+          next unless [".png", ".svg", ".xpm"].include?(ext)
+
+          source = File.join(root_dir, entry)
+          next unless File.file?(source)
+
+          target_dir = File.join(Paths.icon_root, icon_theme_size(entry, source), "apps")
+          FileUtils.mkdir_p(target_dir)
+          icon_install_names(app_id, preferred).each do |name|
+            FileUtils.cp(source, File.join(target_dir, "#{name}#{ext}"))
+          end
+        end
+        icon_paths(app_id).any? ? app_id : nil
+      end
+
+      def fallback_icon_entries(package, preferred)
+        preferred_base = File.basename(preferred.to_s, ".*")
+        candidates = package.image_entries
+        scored = candidates.select do |entry|
+          base = File.basename(entry, ".*")
+          entry.match?(/(^|\/)(icon|logo|app|code)[^\/]*\.(png|svg|xpm)\z/i) ||
+            (!preferred_base.empty? && (base == preferred_base || entry.downcase.include?(preferred_base.downcase)))
+        end
+        scored.empty? ? candidates : scored
+      end
+
+      def icon_score(entry, preferred)
+        base = File.basename(entry, ".*")
+        [
+          preferred.to_s.empty? || base != preferred ? 1 : 0,
+          entry.include?("/256x256/") ? 0 : 1,
+          entry.include?("/512x512/") ? 0 : 1,
+          entry.match?(/(^|\/)(icon|logo|app|code)[^\/]*\.(png|svg|xpm)\z/i) ? 0 : 1,
+          -entry.length
+        ]
+      end
+
+      def icon_theme_size(entry, source)
+        match = entry.match(RpmPackage::HICOLOR_ICON_PATH)
+        return match[1] if match
+        return "scalable" if File.extname(entry).downcase == ".svg"
+        return png_size(source) if File.extname(entry).downcase == ".png"
+
+        "256x256"
+      end
+
+      def png_size(path)
+        File.open(path, "rb") do |file|
+          header = file.read(24)
+          return "256x256" unless header&.start_with?("\x89PNG\r\n\x1A\n".b)
+
+          width, height = header.byteslice(16, 8).unpack("NN")
+          return "256x256" if width.to_i <= 0 || height.to_i <= 0
+
+          "#{width}x#{height}"
+        end
+      rescue SystemCallError
+        "256x256"
+      end
+
+      def icon_paths(app_id)
+        Dir.glob(File.join(Paths.icon_root, "*", "apps", "#{app_id}.{png,svg,xpm}"), File::FNM_EXTGLOB)
+      end
+
+      def installed_icon_paths(app_id, preferred)
+        icon_install_names(app_id, preferred).flat_map do |name|
+          Dir.glob(File.join(Paths.icon_root, "*", "apps", "#{name}.{png,svg,xpm}"), File::FNM_EXTGLOB)
+        end.uniq
+      end
+
+      def icon_install_names(app_id, preferred)
+        names = [app_id]
+        preferred = preferred.to_s
+        names << preferred if preferred.match?(/\A[a-zA-Z0-9_.-]+\z/)
+        names.uniq
+      end
+
+      def portable_warnings(package, executable, desktop_source)
+        warnings = ["Depot installed this RPM in portable extraction mode and did not use rpm, dnf, zypper, sudo, or root scriptlets."]
+        warnings << "RPM scriptlets were found and were not executed: #{package.scriptlets.join(", ")}." unless package.scriptlets.empty?
+        warnings << "No desktop launcher was found; Depot generated one." unless desktop_source
+        warnings << "No executable could be confidently selected." unless executable
+        warnings
+      end
+
+    end
+  end
+end

data/lib/depot/backends/support.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "shellwords"
+require_relative "../paths"
+
+module Depot
+  module Backends
+    module Support
+      private
+
+      def command_available?(command)
+        ENV.fetch("PATH", "").split(File::PATH_SEPARATOR).any? { |dir| File.executable?(File.join(dir, command)) }
+      end
+
+      def refresh_desktop_caches
+        if command_available?("gtk-update-icon-cache") && Dir.exist?(Paths.icon_root)
+          system("gtk-update-icon-cache", "-f", "-t", Paths.icon_root, out: File::NULL, err: File::NULL)
+        end
+        if command_available?("update-desktop-database") && Dir.exist?(Paths.desktop_entries_dir)
+          system("update-desktop-database", Paths.desktop_entries_dir, out: File::NULL, err: File::NULL)
+        end
+      end
+
+      def write_shell_launcher(path, command, *args)
+        FileUtils.mkdir_p(File.dirname(path))
+        escaped = ([command] + args).map { |part| Shellwords.escape(part.to_s) }.join(" ")
+        File.write(path, "#!/bin/sh\nexec #{escaped} \"$@\"\n")
+        File.chmod(0o755, path)
+        path
+      end
+
+      def desktop_name_from(contents)
+        line = contents.to_s.lines.find { |candidate| candidate.start_with?("Name=") }
+        line&.split("=", 2)&.last&.strip
+      end
+    end
+  end
+end

data/lib/depot/cli.rb

@@ -0,0 +1,344 @@
+# frozen_string_literal: true
+
+require "json"
+require "optparse"
+require_relative "../depot"
+
+module Depot
+  class CLI
+    def initialize(stdout: $stdout, stderr: $stderr)
+      @stdout = stdout
+      @stderr = stderr
+    end
+
+    def run(argv)
+      command = argv.shift
+      case command
+      when "inspect"
+        inspect_command(argv)
+      when "install"
+        install_command(argv)
+      when "list"
+        list_command(argv)
+      when "info"
+        info_command(argv)
+      when "uninstall", "remove"
+        uninstall_command(argv)
+      when "update"
+        update_command(argv)
+      when "update-source"
+        update_source_command(argv)
+      when "sandbox"
+        sandbox_command(argv)
+      when "doctor"
+        doctor_command(argv)
+      when "settings"
+        settings_command(argv)
+      when "-h", "--help", nil
+        help
+        0
+      when "-v", "--version"
+        @stdout.puts "Depot #{Depot::VERSION}"
+        0
+      else
+        @stderr.puts "Unknown command: #{command}"
+        help(@stderr)
+        1
+      end
+    end
+
+    private
+
+    def inspect_command(argv)
+      json = argv.delete("--json")
+      input = argv.shift
+      return usage_error("Usage: depot inspect [--json] PATH_OR_URL") unless input
+
+      result = Inspector.inspect(input)
+      return print_error(result) unless result.ok?
+
+      if json
+        @stdout.puts JSON.pretty_generate(result.value.to_h)
+      else
+        inspection = result.value
+        @stdout.puts "Input: #{inspection.input}"
+        @stdout.puts "Format: #{inspection.format} (#{inspection.confidence})"
+        @stdout.puts "Name: #{inspection.display_name}"
+        @stdout.puts "Size: #{inspection.size || "unknown"}"
+        @stdout.puts "SHA-256: #{inspection.sha256 || "unknown"}"
+        @stdout.puts "Executable: #{inspection.executable ? "yes" : "no"}"
+        print_deb_metadata(inspection) if inspection.deb?
+        print_archive_metadata(inspection) if inspection.archive?
+        print_rpm_metadata(inspection) if inspection.rpm?
+        print_flatpakref_metadata(inspection) if inspection.flatpakref?
+        print_list("Warnings", inspection.warnings)
+        print_list("Risks", inspection.risks)
+      end
+      0
+    end
+
+    def install_command(argv)
+      json = argv.delete("--json")
+      no_desktop = argv.delete("--no-desktop")
+      input = argv.shift
+      return usage_error("Usage: depot install [--json] [--no-desktop] PATH") unless input
+
+      settings = {}
+      settings["desktop_integration"] = false if no_desktop
+      result = Installer.install(input, settings:)
+      return print_error(result) unless result.ok?
+
+      manifest = result.value
+      if json
+        @stdout.puts JSON.pretty_generate(manifest)
+      else
+        @stdout.puts "Installed #{manifest.fetch("display_name")} as #{manifest.fetch("app_id")}"
+        @stdout.puts "Executable: #{manifest.fetch("installed_executable")}"
+        @stdout.puts "Desktop entry: #{manifest["desktop_entry"] || "disabled"}"
+        @stdout.puts "Manifest: #{manifest.fetch("manifest_path")}"
+        print_list("Warnings", result.warnings)
+      end
+      0
+    end
+
+    def list_command(_argv)
+      apps = ManifestStore.new.all
+      if apps.empty?
+        @stdout.puts "No Depot apps installed."
+      else
+        apps.each do |manifest|
+          @stdout.puts "#{manifest.fetch("app_id")}\t#{manifest.fetch("display_name")}\t#{manifest.fetch("backend")}"
+        end
+      end
+      0
+    end
+
+    def info_command(argv)
+      json = argv.delete("--json")
+      app_id = argv.shift
+      return usage_error("Usage: depot info [--json] APP_ID") unless app_id
+
+      manifest = ManifestStore.new.find(app_id)
+      return usage_error("No installed app found for #{app_id}") unless manifest
+
+      if json
+        @stdout.puts JSON.pretty_generate(manifest)
+      else
+        @stdout.puts "App: #{manifest.fetch("display_name")} (#{manifest.fetch("app_id")})"
+        @stdout.puts "Backend: #{manifest.fetch("backend")}"
+        @stdout.puts "Source: #{manifest.fetch("install_source")}"
+        @stdout.puts "Update source: #{manifest.dig("update", "source") || "none"}"
+        @stdout.puts "Sandbox: #{Sandbox.summary(manifest)}"
+        @stdout.puts "Executable: #{manifest.fetch("installed_executable")}"
+        @stdout.puts "Desktop entry: #{manifest["desktop_entry"] || "none"}"
+        @stdout.puts "Installed: #{manifest.fetch("installed_at")}"
+        print_list("Created files", manifest.fetch("created_files", []))
+        print_list("Warnings", manifest.fetch("warnings", []))
+      end
+      0
+    end
+
+    def uninstall_command(argv)
+      app_id = argv.shift
+      return usage_error("Usage: depot uninstall APP_ID") unless app_id
+
+      result = Uninstaller.uninstall(app_id)
+      return print_error(result) unless result.ok?
+
+      @stdout.puts "Uninstalled #{app_id}"
+      print_list("Deleted files", result.value.fetch("deleted_files", []))
+      0
+    end
+
+    def update_command(argv)
+      json = argv.delete("--json")
+      all = argv.delete("--all")
+      app_id = argv.shift
+      return usage_error("Usage: depot update [--json] APP_ID | --all") unless all || app_id
+
+      result = all ? Updater.update_all : Updater.update(app_id)
+      return print_error(result) unless result.ok?
+
+      if json
+        @stdout.puts JSON.pretty_generate(result.value)
+      elsif all
+        @stdout.puts "Updated all available apps."
+      else
+        manifest = result.value
+        @stdout.puts "Updated #{manifest.fetch("display_name")} (#{manifest.fetch("app_id")})"
+      end
+      0
+    end
+
+    def update_source_command(argv)
+      app_id = argv.shift
+      url = argv.shift
+      return usage_error("Usage: depot update-source APP_ID HTTPS_URL") unless app_id && url
+
+      result = Updater.set_source(app_id, url)
+      return print_error(result) unless result.ok?
+
+      @stdout.puts "Set update source for #{app_id}."
+      0
+    end
+
+    def sandbox_command(argv)
+      app_id = argv.shift
+      mode = argv.shift
+      return usage_error("Usage: depot sandbox APP_ID [inherit|enabled|disabled]") unless app_id
+
+      manifest = ManifestStore.new.find(app_id)
+      return usage_error("No installed app found for #{app_id}") unless manifest
+
+      if mode.nil?
+        @stdout.puts Sandbox.summary(manifest)
+        return 0
+      end
+
+      result = Sandbox.set(app_id, { "mode" => mode })
+      return print_error(result) unless result.ok?
+
+      @stdout.puts "Set sandbox for #{app_id} to #{result.value.fetch("sandbox").fetch("mode")}."
+      0
+    end
+
+    def settings_command(argv)
+      settings = Settings.new
+      values = settings.load
+      if argv.empty?
+        @stdout.puts JSON.pretty_generate(values)
+        return 0
+      end
+
+      if argv.first == "set"
+        key = argv[1]
+        value = argv[2]
+        return usage_error("Usage: depot settings set KEY VALUE") unless key && value
+
+        parsed = case value
+                 when "true" then true
+                 when "false" then false
+                 else value
+                 end
+        saved = settings.save(values.merge(key => parsed))
+        @stdout.puts JSON.pretty_generate(saved)
+        return 0
+      end
+
+      usage_error("Usage: depot settings [set KEY VALUE]")
+    end
+
+    def doctor_command(argv)
+      json = argv.delete("--json")
+      report = Doctor.new.report
+      if json
+        @stdout.puts JSON.pretty_generate(report)
+        return 0
+      end
+
+      @stdout.puts "Depot doctor"
+      @stdout.puts "Tools:"
+      report.fetch("tools").each do |tool, present|
+        @stdout.puts "  - #{tool}: #{present ? "found" : "missing"}"
+      end
+      @stdout.puts "Paths:"
+      report.fetch("paths").each do |path, present|
+        @stdout.puts "  - #{path}: #{present ? "ok" : "missing"}"
+      end
+      manifests = report.fetch("manifests")
+      if manifests.empty?
+        @stdout.puts "Manifests: none installed"
+      else
+        @stdout.puts "Manifests:"
+        manifests.each do |manifest|
+          status = manifest.fetch("ok") ? "ok" : manifest.fetch("issues").join(", ")
+          @stdout.puts "  - #{manifest.fetch("app_id")}: #{status}"
+        end
+      end
+      0
+    end
+
+    def print_error(result)
+      @stderr.puts result.error
+      print_list("Warnings", result.warnings, io: @stderr)
+      1
+    end
+
+    def usage_error(message)
+      @stderr.puts message
+      1
+    end
+
+    def print_list(title, items, io: @stdout)
+      return if items.nil? || items.empty?
+
+      io.puts "#{title}:"
+      items.each { |item| io.puts "  - #{item}" }
+    end
+
+    def print_deb_metadata(inspection)
+      metadata = inspection.metadata
+      @stdout.puts "Package: #{metadata["package"] || "unknown"}"
+      @stdout.puts "Version: #{metadata["version"] || "unknown"}"
+      @stdout.puts "Architecture: #{metadata["architecture"] || "unknown"}"
+      @stdout.puts "Debian control archive: #{metadata["control_archive"] || "unknown"}"
+      @stdout.puts "Debian data archive: #{metadata["data_archive"] || "unknown"}"
+      print_list("Maintainer scripts", metadata.fetch("maintainer_scripts", []))
+      print_list("Desktop entries", metadata.fetch("desktop_entries", []))
+      print_list("Executable candidates", metadata.fetch("executable_candidates", []))
+    end
+
+    def print_archive_metadata(inspection)
+      metadata = inspection.metadata
+      @stdout.puts "Archive format: #{metadata["archive_format"] || inspection.format}"
+      @stdout.puts "Archive root: #{metadata["archive_root"] || "mixed"}"
+      print_list("Desktop entries", metadata.fetch("desktop_entries", []))
+      print_list("Executable candidates", metadata.fetch("executable_candidates", []))
+      print_list("Installer-like scripts", metadata.fetch("script_entries", []))
+      print_list("Source/build markers", metadata.fetch("source_markers", []))
+    end
+
+    def print_rpm_metadata(inspection)
+      metadata = inspection.metadata
+      version = [metadata["version"], metadata["release"]].compact.join("-")
+      @stdout.puts "Package: #{metadata["package"] || "unknown"}"
+      @stdout.puts "Version: #{version.empty? ? "unknown" : version}"
+      @stdout.puts "Architecture: #{metadata["architecture"] || "unknown"}"
+      @stdout.puts "RPM payload: #{metadata["payload_format"] || "unknown"} / #{metadata["payload_compressor"] || "unknown"}"
+      print_list("RPM requirements", metadata.fetch("requires", []))
+      print_list("RPM scriptlets", metadata.fetch("scriptlets", []))
+      print_list("Desktop entries", metadata.fetch("desktop_entries", []))
+      print_list("Executable candidates", metadata.fetch("executable_candidates", []))
+    end
+
+    def print_flatpakref_metadata(inspection)
+      metadata = inspection.metadata
+      @stdout.puts "Flatpak ID: #{metadata["name"] || "unknown"}"
+      @stdout.puts "Title: #{metadata["title"] || inspection.display_name}"
+      @stdout.puts "Branch: #{metadata["branch"] || "master"}"
+      @stdout.puts "Remote URL: #{metadata["url"] || "unknown"}"
+      @stdout.puts "Suggested remote: #{metadata["suggest_remote_name"] || "none"}"
+      @stdout.puts "Runtime ref: #{metadata["is_runtime"] ? "yes" : "no"}"
+      @stdout.puts "Embedded GPG key: #{metadata["gpg_key_present"] ? "yes" : "no"}"
+    end
+
+    def help(io = @stdout)
+      io.puts <<~HELP
+        Depot #{Depot::VERSION}
+
+        Usage:
+          depot inspect [--json] PATH_OR_URL
+          depot install [--json] [--no-desktop] PATH
+          depot list
+          depot info [--json] APP_ID
+          depot uninstall APP_ID
+          depot update [--json] APP_ID
+          depot update [--json] --all
+          depot update-source APP_ID HTTPS_URL
+          depot sandbox APP_ID [inherit|enabled|disabled]
+          depot doctor [--json]
+          depot settings [set KEY VALUE]
+      HELP
+    end
+  end
+end