ruflet 0.0.18 → 0.0.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4c83f1ea707d8ab40ca6e5f8228fa7f73ce4bc2c4348f586b4c6f206288babb2
-  data.tar.gz: d147a8eb4778f93958649e1fcabdfda7db65d85c5ca4b972e2fe38017533cfb2
+  metadata.gz: 699753a3740cce69a71d67b59cdcd5d8e60ee55d292c3f84b989b660f6e1935a
+  data.tar.gz: b8162cd3c319d7afcde7dcb3c50c6359d2c2596aec2acbbfef12368fe373132c
 SHA512:
-  metadata.gz: 5a1b8036b2001449630a70ffcec1fdb319b7c12e5cdd43599d16e0fc12c1dd411f8d27a72172ea285452ff93d134014e56175f11508395b012503c96092b6fce
-  data.tar.gz: 6d30c57bd94d4f264b81b5346c1160c4bcf75d14aa7b1e80dc6fab0d50cfbe0332421035b287dffad76e82718c28be71e3391004f640a5eecf40da0386aeedd0
+  metadata.gz: 12d669e64d6f397efe4c515fb258c147f243424a8b344f686e3787106086753e37af779e227dd4dc56ef6e3c80a5d68de15fab0c2b0ec95418585cd648e39478
+  data.tar.gz: c70d3335b5ddc83ca1d3f4d1f1b8d4bb91044ed56a667dbc45e8ab3c182ad5010d281801672307aaaaf63e35f83720c5a00b52370bb7153ee77345561c32c755

data/README.md

@@ -1,3 +1,57 @@
 # ruflet
 
-Part of Ruflet monorepo.
+`ruflet` is the command-line package for creating, running, diagnosing, and
+building Ruflet applications.
+
+## Install
+
+```bash
+gem install ruflet
+```
+
+Create a project and run it:
+
+```bash
+ruflet new my_app
+cd my_app
+bundle install
+bundle exec ruflet run --web
+```
+
+Generated projects include `ruflet_core` and `ruflet_server` as application
+dependencies. Use `bundle exec ruflet` inside a project so commands run with
+the versions declared in its `Gemfile`.
+
+## Commands
+
+```bash
+ruflet new <appname>
+ruflet run [scriptname|path] [--web|--desktop] [--port PORT]
+ruflet debug [scriptname|path]
+ruflet devices
+ruflet emulators
+ruflet doctor [--fix]
+ruflet update [web|desktop|all] [--check] [--force]
+ruflet build <apk|android|ios|aab|web|macos|windows|linux> [--self]
+ruflet install [--device DEVICE_ID]
+```
+
+Commands that create, diagnose, or build a Flutter client compare the cached
+template revision with `AdamMusa/ruflet-template` on GitHub. When `main`
+changes, Ruflet downloads the new template and refreshes its managed
+`build/client` automatically. If GitHub is unavailable, Ruflet keeps using the
+last complete cached template. Use `ruflet doctor --fix` to force a clean
+template download.
+
+Desktop and web runs use the completed `prebuild-main` client channel by
+default. Ruflet checks the channel at most once every six hours and downloads
+a new platform build only after every required prebuild job has finished.
+Use `ruflet update --force` for an immediate refresh. Set
+`RUFLET_CLIENT_CHANNEL=stable` to stay on versioned release assets,
+`RUFLET_CLIENT_UPDATE_INTERVAL=0` to check on every run, or
+`RUFLET_CLIENT_AUTO_UPDATE=0` to disable automatic client updates.
+
+Run `ruflet install` without `--device` to choose from a numbered list of
+connected devices. Pass `--device DEVICE_ID` to skip the prompt.
+
+Run `ruflet help <command>` for all options.

data/lib/ruflet/cli/build_command.rb

