depot-linux 0.1.0

data/lib/depot/source_resolver.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Depot
+  module SourceResolver
+    module_function
+
+    def resolve(source)
+      source = source.to_s
+      return source if !source.empty? && File.exist?(source)
+
+      fixture_match(source)
+    end
+
+    def url?(source)
+      uri = URI.parse(source.to_s)
+      uri.absolute? && !uri.scheme.to_s.empty?
+    rescue URI::InvalidURIError
+      false
+    end
+
+    def https_url?(source)
+      uri = URI.parse(source.to_s)
+      uri.is_a?(URI::HTTPS)
+    rescue URI::InvalidURIError
+      false
+    end
+
+    def fixture_match(source)
+      return nil if source.empty?
+
+      Dir[File.expand_path("../../fixtures/**/#{File.basename(source)}", __dir__)].first
+    end
+  end
+end

data/lib/depot/uninstaller.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "open3"
+require_relative "manifest_store"
+require_relative "result"
+
+module Depot
+  class Uninstaller
+    def self.uninstall(app_id)
+      new.uninstall(app_id)
+    end
+
+    def initialize(store: ManifestStore.new)
+      @store = store
+    end
+
+    def uninstall(app_id)
+      manifest = @store.find(app_id)
+      return Result.err("No installed app found for #{app_id}") unless manifest
+
+      flatpak = uninstall_flatpak(manifest)
+      return flatpak unless flatpak.ok?
+
+      deleted = []
+      manifest.fetch("created_files", []).each do |path|
+        next unless safe_delete_file?(path)
+
+        FileUtils.rm_f(path)
+        deleted << path
+      end
+
+      manifest.fetch("created_dirs", []).reverse_each do |path|
+        next unless safe_delete_dir?(path)
+
+        FileUtils.rm_rf(path) if Dir.exist?(path)
+      rescue SystemCallError
+        nil
+      end
+
+      @store.delete(app_id)
+      Result.ok({ "app_id" => app_id, "deleted_files" => deleted })
+    rescue SystemCallError => e
+      Result.err("Uninstall failed: #{e.message}")
+    end
+
+    private
+
+    def uninstall_flatpak(manifest)
+      return Result.ok unless manifest["backend"] == "flatpak"
+
+      flatpak_id = manifest.dig("flatpak", "app_id") || manifest.dig("package", "Name")
+      return Result.err("Flatpak manifest is missing the Flatpak app ID.") if flatpak_id.to_s.empty?
+      return Result.err("Flatpak is not installed on this system.") unless command_available?("flatpak")
+
+      stdout, stderr, status = Open3.capture3("flatpak", "uninstall", "--user", "--noninteractive", "-y", flatpak_id)
+      return Result.ok if status.success?
+
+      message = [stderr, stdout].map(&:to_s).find { |text| text.strip != "" } || "flatpak uninstall failed"
+      Result.err("Flatpak uninstall failed: #{message.strip}")
+    end
+
+    def safe_delete_file?(path)
+      return false unless path.is_a?(String) && !path.empty?
+      return false unless File.file?(path) || File.symlink?(path)
+
+      expanded = File.expand_path(path)
+      allowed_roots.any? { |root| expanded.start_with?(root + File::SEPARATOR) }
+    end
+
+    def safe_delete_dir?(path)
+      return false unless path.is_a?(String) && !path.empty?
+
+      expanded = File.expand_path(path)
+      expanded.start_with?(File.expand_path(Depot::Paths.apps_dir) + File::SEPARATOR)
+    end
+
+    def allowed_roots
+      @allowed_roots ||= [
+        Depot::Paths.data_dir,
+        Depot::Paths.desktop_entries_dir,
+        Depot::Paths.icon_root
+      ].map { |path| File.expand_path(path) }
+    end
+
+    def command_available?(command)
+      ENV.fetch("PATH", "").split(File::PATH_SEPARATOR).any? { |dir| File.executable?(File.join(dir, command)) }
+    end
+  end
+end

