ruby_everywhere 0.3.0 → 0.5.0

data/lib/everywhere/commands/doctor.rb

@@ -3,14 +3,15 @@
 require "dry/cli"
 require_relative "../shellout"
 require_relative "../paths"
+require_relative "../android_sdk"
 
 module Everywhere
   module Commands
     # Check that this machine can build native apps. Desktop checks always
-    # run; the iOS section joins in when the app's build.targets include an
-    # ios target, or explicitly via --target ios-*.
+    # run; the iOS and Android sections join in when the app's build.targets
+    # include such a target, or explicitly via --target ios-* / android-*.
     class Doctor < Dry::CLI::Command
-      desc "Check the toolchain (rbe-tebako, rust, brew deps; Xcode for iOS targets)"
+      desc "Check the toolchain (rbe-tebako, rust, brew deps; Xcode for iOS, SDK/JDK for Android)"
 
       option :root,   default: ".", desc: "App root (its build.targets pick the sections)"
       option :target, default: nil, desc: "Also check a specific target's toolchain (e.g. ios-arm64)"
@@ -22,6 +23,7 @@ module Everywhere
         ok &= check("homebrew bison")     { !`brew --prefix bison 2>/dev/null`.strip.empty? }
 
         ok &= ios_checks if ios_wanted?(root, target)
+        ok &= android_checks if android_wanted?(root, target)
 
         puts
         ok ? UI.success("ready to build") : UI.bad("fix the items above (see https://rubyeverywhere.com/docs/diy/requirements)")
@@ -64,6 +66,90 @@ module Everywhere
         ok
       end
 