@@ -14,7 +14,6 @@ module Ruflet
     module BuildCommand
       include FlutterSdk
       CLIENT_EXTENSION_MAP = {
-        "ads" => { package: "flet_ads", alias: "ruflet_ads" },
         "audio" => { package: "flet_audio", alias: "ruflet_audio" },
         "audio_recorder" => { package: "flet_audio_recorder", alias: "ruflet_audio_recorder" },
         "camera" => { package: "flet_camera", alias: "ruflet_camera" },
@@ -175,13 +174,30 @@ module Ruflet
 
       def ensure_flutter_client_dir(verbose: false)
         client_dir = detect_flutter_client_dir
-        return client_dir if client_dir
+        if client_dir
+          refresh_hidden_flutter_client_template(client_dir, verbose: verbose)
+          return client_dir
+        end
 
         bootstrapped = bootstrap_flutter_client_template
         build_log(verbose, "bootstrapped client template at #{bootstrapped}") if bootstrapped
         bootstrapped
       end
 
+      def refresh_hidden_flutter_client_template(client_dir, verbose: false)
+        return unless File.expand_path(client_dir) == File.expand_path(hidden_flutter_client_dir)
+        return unless File.file?(File.join(client_dir, ".metadata"))
+        return unless Ruflet::CLI.respond_to?(:resolve_ruflet_client_template_root, true)
+
+        template_root = Ruflet::CLI.send(:resolve_ruflet_client_template_root)
+        return unless template_root && Dir.exist?(template_root)
+        return if Ruflet::CLI.respond_to?(:client_template_current?, true) &&
+          Ruflet::CLI.send(:client_template_current?, client_dir, template_root)
+
+        Ruflet::CLI.send(:copy_ruflet_client_template, Dir.pwd)
+        build_log(verbose, "refreshed managed Flutter client from template #{template_root}")
+      end
+
       def build_tool_env(env, platform, client_dir = nil)
         return env unless %w[ios macos].include?(platform)
 
@@ -1213,7 +1229,8 @@ module Ruflet
           "lib/connection_probe.dart",
           "lib/connection_probe_io.dart",
           "lib/connection_probe_stub.dart",
-          "ios/Podfile"
+          "ios/Podfile",
+          "windows/CMakeLists.txt"
         ]
 
         managed_files.each do |relative_path|
@@ -1388,10 +1405,10 @@ module Ruflet
       def prune_client_pubspec(path, selected_packages)
         data = YAML.safe_load(File.read(path), aliases: true) || {}
         deps = (data["dependencies"] || {}).dup
+        optional_packages = CLIENT_EXTENSION_MAP.values.map { |entry| entry.fetch(:package) }.uniq
 
         deps.keys.each do |name|
-          next unless name.start_with?("flet_")
-          next if name == "flet"
+          next unless optional_packages.include?(name)
           next if selected_packages.include?(name)
 
           deps.delete(name)