data/lib/depot/update_downloader.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require "digest"
+require "fileutils"
+require "net/http"
+require "tmpdir"
+require "uri"
+require_relative "result"
+require_relative "version"
+
+module Depot
+  module UpdateDownloader
+    MAX_DOWNLOAD_BYTES = 2 * 1024 * 1024 * 1024
+    MAX_REDIRECTS = 5
+    OPEN_TIMEOUT_SECONDS = 15
+    READ_TIMEOUT_SECONDS = 60
+    KNOWN_SUFFIXES = [
+      ".flatpakref",
+      ".AppImage",
+      ".appimage",
+      ".tar.gz",
+      ".tgz",
+      ".tar.xz",
+      ".txz",
+      ".tar.zst",
+      ".tzst",
+      ".deb",
+      ".rpm"
+    ].freeze
+
+    module_function
+
+    def download(url, max_bytes: MAX_DOWNLOAD_BYTES, redirects: MAX_REDIRECTS)
+      return Result.err("Update downloader requires a block.") unless block_given?
+
+      uri = parse_https_url(url)
+      return uri unless uri.ok?
+
+      Dir.mktmpdir("depot-update-") do |dir|
+        path = File.join(dir, "package#{suffix_for(uri.value.path)}")
+        result = download_to(uri.value, path, max_bytes:, redirects:)
+        return result unless result.ok?
+
+        yield path, result.value
+      end
+    rescue SystemCallError => e
+      Result.err("Could not download update: #{e.message}")
+    end
+
+    def https_url?(url)
+      parse_https_url(url).ok?
+    end
+
+    def parse_https_url(url)
+      uri = URI.parse(url.to_s)
+      return Result.err("Update URL must use https://.") unless uri.is_a?(URI::HTTPS)
+      return Result.err("Update URL is missing a host.") if uri.host.to_s.empty?
+
+      Result.ok(uri)
+    rescue URI::InvalidURIError
+      Result.err("Update URL must be a valid https:// URL.")
+    end
+
+    def download_to(uri, path, max_bytes:, redirects:)
+      return Result.err("Update download redirected too many times.") if redirects.negative?
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.open_timeout = OPEN_TIMEOUT_SECONDS
+      http.read_timeout = READ_TIMEOUT_SECONDS
+
+      request = Net::HTTP::Get.new(uri)
+      request["User-Agent"] = "Depot/#{Depot::VERSION}"
+      result = nil
+      http.request(request) do |response|
+        result = case response
+                 when Net::HTTPSuccess
+                   stream_response(uri, response, path, max_bytes)
+                 when Net::HTTPRedirection
+                   follow_redirect(uri, response, path, max_bytes:, redirects:)
+                 else
+                   Result.err("Update download failed: HTTP #{response.code}")
+                 end
+      end
+      result || Result.err("Update download failed before Depot received a response.")
+    rescue Timeout::Error, IOError, SystemCallError => e
+      Result.err("Update download failed: #{e.message}")
+    end
+
+    def follow_redirect(uri, response, path, max_bytes:, redirects:)
+      location = response["location"].to_s
+      return Result.err("Update download redirected without a location.") if location.empty?
+
+      redirected = URI.join(uri, location)
+      return Result.err("Update redirects must stay on https://.") unless redirected.is_a?(URI::HTTPS)
+
+      download_to(redirected, path, max_bytes:, redirects: redirects - 1)
+    rescue URI::InvalidURIError
+      Result.err("Update download redirected to an invalid URL.")
+    end
+
+    def stream_response(uri, response, path, max_bytes)
+      content_length = response["content-length"].to_i
+      if content_length.positive? && content_length > max_bytes
+        return Result.err("Update is too large to download safely (#{content_length} bytes).")
+      end
+
+      digest = Digest::SHA256.new
+      bytes = 0
+      File.open(path, "wb") do |file|
+        response.read_body do |chunk|
+          bytes += chunk.bytesize
+          return Result.err("Update exceeded Depot's #{max_bytes} byte safety limit.") if bytes > max_bytes
+
+          digest.update(chunk)
+          file.write(chunk)
+        end
+      end
+
+      return Result.err("Update download was empty.") if bytes.zero?
+
+      Result.ok(
+        {
+          "url" => uri.to_s,
+          "size" => bytes,
+          "sha256" => digest.hexdigest
+        }
+      )
+    end
+
+    def suffix_for(path)
+      basename = File.basename(path.to_s)
+      KNOWN_SUFFIXES.find { |suffix| basename.end_with?(suffix) } || File.extname(basename)
+    end
+  end
+end