+      def android_wanted?(root, target)
+        return true if target && Everywhere::Config.os_of(target) == "android"
+
+        Everywhere::Config.load(File.expand_path(root)).targets
+                          .any? { |t| Everywhere::Config.os_of(t) == "android" }
+      rescue StandardError
+        false
+      end
+
+      # Every check here resolves by location through AndroidSdk, never off
+      # PATH: Android Studio installs the SDK, adb, the emulator and a JDK
+      # without exporting any of them, so a `which adb` would report a broken
+      # machine that in fact builds fine. Nothing auto-installs — SDK components
+      # are gigabytes — so each failure carries the exact command to run.
+      def android_checks
+        puts
+        UI.step("Android target")
+        sdk = Everywhere::AndroidSdk
+        root = sdk.sdk_root
+
+        ok = fix_check(labelled("Android SDK", root && UI.short_path(root)),
+                       "install Android Studio (it provisions the SDK, adb, the emulator and a " \
+                       "JDK), or point ANDROID_HOME at an existing SDK") { !root.nil? }
+
+        jdk = sdk.java_version
+        ok &= fix_check(labelled("JDK #{sdk::MINIMUM_JDK}+", jdk && "found #{jdk}"),
+                        "install Android Studio (it bundles a JDK) or set JAVA_HOME to a " \
+                        "JDK #{sdk::MINIMUM_JDK} or newer") { !jdk.nil? && jdk >= sdk::MINIMUM_JDK }
+
+        # This one has to come before adb, the emulator, the AVD and the
+        # platform, because every one of those remediations is an sdkmanager
+        # line — and sdkmanager is exactly what can be missing. Phase 0 found a
+        # machine with a full SDK, adb, the emulator, build-tools and an AVD but
+        # no cmdline-tools anywhere, so "run this sdkmanager command" was the
+        # one piece of advice that couldn't be followed. Reported, but NOT
+        # folded into `ok`: that machine builds Android apps fine, and failing
+        # doctor over a component it doesn't need would be a lie.
+        if sdk.cmdline_tools?
+          UI.ok(labelled("Android SDK command-line tools", UI.short_path(sdk.sdkmanager)))
+        else
+          UI.warn("Android SDK command-line tools missing — nothing below can be installed " \
+                  "until they are: #{sdk.cmdline_tools_hint}")
+        end
+
+        ok &= fix_check(labelled("adb", sdk.adb && UI.short_path(sdk.adb)),
+                        sdk.install_hint("platform-tools")) { !sdk.adb.nil? }
+
+        ok &= fix_check(labelled("emulator", sdk.emulator && UI.short_path(sdk.emulator)),
+                        sdk.install_hint("emulator")) { !sdk.emulator.nil? }
+
+        avds = sdk.avds
+        ok &= fix_check(labelled("an Android virtual device", avds.first),
+                        sdk.create_avd_hint) { avds.any? }
+
+        platform = "platforms;android-#{sdk::COMPILE_SDK}"
+        ok &= fix_check(labelled(platform, listed(sdk.installed_platforms)),
+                        sdk.install_hint(platform)) { sdk.platform? }
+
+        ok &= fix_check("bundled Android shell template",
+                        "not shipped in this release of ruby_everywhere yet, so Android " \
+                        "builds aren't available") { !Everywhere::Paths.android_dir.nil? }
+        ok
+      end
+
+      # "adb (~/Library/Android/sdk/platform-tools/adb)" — the resolved location
+      # matters on Android in a way it doesn't on iOS, because there are several
+      # plausible SDK roots and the user can't tell from `which` which one we
+      # picked.
+      def labelled(label, detail) = detail ? "#{label} #{UI.dim("(#{detail})")}" : label
+
+      def listed(items) = items.empty? ? "none installed" : "have #{items.join(", ")}"
+
+      # check() prints one fixed label, but an Android remediation is only
+      # knowable after resolution (the sdkmanager path depends on where the SDK
+      # turned out to be), so a failure appends the exact command to run.
+      def fix_check(label, fix)
+        passed = yield
+        passed ? UI.ok(label) : UI.bad("#{label} — #{fix}")
+        passed
+      rescue StandardError
+        UI.bad("#{label} — #{fix}")
+        false
+      end
+
       def check(label)
         passed = yield
         passed ? UI.ok(label) : UI.bad(label)

data/lib/everywhere/commands/install.rb

@@ -158,6 +158,17 @@ module Everywhere
           #   - label: Quit
           #     action: quit
 
+          # Desktop window chrome. title_bar: overlay floats the macOS traffic
+          # lights over your page with no title text (reserve the space with the
+          # .everywhere-titlebar-inset class from everywhere/native.css);
+          # frameless removes the system chrome entirely, and the page draws its
+          # own title bar and calls Everywhere.window.* for the controls.
+          # window:
+          #   title_bar: overlay     # decorated (default) | overlay | frameless
+          #   title: false           # draw the title text
+          #   size: [1100, 750]
+          #   min_size: [600, 400]
+
           # Mobile tab bar (iOS today, Android soon). Served live from
           # /everywhere/ios_v1.json too, so tab changes deploy with the app —
           # no app-store release. Icons: ios = SF Symbol name.
@@ -177,6 +188,15 @@ module Everywhere
           #   ios:
           #     lazy_load_tabs: true   # defer each tab's first load until it's tapped
           #                            # (false = load every tab up front; omit = default)
+          #
+          #   Rust you keep in native/desktop/ and compile into the desktop
+          #   shell. Declaring anything here switches the desktop build to a
+          #   per-app cargo compile — the first one takes minutes.
+          #   desktop:
+          #     commands: [scan_ports]   # reachable as Everywhere.desktop.invoke("scan_ports")
+          #     setup: true              # run native/desktop/setup.rs at boot
+          #     crates:
+          #       serialport: "4.3"
 
           # Durable build knobs (CLI flags still override per-run).
           # build:
@@ -187,7 +207,7 @@ module Everywhere
           #     #                     # (`every build` / `every dev --ios`) work today;
           #     #                     # hosted platform builds for iOS aren't live yet.
           #     # - android-arm64     # future — mobile is remote mode only
-          #   permissions: [notifications, filesystem:read, clipboard]
+          #   capabilities: [notifications, filesystem:read, clipboard]  # desktop OS integration
 
           # Per-platform overrides. Keys are platform names (macos / ios / android /
           # windows / linux); anything here overrides the app: defaults above for that

data/lib/everywhere/commands/logs.rb

@@ -1,20 +1,27 @@
 # frozen_string_literal: true
 
 require "dry/cli"
+require_relative "../android_sdk"
+require_relative "../config"
+require_relative "../emulator"
 require_relative "../simulator"
 require_relative "../ui"
 
 module Everywhere
   module Commands
-    # Tail the native shell's logs. iOS only so far: the Simulator's unified
-    # log, scoped to the shell process. Watches (log stream) by default;
-    # --last replays recent history (log show) and exits.
+    # Tail the native shell's logs. Two platforms, one shape: the iOS Simulator's
+    # unified log scoped to the shell process, or Android's logcat scoped to the
+    # shell's process id. Watches by default; --last replays recent history and
+    # exits.
     class Logs < Dry::CLI::Command
-      desc "Stream native shell logs (iOS Simulator; watches by default)"
+      desc "Stream native shell logs (iOS Simulator or Android; watches by default)"
 
-      option :ios,     type: :boolean, default: false, desc: "iOS Simulator logs (the only target so far)"
-      option :last,    default: nil, desc: 'Show recent history instead of watching (e.g. "5m", "1h")'
+      option :ios,     type: :boolean, default: false, desc: "iOS Simulator logs (unified log)"
+      option :android, type: :boolean, default: false, desc: "Android logs (logcat, scoped to the app's process)"
+      option :last,    default: nil, desc: 'Show recent history instead of watching (e.g. "5m", "1h"; Android also takes a line count)'
       option :udid,    default: nil, desc: "Simulator UDID (default: the booted one)"
+      option :serial,  default: nil, desc: "Android device serial (default: the running emulator)"
+      option :app_id,  default: nil, desc: "Android applicationId (default: the one in config/everywhere.yml)"
       option :verbose, type: :boolean, default: false, desc: "Everything the shell process logs, debug level included"
 
       # The template contract fixes the product name (App.app), so the shell's
@@ -28,14 +35,56 @@ module Everywhere
       PREDICATE = 'process == "App" AND eventType == logEvent AND NOT subsystem BEGINSWITH "com.apple"'
       VERBOSE_PREDICATE = 'process == "App"'
 
-      def call(ios: false, last: nil, udid: nil, verbose: false, **)
-        UI.die!("only the iOS Simulator is supported so far — run: every logs --ios") unless ios
+      # Android has no predicate language, so the same job is split in two:
+      # `--pid=` fixes the process (see #android_logs) and a filterspec fixes
+      # the priority floor.
+      #
+      # Inside our own process the analogue of iOS's Apple-framework chatter is
+      # the platform's own: ART's GC bookkeeping, binder transactions,
+      # chromium's internal tracing. Those sit at VERBOSE, so the default floor
+      # is DEBUG — which keeps Hotwire Native's logging (Hotwire-Core and
+      # Hotwire-Navigation both log at debug), keeps every WebView console
+      # message (chromium reports them at INFO), and drops the runtime's
+      # housekeeping. --verbose lowers the floor to VERBOSE.
+      #
+      # Deliberately NOT a tag list: filtering on Hotwire-Core/Hotwire-Navigation
+      # would be the obvious way to cut noise and would hide the two things a
+      # shell developer most wants — their own Log calls and their page's
+      # console output. Scoping by process keeps everything that is ours and
+      # nothing that isn't, which is the same trade the iOS predicate makes.
+      DEFAULT_LEVEL = "*:D"
+      VERBOSE_LEVEL = "*:V"
 
+      # `-v time` is the compact-style analogue: with the process already fixed,
+      # repeating its pid on every line is noise. --verbose widens to threadtime,
+      # which adds the thread id you need once you're reading runtime internals.
+      DEFAULT_FORMAT = "time"
+      VERBOSE_FORMAT = "threadtime"
+
+      def call(ios: false, android: false, last: nil, udid: nil, serial: nil, app_id: nil, verbose: false, **)
+        UI.die!("pick a platform — run: every logs --ios, or every logs --android") unless ios || android
+        UI.die!("--ios and --android are two separate log streams — pick one") if ios && android
+
+        if android
+          android_logs(serial: serial, app_id: app_id, last: last, verbose: verbose)
+        else
+          ios_logs(udid: udid, last: last, verbose: verbose)
+        end
+      end
+
+      # --- iOS ------------------------------------------------------------------
+
+      def ios_logs(udid: nil, last: nil, verbose: false)
         udid ||= Everywhere::Simulator.booted_udid
         UI.die!("no booted iOS Simulator — start one with `every dev --ios`") unless udid
 
         UI.step(last ? "iOS Simulator logs from the last #{UI.bold(last)}"
                      : "watching iOS Simulator logs #{UI.dim("(Ctrl-C to stop)")}")
+        # exec replaces this process, so anything still sitting in Ruby's stdout
+        # buffer dies with it — and stdout IS buffered whenever it's a pipe,
+        # which is exactly how `every dev`'s log toggle runs us. Without this
+        # the header above silently vanishes in the one context that spawns us.
+        $stdout.flush
         exec(*argv(udid, last: last, verbose: verbose))
       end
 
@@ -51,6 +100,66 @@ module Everywhere
                 end
         argv + ["--style", "compact", "--predicate", verbose ? VERBOSE_PREDICATE : PREDICATE]
       end
+
+      # --- Android --------------------------------------------------------------
+
+      # logcat carries every process on the device, so the pid lookup is the
+      # whole filter — and it's also why "the app isn't running" is a distinct,
+      # extremely common state that has to be said plainly rather than shown as
+      # an empty stream. Unlike iOS, the process name isn't fixed by the
+      # template (it's the applicationId), so the config supplies it.
+      def android_logs(serial: nil, app_id: nil, last: nil, verbose: false)
+        serial ||= Everywhere::Emulator.booted_serial
+        UI.die!("no Android emulator or device — start one with `every dev --android`") unless serial
+
+        application_id = app_id || Everywhere::Config.load(Dir.pwd).bundle_id(target: "android-arm64")
+        pid = Everywhere::Emulator.pid_of(serial, application_id)
+        unless pid
+          UI.die!("#{application_id} isn't running on #{serial} — start it with `every dev --android` " \
+                  "(or pass --app-id if that isn't this app's applicationId)")
+        end
+
+        UI.step(last ? "Android logs from the last #{UI.bold(window_label(last))}"
+                     : "watching Android logs for #{UI.bold(application_id)} #{UI.dim("(Ctrl-C to stop)")}")
+        $stdout.flush # see ios_logs — exec discards a buffered header
+        exec(*android_argv(serial, pid, last: last, verbose: verbose))
+      end
+
+      # `-d` dumps what's buffered and exits — the `log show` half of the iOS
+      # split — and `-t` bounds that dump. Without `-d`, logcat follows.
+      def android_argv(serial, pid, last: nil, verbose: false)
+        argv = [Everywhere::AndroidSdk.adb!, "-s", serial, "logcat", "--pid=#{pid}"]
+        argv += ["-d", "-t", logcat_window(last)] if last
+        argv + ["-v", verbose ? VERBOSE_FORMAT : DEFAULT_FORMAT,
+                verbose ? VERBOSE_LEVEL : DEFAULT_LEVEL]
+      end
+
+      # logcat's -t takes a line count or a timestamp; it has no notion of "5m".
+      # So a bare number passes straight through as a count, and a duration in
+      # the iOS --last spelling is converted to the timestamp logcat wants.
+      #
+      # That timestamp is compared against the *device's* clock. An emulator
+      # inherits the host's clock and timezone so it lines up exactly; a
+      # physical device whose clock has drifted will return a little more or
+      # less than asked. A line count has no such ambiguity, which is why both
+      # spellings stay.
+      LOGCAT_TIME = "%m-%d %H:%M:%S.000"
+      DURATION_UNITS = { "s" => 1, "m" => 60, "h" => 3600, "d" => 86_400 }.freeze
+
+      def logcat_window(last)
+        text = last.to_s.strip
+        return text if text.match?(/\A\d+\z/)
+
+        if (match = text.match(/\A(\d+)([smhd])\z/i))
+          seconds = match[1].to_i * DURATION_UNITS.fetch(match[2].downcase)
+          return (Time.now - seconds).strftime(LOGCAT_TIME)
+        end
+
+        UI.die!(%(--last takes a line count ("200") or a duration ("30s", "5m", "2h") — got #{last.inspect}))
+      end
+
+      # "200" reads as a count, everything else as a duration.
+      def window_label(last) = last.to_s.match?(/\A\d+\z/) ? "#{last} lines" : last.to_s
     end
   end
 end

data/lib/everywhere/commands/release.rb

@@ -12,7 +12,7 @@ module Everywhere
     # Produce a signed, notarized, stapled, distributable artifact + release.json.
     #
     # `every release` wraps the existing signing engine
-    # (cli/support/macos/notarize.sh) rather than reimplementing
+    # (cli/support/release/macos/notarize.sh) rather than reimplementing
     # codesign/notarytool, and emits the machine-readable receipt every build
     # surface (local, CI, Platform) must produce. See
     # platform/docs/build-engine.md §4, §7, §9.
@@ -20,7 +20,7 @@ module Everywhere
     # Today only the macos builder is live; the target is parameterized so
     # ios/android/windows/linux slot in as builders later.
     class Release < Dry::CLI::Command
-      NOTARIZE = File.expand_path("../../../support/macos/notarize.sh", __dir__)
+      NOTARIZE = File.expand_path("../../../support/release/macos/notarize.sh", __dir__)
 
       desc "Sign, notarize, staple, and emit release.json for a distributable build"