@@ -1445,7 +1462,9 @@ module Ruflet
 
         selected_aliases.each do |extension_alias|
           import_line = template.lines.find { |line| line.match?(/\sas #{Regexp.escape(extension_alias)};\s*\z/) }
-          extension_line = template.lines.find { |line| line.match?(/^\s*#{Regexp.escape(extension_alias)}\.Extension\(\),\s*$/) }
+          extension_line = template.lines.find do |line|
+            line.match?(/^\s*#{Regexp.escape(extension_alias)}\.[A-Za-z0-9_]+\(\),\s*$/)
+          end
 
           content = insert_missing_import(content, import_line) if import_line && !content.include?(import_line)
           content = insert_missing_extension(content, extension_line) if extension_line && !content.include?(extension_line)
@@ -1491,25 +1510,37 @@ module Ruflet
       def prune_client_main(path, selected_aliases)
         content = File.read(path)
         alias_to_package = {}
+        optional_aliases = CLIENT_EXTENSION_MAP.values.map { |entry| entry.fetch(:alias) }.uniq
 
-        content.scan(%r{^import 'package:(flet_[^/]+)/\1\.dart'\s+as ([a-zA-Z0-9_]+);$}m) do |package_name, import_alias|
+        content.scan(%r{^import 'package:([^/]+)/[^']+'\s+as ([a-zA-Z0-9_]+);$}m) do |package_name, import_alias|
           alias_to_package[import_alias] = package_name
         end
+        content.scan(%r{^import '([^']+)'\s+as ([a-zA-Z0-9_]+);$}m) do |_source, import_alias|
+          alias_to_package[import_alias] = :local if optional_aliases.include?(import_alias)
+        end
 
-        content = content.gsub(%r{^import 'package:(flet_[^/]+)/\1\.dart'\s+as ([a-zA-Z0-9_]+);\n}m) do |match|
+        content = content.gsub(%r{^import 'package:([^/]+)/[^']+'\s+as ([a-zA-Z0-9_]+);\n}m) do |match|
           package_name = Regexp.last_match(1)
           import_alias = Regexp.last_match(2)
-          if package_name == "flet" || selected_aliases.include?(import_alias)
+          if !optional_aliases.include?(import_alias) || selected_aliases.include?(import_alias)
+            match
+          else
+            ""
+          end
+        end
+        content = content.gsub(%r{^import '([^']+)'\s+as ([a-zA-Z0-9_]+);\n}m) do |match|
+          import_alias = Regexp.last_match(2)
+          if !optional_aliases.include?(import_alias) || selected_aliases.include?(import_alias)
             match
           else
             ""
           end
         end
 
-        content = content.gsub(/^(\s*)([a-zA-Z0-9_]+)\.Extension\(\),\s*$/) do |match|
+        content = content.gsub(/^(\s*)([a-zA-Z0-9_]+)\.[A-Za-z0-9_]+\(\),\s*$/) do |match|
           extension_alias = Regexp.last_match(2)
           package_name = alias_to_package[extension_alias]
-          if package_name.nil? || selected_aliases.include?(extension_alias)
+          if package_name.nil? || !optional_aliases.include?(extension_alias) || selected_aliases.include?(extension_alias)
             match
           else
             ""

data/lib/ruflet/cli/extra_command.rb

@@ -16,20 +16,23 @@ module Ruflet
         verbose = args.delete("--verbose") || args.delete("-v")
         fix = args.delete("--fix")
         client_dir = detect_client_dir
-        template_root = resolve_ruflet_client_template_root
+        template_root =
+          if fix
+            ensure_cached_ruflet_client_template!(force: true, verbose: !!verbose)
+          else
+            resolve_ruflet_client_template_root
+          end
         puts "Ruflet doctor"
         puts "  Ruby: #{RUBY_VERSION}"
         puts "  Flutter host target: #{flutter_host || 'unsupported'}"
         if template_root
           puts "  Template: #{template_root}"
+          revision = cached_template_revision if respond_to?(:cached_template_revision, true)
+          puts "  Template revision: #{revision}" if revision
         elsif fix
-          template_root = ensure_cached_ruflet_client_template!(force: true, verbose: !!verbose)
-          unless template_root
-            warn "  Template: missing"
-            warn "Failed to fetch the Ruflet Flutter template from GitHub."
-            return 1
-          end
-          puts "  Template: #{template_root}"
+          warn "  Template: missing"
+          warn "Failed to fetch the Ruflet Flutter template from GitHub."
+          return 1
         else
           warn "  Template: missing"
           warn "Run `ruflet doctor --fix` to fetch the Flutter template from GitHub."

data/lib/ruflet/cli/flutter_sdk.rb

@@ -47,9 +47,18 @@ module Ruflet
       private
 
       def flutter_tools(client_dir: nil, auto_install: true)
-        # Prefer FVM when available so Flutter/Dart match a pinned SDK.
-        fvm_tools = flutter_tools_via_fvm(client_dir: client_dir, auto_install: auto_install)
-        return fvm_tools if fvm_tools
+        desired = desired_flutter_spec(client_dir: client_dir)
+
+        # Environment and .fvmrc versions are intentional pins. Flutter's
+        # generated .metadata revision only records which SDK created the
+        # project; it must not force every build to download that old SDK.
+        if %i[env fvmrc].include?(desired[:source])
+          fvm_tools = flutter_tools_via_fvm(client_dir: client_dir, auto_install: auto_install)
+          return fvm_tools if fvm_tools
+        else
+          system_tools = flutter_tools_via_system
+          return system_tools if system_tools
+        end
 
         managed_tools = flutter_tools_via_managed_sdk(client_dir: client_dir, auto_install: auto_install)
         return managed_tools if managed_tools
@@ -57,6 +66,13 @@ module Ruflet
         nil
       end
 
+      def flutter_tools_via_system
+        flutter = which_command("flutter")
+        return nil unless flutter
+
+        tools_from_flutter_bin(flutter)
+      end
+
       def flutter_tools_via_managed_sdk(client_dir: nil, auto_install: true)
         return nil unless auto_install
 
@@ -199,7 +215,12 @@ module Ruflet
         return { version: fvm, source: :fvmrc } if fvm
 
         metadata = parse_flutter_metadata(find_flutter_metadata(client_dir))
-        return metadata.merge(source: :metadata) if metadata
+        if metadata
+          return {
+            channel: metadata[:channel] || DEFAULT_FLUTTER_CHANNEL,
+            source: :metadata
+          }
+        end
 
         { channel: DEFAULT_FLUTTER_CHANNEL, version: DEFAULT_FLUTTER_CHANNEL, source: :default }
       end

data/lib/ruflet/cli/new_command.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require "open3"
 require "tmpdir"
 require "yaml"
 
@@ -8,10 +9,10 @@ module Ruflet
   module CLI
     module NewCommand
       TEMPLATE_REPO_URL = ENV.fetch("RUFLET_TEMPLATE_REPO_URL", "https://github.com/AdamMusa/ruflet-template.git")
+      TEMPLATE_REPO_REF = ENV.fetch("RUFLET_TEMPLATE_REPO_REF", "main")
       RUNTIME_REPO_URL = ENV.fetch("RUFLET_RUNTIME_REPO_URL", "https://github.com/AdamMusa/ruflet.git")
 
       CLIENT_EXTENSION_MAP = {
-        "ads" => { package: "flet_ads", alias: "ruflet_ads" },
         "audio" => { package: "flet_audio", alias: "ruflet_audio" },
         "audio_recorder" => { package: "flet_audio_recorder", alias: "ruflet_audio_recorder" },
         "camera" => { package: "flet_camera", alias: "ruflet_camera" },
@@ -69,8 +70,10 @@ module Ruflet
 
         target = hidden_flutter_client_dir(root)
         FileUtils.mkdir_p(File.dirname(target))
+        FileUtils.rm_rf(target)
         FileUtils.cp_r(template_root, target)
         prune_client_template(target)
+        write_client_template_revision(target, installed_template_revision(template_root))
       end
 
       def hidden_flutter_client_dir(root = Dir.pwd)
@@ -99,8 +102,6 @@ module Ruflet
 
       def ensure_cached_ruflet_client_template!(force: false, verbose: false)
         cached_template = cached_ruflet_client_template_root
-        return cached_template if !force && Dir.exist?(cached_template)
-
         download_ruflet_template(force: force, verbose: verbose)
         Dir.exist?(cached_template) ? cached_template : nil
       end
@@ -113,6 +114,10 @@ module Ruflet
         File.join(template_cache_root, "ruflet_flutter_template")
       end
 
+      def cached_ruflet_client_template_revision_path
+        File.join(template_cache_root, "ruflet_flutter_template.revision")
+      end
+
       def cached_ruby_runtime_root
         File.join(cache_root, "ruby_runtime")
       end
@@ -126,40 +131,104 @@ module Ruflet
       end
 
       def download_ruflet_assets(force: false, verbose: false)
-        template_target = cached_ruflet_client_template_root
-        return true if !force && Dir.exist?(template_target)
-
-        Dir.exist?(template_target) || download_ruflet_template(force: force, verbose: verbose)
+        !ensure_cached_ruflet_client_template!(force: force, verbose: verbose).nil?
       end
 
       def download_ruflet_template(force: false, verbose: false)
         target = cached_ruflet_client_template_root
-        return target if !force && Dir.exist?(target)
+        remote_revision = remote_template_revision(verbose: verbose)
+        current_revision = cached_template_revision
+        cache_available = valid_ruflet_template?(target)
+        if !force && cache_available && remote_revision && current_revision == remote_revision
+          return target
+        end
+        if !force && cache_available && remote_revision.nil?
+          build_log(verbose, "Unable to check the Ruflet template revision; using cached #{current_revision || 'template'}") if respond_to?(:build_log, true)
+          return target
+        end
 
         FileUtils.mkdir_p(template_cache_root)
 
         Dir.mktmpdir("ruflet-assets") do |tmp|
           repo_dir = File.join(tmp, "Ruflet")
-          clone_cmd = ["git", "clone", "--depth", "1", "--filter=blob:none", "--sparse", TEMPLATE_REPO_URL, repo_dir]
-          return nil unless run_template_command(clone_cmd, verbose: verbose)
-          return nil unless run_template_command(["git", "-C", repo_dir, "sparse-checkout", "set", "templates/ruflet_flutter_template"], verbose: verbose)
+          clone_cmd = ["git", "clone", "--depth", "1", "--branch", TEMPLATE_REPO_REF, "--filter=blob:none", "--sparse", TEMPLATE_REPO_URL, repo_dir]
+          return target_if_present(target) unless run_template_command(clone_cmd, verbose: verbose)
+          return target_if_present(target) unless run_template_command(["git", "-C", repo_dir, "sparse-checkout", "set", "templates/ruflet_flutter_template"], verbose: verbose)
 
           source = File.join(repo_dir, "templates", "ruflet_flutter_template")
-          return nil unless Dir.exist?(source)
+          return target_if_present(target) unless valid_ruflet_template?(source)
 
+          fetched_revision = git_revision(repo_dir) || remote_revision
+          staged_target = File.join(tmp, "ruflet_flutter_template")
+          FileUtils.cp_r(source, staged_target)
           FileUtils.rm_rf(target)
-          FileUtils.cp_r(source, target)
+          FileUtils.mv(staged_target, target)
+          File.write(cached_ruflet_client_template_revision_path, "#{fetched_revision}\n") if fetched_revision
         end
 
         target
       rescue StandardError => e
         warn "Failed to fetch Ruflet template: #{e.class}: #{e.message}"
-        nil
+        target_if_present(target)
       end
 
       def run_template_command(cmd, verbose: false)
         output = verbose ? $stdout : File::NULL
-        system(*cmd, out: output, err: verbose ? $stderr : File::NULL)
+        env = { "GIT_TERMINAL_PROMPT" => "0" }
+        system(env, *cmd, out: output, err: verbose ? $stderr : File::NULL)
+      end
+
+      def remote_template_revision(verbose: false)
+        return @ruflet_template_remote_revision if defined?(@ruflet_template_remote_revision)
+
+        env = { "GIT_TERMINAL_PROMPT" => "0" }
+        stdout, stderr, status = Open3.capture3(env, "git", "ls-remote", TEMPLATE_REPO_URL, "refs/heads/#{TEMPLATE_REPO_REF}")
+        warn stderr unless status.success? || !verbose || stderr.empty?
+        @ruflet_template_remote_revision = status.success? ? stdout.split.first : nil
+      rescue StandardError => e
+        warn "Failed to check Ruflet template revision: #{e.message}" if verbose
+        @ruflet_template_remote_revision = nil
+      end
+
+      def cached_template_revision
+        return nil unless File.file?(cached_ruflet_client_template_revision_path)
+
+        File.read(cached_ruflet_client_template_revision_path).strip.then { |value| value.empty? ? nil : value }
+      end
+
+      def installed_template_revision(template_root)
+        return cached_template_revision if File.expand_path(template_root) == File.expand_path(cached_ruflet_client_template_root)
+
+        git_revision(File.expand_path("../..", template_root))
+      end
+
+      def write_client_template_revision(target, revision)
+        return unless revision
+
+        File.write(File.join(target, ".ruflet-template-revision"), "#{revision}\n")
+      end
+
+      def client_template_current?(target, template_root)
+        expected = installed_template_revision(template_root)
+        return false unless expected
+
+        marker = File.join(target, ".ruflet-template-revision")
+        File.file?(marker) && File.read(marker).strip == expected
+      end
+
+      def git_revision(repo_dir)
+        stdout, _stderr, status = Open3.capture3("git", "-C", repo_dir, "rev-parse", "HEAD")
+        status.success? ? stdout.strip : nil
+      rescue StandardError
+        nil
+      end
+
+      def valid_ruflet_template?(path)
+        Dir.exist?(path) && File.file?(File.join(path, "pubspec.yaml")) && File.file?(File.join(path, "lib", "main.dart"))
+      end
+
+      def target_if_present(target)
+        valid_ruflet_template?(target) ? target : nil
       end
 
       def prune_client_template(target)

data/lib/ruflet/cli/run_command.rb

@@ -16,6 +16,9 @@ require "time"
 module Ruflet
   module CLI
     module RunCommand
+      CLIENT_CHANNEL_MANIFEST = "ruflet_client-manifest.json"
+      DEFAULT_CLIENT_UPDATE_INTERVAL = 6 * 60 * 60
+
       def command_run(args)
         options = { target: "mobile", requested_port: 8550 }
         parser = OptionParser.new do |o|
@@ -371,17 +374,29 @@ module Ruflet
           return nil if desktop_asset.nil?
           wanted_assets << { kind: :desktop, name: desktop_asset, platform: platform }
         end
-        if !force && (wanted_assets.empty? || prebuilt_assets_present?(cache_root, web: web, desktop: desktop, platform: platform))
+        cache_ready = wanted_assets.empty? || prebuilt_assets_present?(cache_root, web: web, desktop: desktop, platform: platform)
+        release = nil
+        if !force && cache_ready
           ensure_client_manifest(cache_root, platform: platform)
-          return cache_root
+          manifest = read_client_manifest(cache_root)
+          return cache_root unless client_update_due?(manifest)
+
+          release = fetch_release_for_version(wanted_assets: wanted_assets)
+          if release.nil? || client_release_current?(manifest, release, wanted_assets)
+            mark_client_update_checked(cache_root)
+            return cache_root
+          end
+
+          force = true
         end
 
-        release = fetch_release_for_version
+        release ||= fetch_release_for_version(wanted_assets: wanted_assets)
         return nil unless release
 
         assets = release.fetch("assets", [])
         asset_names = assets.map { |a| a["name"].to_s }
         installed_assets = []
+        release_revision = client_release_revision(release)
         Dir.mktmpdir("ruflet-prebuilt-") do |tmpdir|
           wanted_assets.each do |wanted|
             asset_name = wanted.fetch(:name)
@@ -408,7 +423,8 @@ module Ruflet
               "kind" => wanted[:kind].to_s,
               "platform" => wanted[:platform] || platform,
               "asset_name" => resolved_name,
-              "download_url" => asset.fetch("browser_download_url")
+              "download_url" => asset.fetch("browser_download_url"),
+              "release_revision" => release_revision
             }
           end
         end
@@ -467,12 +483,71 @@ module Ruflet
         File.join(Dir.home, ".ruflet", "client", ruflet_version, platform.to_s)
       end
 
-      def fetch_release_for_version
-        release_by_tag("v#{ruflet_version}") ||
-          release_by_tag(ruflet_version) ||
-          release_by_tag("prebuild") ||
-          release_by_tag("prebuild-main") ||
-          release_latest
+      def fetch_release_for_version(wanted_assets: [])
+        releases = []
+        channel = client_release_channel
+        if channel != "stable"
+          rolling = release_by_tag(channel)
+          releases << rolling if rolling && rolling_release_complete?(rolling)
+        end
+        releases << release_by_tag("v#{ruflet_version}")
+        releases << release_by_tag(ruflet_version)
+        releases << release_latest
+        releases.compact.find { |release| release_has_wanted_assets?(release, wanted_assets) }
+      end
+
+      def client_release_channel
+        value = ENV.fetch("RUFLET_CLIENT_CHANNEL", "prebuild-main").to_s.strip
+        value.empty? ? "prebuild-main" : value
+      end
+
+      def rolling_release_complete?(release)
+        release.fetch("assets", []).any? { |asset| asset["name"] == CLIENT_CHANNEL_MANIFEST }
+      end
+
+      def release_has_wanted_assets?(release, wanted_assets)
+        assets = release.fetch("assets", [])
+        wanted_assets.all? do |wanted|
+          assets.any? { |asset| asset["name"] == wanted[:name] } || fallback_release_asset(assets, wanted)
+        end
+      end
+
+      def client_release_revision(release)
+        marker = release.fetch("assets", []).find { |asset| asset["name"] == CLIENT_CHANNEL_MANIFEST }
+        source = marker || release
+        [source["id"], source["updated_at"] || source["published_at"], source["size"]].compact.join(":")
+      end
+
+      def client_release_current?(manifest, release, wanted_assets)
+        return false unless manifest
+
+        revision = client_release_revision(release)
+        targets = Array(manifest["targets"])
+        wanted_assets.all? do |wanted|
+          targets.any? do |target|
+            target["kind"] == wanted[:kind].to_s &&
+              (wanted[:platform].nil? || target["platform"] == wanted[:platform]) &&
+              target["release_revision"] == revision
+          end
+        end
+      end
+
+      def client_update_due?(manifest)
+        return false if ENV["RUFLET_CLIENT_AUTO_UPDATE"].to_s.match?(/\A(?:0|false|no|off)\z/i)
+        return true unless manifest
+
+        checked_at = manifest["checked_at"] || manifest["installed_at"]
+        return true if checked_at.to_s.empty?
+
+        Time.now.utc - Time.iso8601(checked_at) >= client_update_interval
+      rescue ArgumentError
+        true
+      end
+
+      def client_update_interval
+        Integer(ENV.fetch("RUFLET_CLIENT_UPDATE_INTERVAL", DEFAULT_CLIENT_UPDATE_INTERVAL.to_s), 10).clamp(0, 7 * 24 * 60 * 60)
+      rescue ArgumentError
+        DEFAULT_CLIENT_UPDATE_INTERVAL
       end
 
       def ruflet_version
@@ -596,18 +671,36 @@ module Ruflet
 
       def write_client_manifest(root, platform:, release:, assets:)
         FileUtils.mkdir_p(root)
+        existing = read_client_manifest(root) || {}
+        installed_targets = Array(existing["targets"])
+        assets.each do |asset|
+          installed_targets.reject! do |target|
+            target["kind"] == asset["kind"] && target["platform"] == asset["platform"]
+          end
+          installed_targets << asset
+        end
         payload = {
-          "schema" => 1,
+          "schema" => 2,
           "ruflet_version" => ruflet_version,
           "platform" => platform,
-          "release_tag" => release && release["tag_name"],
-          "released_at" => release && release["published_at"],
+          "release_tag" => release && release["tag_name"] || existing["release_tag"],
+          "release_revision" => release && client_release_revision(release) || existing["release_revision"],
+          "released_at" => release && release["published_at"] || existing["released_at"],
+          "checked_at" => Time.now.utc.iso8601,
           "installed_at" => Time.now.utc.iso8601,
-          "targets" => assets
+          "targets" => installed_targets
         }
         File.write(client_manifest_path(root), JSON.pretty_generate(payload))
       end
 
+      def mark_client_update_checked(root)
+        manifest = read_client_manifest(root)
+        return unless manifest
+
+        manifest["checked_at"] = Time.now.utc.iso8601
+        File.write(client_manifest_path(root), JSON.pretty_generate(manifest))
+      end
+
       def print_mobile_qr_hint(port: 8550)
         host = best_lan_host
         payload = "http://#{host}:#{port}"

data/lib/ruflet/cli.rb

@@ -73,7 +73,7 @@ module Ruflet
           ruflet install [--device DEVICE_ID] [--verbose]
           ruflet devices
           ruflet emulators
-          ruflet doctor
+          ruflet doctor [--fix] [--verbose]
       HELP
     end
 
@@ -89,7 +89,7 @@ module Ruflet
     private
 
     def ensure_first_run_assets(command)
-      return if %w[version -v --version help -h --help].include?(command)
+      return unless %w[create new bootstrap init update debug build install doctor].include?(command)
       return unless respond_to?(:download_ruflet_assets, true)
 
       send(:download_ruflet_assets)

data/lib/ruflet/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ruflet
-  VERSION = "0.0.18" unless const_defined?(:VERSION)
+  VERSION = "0.0.19" unless const_defined?(:VERSION)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruflet
 version: !ruby/object:Gem::Version
-  version: 0.0.18
+  version: 0.0.19
 platform: ruby
 authors:
 - AdamMusa