data/lib/depot/updater.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+require "open3"
+require "time"
+require_relative "installer"
+require_relative "manifest_store"
+require_relative "result"
+require_relative "settings"
+require_relative "source_resolver"
+require_relative "update_downloader"
+require_relative "uninstaller"
+
+module Depot
+  class Updater
+    def self.update(app_id, options = {})
+      new.update(app_id, options)
+    end
+
+    def self.update_all(options = {})
+      new.update_all(options)
+    end
+
+    def self.set_source(app_id, url)
+      new.set_source(app_id, url)
+    end
+
+    def initialize(store: ManifestStore.new, settings: Settings.new)
+      @store = store
+      @settings = settings
+    end
+
+    def records
+      @store.all.map { |manifest| update_record(manifest) }
+    end
+
+    def update(app_id, options = {})
+      return Result.err("Updates are disabled in Depot settings.") unless updates_enabled?(options)
+
+      manifest = @store.find(app_id)
+      return Result.err("No installed app found for #{app_id}") unless manifest
+
+      case manifest.fetch("backend", "")
+      when "flatpak"
+        update_flatpak(manifest)
+      else
+        reinstall_from_source(manifest, options)
+      end
+    end
+
+    def update_all(options = {})
+      return Result.err("Updates are disabled in Depot settings.") unless updates_enabled?(options)
+
+      results = records.map do |record|
+        next { "app_id" => record.fetch("app_id"), "ok" => false, "error" => record.fetch("status") } unless record.fetch("enabled")
+
+        result = update(record.fetch("app_id"), options)
+        { "app_id" => record.fetch("app_id"), "ok" => result.ok?, "error" => result.error, "value" => result.value }
+      end
+      failed = results.reject { |result| result.fetch("ok") }
+      return Result.err("#{failed.length} updates failed.", warnings: failed.map { |result| "#{result.fetch("app_id")}: #{result.fetch("error")}" }) unless failed.empty?
+
+      Result.ok({ "updated" => results })
+    end
+
+    def set_source(app_id, url)
+      manifest = @store.find(app_id)
+      return Result.err("No installed app found for #{app_id}") unless manifest
+
+      return Result.err("Update URL must use https://.") unless UpdateDownloader.https_url?(url)
+
+      update = manifest.fetch("update", {}).merge(
+        "source" => url,
+        "mechanism" => "url-download",
+        "status" => "ready",
+        "last_checked_at" => Time.now.utc.iso8601
+      )
+      @store.write(manifest.merge("update" => update))
+      Result.ok(@store.find(app_id))
+    end
+
+    private
+
+    def updates_enabled?(options)
+      return true if options[:force]
+
+      @settings.load.fetch("updates_enabled", true)
+    end
+
+    def update_record(manifest)
+      source = SourceResolver.resolve(manifest["install_source"])
+      update_url = update_url(manifest)
+      method = update_method(manifest)
+      enabled = method == "flatpak" || !source.nil? || !update_url.nil?
+      status = update_status(method, source, update_url, manifest)
+      {
+        "app_id" => manifest.fetch("app_id"),
+        "display_name" => manifest.fetch("display_name"),
+        "backend" => manifest.fetch("backend"),
+        "method" => method,
+        "enabled" => enabled,
+        "status" => status,
+        "last_updated_at" => manifest.dig("update", "last_updated_at")
+      }
+    end
+
+    def update_method(manifest)
+      return "flatpak" if manifest.fetch("backend") == "flatpak"
+      return "url-download" if update_url(manifest)
+
+      "reinstall-source"
+    end
+
+    def update_status(method, source, update_url, manifest)
+      return "Ready" if method == "flatpak"
+      return "Ready from URL" if update_url
+      return "Ready" if source
+
+      raw_source = manifest.dig("update", "source") || manifest["install_source"]
+      if SourceResolver.url?(raw_source)
+        "Only https update URLs are supported"
+      else
+        "Original installer is missing"
+      end
+    end
+
+    def update_url(manifest)
+      source = manifest.dig("update", "source")
+      source = manifest["install_source"] if source.to_s.empty?
+      return nil unless SourceResolver.https_url?(source)
+
+      source
+    end
+
+    def update_flatpak(manifest)
+      flatpak_id = manifest.dig("flatpak", "app_id") || manifest.dig("package", "Name")
+      return Result.err("Flatpak manifest is missing the Flatpak app ID.") if flatpak_id.to_s.empty?
+      return Result.err("Flatpak is not installed on this system.") unless command_available?("flatpak")
+
+      stdout, stderr, status = Open3.capture3("flatpak", "update", "--user", "--noninteractive", "-y", flatpak_id)
+      return Result.err("Flatpak update failed: #{command_message(stdout, stderr)}") unless status.success?
+
+      update_manifest(manifest, "flatpak", "updated")
+      Result.ok(@store.find(manifest.fetch("app_id")), warnings: [command_message(stdout, stderr)].reject(&:empty?))
+    end
+
+    def reinstall_from_source(manifest, options)
+      url = update_url(manifest)
+      return reinstall_from_url(manifest, url, options) if url
+
+      source = SourceResolver.resolve(manifest["install_source"])
+      return Result.err("Original installer is missing: #{manifest["install_source"]}") unless source
+
+      uninstall = Uninstaller.new(store: @store).uninstall(manifest.fetch("app_id"))
+      return uninstall unless uninstall.ok?
+
+      install = Installer.new(store: @store, settings: @settings).install(source, settings: @settings.load.merge(options.fetch(:settings, {})))
+      return install unless install.ok?
+
+      updated = install.value
+      update_manifest(updated, "reinstall-source", "updated")
+      Result.ok(@store.find(updated.fetch("app_id")), warnings: install.warnings)
+    end
+
+    def reinstall_from_url(manifest, url, options)
+      UpdateDownloader.download(url) do |path, metadata|
+        inspection = Inspector.inspect(path)
+        return inspection unless inspection.ok?
+
+        compatible = compatible_update?(manifest, inspection.value)
+        return Result.err(compatible) unless compatible == true
+
+        uninstall = Uninstaller.new(store: @store).uninstall(manifest.fetch("app_id"))
+        return uninstall unless uninstall.ok?
+
+        install = Installer.new(store: @store, settings: @settings).install(path, settings: @settings.load.merge(options.fetch(:settings, {})))
+        return install unless install.ok?
+
+        updated = install.value
+        stored = @store.find(updated.fetch("app_id")) || updated
+        @store.write(stored.merge("install_source" => url))
+        update_manifest(
+          @store.find(updated.fetch("app_id")) || stored,
+          "url-download",
+          "updated",
+          "source" => url,
+          "last_download_sha256" => metadata.fetch("sha256"),
+          "last_download_size" => metadata.fetch("size")
+        )
+        Result.ok(@store.find(updated.fetch("app_id")), warnings: install.warnings)
+      end
+    end
+
+    def compatible_update?(manifest, inspection)
+      expected = expected_formats(manifest.fetch("backend", ""))
+      return true if expected.include?(inspection.format)
+
+      "Downloaded update is #{inspection.format}, but #{manifest.fetch("display_name")} was installed as #{manifest.fetch("backend")}. Depot will not switch package families during an update."
+    end
+
+    def expected_formats(backend)
+      case backend
+      when "appimage" then ["appimage"]
+      when "deb-portable" then ["deb"]
+      when "rpm-portable" then ["rpm"]
+      when "archive-portable" then %w[tar.gz tar.xz tar.zst]
+      when "flatpak" then ["flatpakref"]
+      else [backend]
+      end
+    end
+
+    def update_manifest(manifest, method, status, extra = {})
+      stored = @store.find(manifest.fetch("app_id")) || manifest
+      update = stored.fetch("update", {}).merge(
+        "mechanism" => method,
+        "status" => status,
+        "last_checked_at" => Time.now.utc.iso8601,
+        "last_updated_at" => Time.now.utc.iso8601
+      ).merge(extra)
+      @store.write(stored.merge("update" => update))
+    end
+
+    def command_message(stdout, stderr)
+      [stderr, stdout].map(&:to_s).find { |text| text.strip != "" }.to_s.strip
+    end
+
+    def command_available?(command)
+      ENV.fetch("PATH", "").split(File::PATH_SEPARATOR).any? { |dir| File.executable?(File.join(dir, command)) }
+    end
+  end
+end

data/lib/depot/util.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Depot
+  module Util
+    module_function
+
+    def sha256(path)
+      Digest::SHA256.file(path).hexdigest
+    end
+
+    def slug(value)
+      base = File.basename(value.to_s, ".*").downcase
+      base = base.gsub(/[^a-z0-9]+/, "-").gsub(/\A-+|-+\z/, "")
+      base.empty? ? "app" : base
+    end
+
+    def unique_id(base, taken)
+      candidate = base
+      index = 2
+      while taken.include?(candidate)
+        candidate = "#{base}-#{index}"
+        index += 1
+      end
+      candidate
+    end
+
+    def desktop_exec_quote(path)
+      %("#{path.gsub(/(["\\`$])/, '\\\\\\1')}")
+    end
+  end
+end

data/lib/depot/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Depot
+  VERSION = "0.1.0"
+end

data/lib/depot.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "depot/version"
+require_relative "depot/paths"
+require_relative "depot/result"
+require_relative "depot/settings"
+require_relative "depot/manifest_store"
+require_relative "depot/assets"
+require_relative "depot/packages/archive"
+require_relative "depot/packages/deb"
+require_relative "depot/packages/rpm"
+require_relative "depot/packages/flatpak_ref"
+require_relative "depot/inspector"
+require_relative "depot/installer"
+require_relative "depot/uninstaller"
+require_relative "depot/app_customizer"
+require_relative "depot/doctor"
+require_relative "depot/source_resolver"
+require_relative "depot/sandbox"
+require_relative "depot/update_downloader"
+require_relative "depot/updater"

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: depot-linux
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- netizensnoopy
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: toml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Install AppImage, .deb, .rpm, .flatpakref, tar.gz on Linux without root
+email:
+- netizensnoopy@users.noreply.github.com
+executables:
+- depot
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- README.md
+- Rakefile
+- bin/depot
+- bin/depot-gui
+- bin/setup-rubyqt6
+- fixtures/assets/download.png
+- fixtures/flatpakrefs/org.qbittorrent.qBittorrent.flatpakref
+- fixtures/rpms/Modrinth App-0.13.14-1.x86_64.rpm
+- lib/depot.rb
+- lib/depot/app_customizer.rb
+- lib/depot/assets.rb
+- lib/depot/backends/app_image.rb
+- lib/depot/backends/archive.rb
+- lib/depot/backends/deb.rb
+- lib/depot/backends/flatpak_ref.rb
+- lib/depot/backends/rpm.rb
+- lib/depot/backends/support.rb
+- lib/depot/cli.rb
+- lib/depot/desktop_entry.rb
+- lib/depot/doctor.rb
+- lib/depot/gui/app.rb
+- lib/depot/gui/drop_panel.rb
+- lib/depot/gui/main_window.rb
+- lib/depot/inspection.rb
+- lib/depot/inspector.rb
+- lib/depot/installer.rb
+- lib/depot/manifest_store.rb
+- lib/depot/packages/archive.rb
+- lib/depot/packages/deb.rb
+- lib/depot/packages/flatpak_ref.rb
+- lib/depot/packages/rpm.rb
+- lib/depot/paths.rb
+- lib/depot/result.rb
+- lib/depot/sandbox.rb
+- lib/depot/settings.rb
+- lib/depot/source_resolver.rb
+- lib/depot/uninstaller.rb
+- lib/depot/update_downloader.rb
+- lib/depot/updater.rb
+- lib/depot/util.rb
+- lib/depot/version.rb
+homepage: https://github.com/netizensnoopy/depot
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Unified Linux app installer
+test_files: []