ruby_everywhere 0.3.0 → 0.4.0

data/lib/everywhere/builders/ios.rb

@@ -5,6 +5,7 @@ require_relative "../paths"
 require_relative "../shellout"
 require_relative "../log_filter"
 require_relative "../icon"
+require_relative "../asset_catalog"
 require_relative "../ui"
 
 module Everywhere
@@ -72,9 +73,9 @@ module Everywhere
       end
 
       # The whole per-app surface: one xcconfig (identity), two JSON resources
-      # (runtime config + path configuration with baked tabs), one PNG (icon),
-      # and the Extensions/ buildable folder (app-authored Swift + generated
-      # registry). The pbxproj is never touched.
+      # (runtime config + path configuration with baked tabs), the asset catalog
+      # (icon + app images), and the Extensions/ buildable folder (app-authored
+      # Swift + generated registry). The pbxproj is never touched.
       def stamp!(work)
         UI.step("stamping shell #{UI.dim("(#{bundle_id} → #{UI.short_path(work)})")}")
         write_xcconfig(work)
@@ -86,8 +87,10 @@ module Everywhere
                    @config.path_configuration_json("ios"))
         write_launch_background(work)
         write_usage_strings(work)
+        write_url_scheme(work)
         write_entitlements(work)
         write_app_icon(work)
+        write_asset_catalog(work)
         write_extensions(work)
         write_native_packages(work)
       end
@@ -291,6 +294,25 @@ module Everywhere
         end
       end
 
+      # The custom URL scheme third-party sign-in returns through
+      # (everywhere.yml auth:) → Info.plist. ASWebAuthenticationSession claims
+      # the callback for itself while it's running, so this registration isn't
+      # what makes the flow work — it's what stops another app from quietly
+      # owning the scheme, and what makes `xcrun simctl openurl` usable for
+      # testing the return leg by hand.
+      def write_url_scheme(work)
+        errors = @config.auth_errors
+        UI.die!("auth in config/everywhere.yml:\n#{errors.join("\n")}") unless errors.empty?
+        return unless @config.oauth?
+
+        require "json"
+        scheme = @config.auth_scheme
+        UI.step("stamping sign-in callback scheme #{UI.dim("(#{scheme}://)")}")
+        Shellout.run!({}, "plutil", "-replace", "CFBundleURLTypes", "-json",
+                      JSON.generate([{ "CFBundleURLName" => bundle_id, "CFBundleURLSchemes" => [scheme] }]),
+                      File.join(work, "App", "Info.plist"))
+      end
+
       # The launch-screen (and splash overlay) background — the storyboard's
       # LaunchBackground named color, stamped from appearance.background_color
       # so the launch frame matches the app instead of the template default.
@@ -357,6 +379,21 @@ module Everywhere
         UI.warn "couldn't read #{File.basename(source)} — shipping the placeholder icon"
       end
 
+      # App-supplied images: native/ios/assets/** → imagesets in the template's
+      # Assets.xcassets, so native/ios Swift code reaches them by filename with
+      # Image("logo") / UIImage(named: "logo").
+      def write_asset_catalog(work)
+        source = File.join(@root, "native", "ios", "assets")
+        return unless File.directory?(source)
+
+        names, errors = AssetCatalog.write!(source, File.join(work, "App", "Assets.xcassets"))
+        UI.die!("native/ios/assets:\n#{errors.join("\n")}") unless errors.empty?
+        return if names.empty?
+
+        listed = names.length > 6 ? "#{names.take(6).join(", ")}, …" : names.join(", ")
+        UI.step("bundling image assets #{UI.dim("(#{names.length} from native/ios/assets: #{listed})")}")
+      end
+
       def xcodebuild!(work, configuration, dist_dir)
         UI.step("building iOS shell #{UI.dim("(xcodebuild, #{configuration}, first run compiles HotwireNative)")}")
         FileUtils.mkdir_p(dist_dir)

data/lib/everywhere/commands/build.rb

@@ -10,6 +10,7 @@ require_relative "../png"
 require_relative "../icon"
 require_relative "../paths"
 require_relative "../builders/ios"
+require_relative "../builders/android"
 
 module Everywhere
   module Commands
@@ -24,34 +25,47 @@ module Everywhere
     class Build < Dry::CLI::Command
       SHIM = File.expand_path("~/.tebako-shims/clang++")
 
-      desc "Package the app natively — desktop (tebako press + shell + .app) or iOS (--target ios-arm64)"
+      DEFAULT_TARGET = "macos-arm64"
+      IOS_TARGET = "ios-arm64"
+      # The APK/AAB is universal, so the arch half is nominal — it exists only
+      # so every target reads as os-arch.
+      ANDROID_TARGET = "android-arm64"
+
+      # The --ios/--android shorthands and the os they stand for, so adding a
+      # mobile platform is one entry rather than a third copy of resolve_target.
+      SHORTHAND_TARGETS = { ios: IOS_TARGET, android: ANDROID_TARGET }.freeze
+
+      desc "Package the app natively — desktop (tebako press + shell + .app), iOS (--ios) or Android (--android)"
 
       option :root,       default: ".",              desc: "App root directory"
       option :output,     default: nil,              desc: "Output binary path (default: dist/<app>)"
       option :ruby,       default: "4.0.6",          desc: "Ruby version to package"
       option :entry,      default: "native_boot.rb", desc: "Entry point script relative to root"
       option :app_name,   default: nil,              desc: "Bundle name (default: capitalized app dir)"
-      option :target,     default: "macos-arm64",    desc: "Build target (os-arch) — selects any platforms: overrides"
+      option :target,     default: nil,              desc: "Build target (os-arch) — selects any platforms: overrides, default: \"#{DEFAULT_TARGET}\""
       option :shell_dir,  default: nil,              desc: "Path to the shell's src-tauri directory"
+      option :ios,        type: :boolean, default: false, desc: "Build the iOS shell (shorthand for --target #{IOS_TARGET})"
+      option :android,    type: :boolean, default: false, desc: "Build the Android shell (shorthand for --target #{ANDROID_TARGET})"
       option :skip_press, type: :boolean, default: false, desc: "Reuse the existing pressed binary, only rebuild the .app"
 
       def call(root: ".", output: nil, ruby: "4.0.6", entry: "native_boot.rb",
-               app_name: nil, target: "macos-arm64", shell_dir: nil, skip_press: false, **)
+               app_name: nil, target: nil, shell_dir: nil, ios: false, android: false, skip_press: false, **)
+        target = resolve_target(target, ios: ios, android: android)
         root_path = File.expand_path(root)
         config = Everywhere::Config.load(root_path)
 
         # Builder dispatch on the target's os (build-engine.md §5): macOS is
-        # the tebako+tauri path below; iOS is a Hotwire Native shell built by
-        # its own builder. Anything else has no builder yet.
+        # the tebako+tauri path below; the mobile targets are Hotwire Native
+        # shells, each built by its own builder. Anything else has no builder yet.
         case Everywhere::Config.os_of(target)
-        when "ios"
-          app = Builders::Ios.new(config: config, root: root_path, target: target)
-                             .build!(dist_dir: File.expand_path("dist", root_path))
+        when "ios", "android"
+          app = mobile_builder(target).new(config: config, root: root_path, target: target)
+                                      .build!(dist_dir: File.expand_path("dist", root_path))
           UI.success("built #{rel(app, root_path)}")
           return
         when "macos" # the rest of this method
         else
-          UI.die!("no builder for target #{target} — macos-* and ios-* are supported")
+          UI.die!("no builder for target #{target} — macos-*, ios-* and android-* are supported")
         end
 
         # The os of `target` selects any per-platform overrides (bundle id,
@@ -95,6 +109,34 @@ module Everywhere
 
       private
 
+      # `--ios` is the shorthand `every dev` already has; --target stays the
+      # general escape hatch. Both given is only an error when they disagree —
+      # `--ios --target ios-arm64` is redundant, not wrong.
+      def mobile_builder(target)
+        Everywhere::Config.os_of(target) == "android" ? Builders::Android : Builders::Ios
+      end
+
+      # --ios/--android are shorthand for their target, and disagreeing with an
+      # explicit --target is a mistake worth naming rather than silently
+      # resolving one way: both spellings were deliberate, so we can't know
+      # which one the user meant.
+      def resolve_target(target, ios:, android:)
+        asked = { ios: ios, android: android }.select { |_flag, given| given }.keys
+        if asked.length > 1
+          UI.die!("#{asked.map { |f| "--#{f}" }.join(" and ")} are separate builds — run one at a time")
+        end
+
+        flag = asked.first or return target || DEFAULT_TARGET
+        shorthand = SHORTHAND_TARGETS.fetch(flag)
+        return shorthand if target.nil?
+
+        unless Everywhere::Config.os_of(target) == flag.to_s
+          UI.die!("--#{flag} and --target #{target} disagree — drop one " \
+                  "(--#{flag} means --target #{shorthand})")
+        end
+        target
+      end
+
       def rel(path, root_path) = UI.short_path(path.sub("#{root_path}/", "").sub("#{Dir.pwd}/", ""))
 
       # The precompile step runs against the HOST Ruby — unlike tebako press,

data/lib/everywhere/commands/clean.rb

@@ -6,17 +6,22 @@ require "fileutils"
 module Everywhere
   module Commands
     # Wipes the shared build caches under ~/.rubyeverywhere (or
-    # $RUBYEVERYWHERE_HOME): the cargo shell cache plus the iOS DerivedData /
-    # SPM / stamped-project dirs. Safe to run any time: only compiled shell
-    # output lives there, so the next `every dev`/`every build` recompiles cold.
+    # $RUBYEVERYWHERE_HOME): the cargo shell cache, the iOS DerivedData / SPM /
+    # stamped-project dirs, and the Android Gradle home / icon font / stamped
+    # projects. Safe to run any time: everything here is derived output, so the
+    # next `every dev`/`every build` rebuilds it — cold, and for Android that
+    # includes re-downloading Gradle and the Material icon font.
     class Clean < Dry::CLI::Command
-      desc "Remove the shell build caches (~/.rubyeverywhere: shell-target, ios-*)"
+      desc "Remove the shell build caches (~/.rubyeverywhere: shell-target, ios-*, android-*)"
 
       def call(**)
         caches = [Everywhere::Paths.cargo_target_dir,
                   Everywhere::Paths.ios_derived_data_dir,
                   Everywhere::Paths.ios_packages_dir,
-                  File.join(Everywhere::Paths.cache_dir, "ios")].select { |d| File.exist?(d) }
+                  File.join(Everywhere::Paths.cache_dir, "ios"),
+                  Everywhere::Paths.android_gradle_home,
+                  Everywhere::Paths.android_fonts_dir,
+                  File.join(Everywhere::Paths.cache_dir, "android")].select { |d| File.exist?(d) }
         return UI.step("nothing to clean #{UI.dim("(no build caches under #{Everywhere::Paths.cache_dir})")}") if caches.empty?
 
         freed = 0

data/lib/everywhere/commands/dev.rb

@@ -6,7 +6,9 @@ require "shellwords"
 require_relative "../shellout"
 require_relative "../paths"
 require_relative "../builders/ios"
+require_relative "../builders/android"
 require_relative "../simulator"
+require_relative "../emulator"
 require_relative "logs"
 
 module Everywhere
@@ -21,16 +23,24 @@ module Everywhere
     class Dev < Dry::CLI::Command
       desc "Run the dev server with native shells on demand (live reload, no packaging)"
 
+      IOS_TARGET = "ios-arm64"
+      ANDROID_TARGET = "android-arm64"
+
       option :port,      default: "3000", desc: "Dev server port"
       option :shell_dir, default: nil,    desc: "Path to the shell's src-tauri directory"
-      option :target,    default: nil,    desc: "Single shell to open: macos (desktop) or ios (Simulator)"
+      option :target,    default: nil,    desc: "Single shell to open: macos (desktop), ios (Simulator) or android (emulator)"
       option :desktop,   type: :boolean, default: false, desc: "Open the desktop shell"
       option :ios,       type: :boolean, default: false, desc: "Open the iOS Simulator shell"
+      option :android,   type: :boolean, default: false, desc: "Open the Android emulator shell"
       option :browser,   type: :boolean, default: false, desc: "Open the app in the default browser"
+      option :dev_url,   default: nil,    desc: "Explicit URL for the device to load (e.g. a LAN address for a physical Android device)"
 
-      def call(port: "3000", shell_dir: nil, target: nil, desktop: false, ios: false, browser: false, **)
+      def call(port: "3000", shell_dir: nil, target: nil, desktop: false, ios: false, android: false,
+               browser: false, dev_url: nil, **)
         @shell_dir = shell_dir
-        targets = requested_targets(target, desktop: desktop, ios: ios, browser: browser)
+        @port = port
+        @dev_url_override = dev_url
+        targets = requested_targets(target, desktop: desktop, ios: ios, android: android, browser: browser)
         framework, @config = detect_app
 
         start_server(framework, port)
@@ -54,10 +64,15 @@ module Everywhere
 
       private
 
-      def requested_targets(target, desktop:, ios:, browser:)
+      # --target names ONE shell; the boolean flags are additive. Desktop is the
+      # fallback for any --target that isn't a mobile os, which keeps
+      # `--target macos-arm64` (and a bare `--target`) meaning what it always did.
+      def requested_targets(target, desktop:, ios:, android:, browser:)
+        target_os = target && Everywhere::Config.os_of(target)
         targets = []
-        targets << "desktop" if desktop || (target && Everywhere::Config.os_of(target) != "ios")
-        targets << "ios"     if ios     || (target && Everywhere::Config.os_of(target) == "ios")
+        targets << "desktop" if desktop || (target && !%w[ios android].include?(target_os))
+        targets << "ios"     if ios     || target_os == "ios"
+        targets << "android" if android || target_os == "android"
         targets << "browser" if browser
         targets
       end
@@ -100,6 +115,7 @@ module Everywhere
       def launch(target)
         case target
         when "ios"     then launch_ios
+        when "android" then launch_android
         when "browser" then launch_browser
         else                launch_desktop
         end
@@ -134,6 +150,26 @@ module Everywhere
         Simulator.launch(udid, @config.bundle_id(target: "ios-arm64"), env: { "EVERYWHERE_DEV_URL" => @dev_url })
       end
 
+      # The Android counterpart of launch_ios: build Debug (warm after the first
+      # run), put it on a booted emulator and launch it. Unlike the Simulator,
+      # which shares the Mac's loopback, an Android device reaches the host
+      # through `adb reverse` — so the URL is resolved per-device rather than
+      # reused from @dev_url (see Emulator.dev_url for the fallback ladder).
+      # Pressing a again rebuilds and relaunches, so it doubles as a reload.
+      def launch_android
+        serial = Emulator.boot_default!
+        url = Emulator.dev_url(@dev_url, serial: serial, port: @port, override: @dev_url_override)
+
+        app = Builders::Android.new(config: @config, root: @config.root, target: ANDROID_TARGET)
+                               .build!(dist_dir: File.expand_path("dist", @config.root), dev: true, dev_url: url)
+
+        application_id = @config.bundle_id(target: ANDROID_TARGET)
+        UI.step("installing #{UI.bold(File.basename(app))}")
+        Emulator.install(serial, app, application_id: application_id)
+        UI.step("launching → #{UI.cyan(url)}")
+        Emulator.launch(serial, application_id)
+      end
+
       def launch_browser
         UI.step("opening browser → #{UI.cyan(@dev_url)}")
         opener = RUBY_PLATFORM.include?("darwin") ? "open" : "xdg-open"
@@ -164,14 +200,16 @@ module Everywhere
       # -icanon -echo disables only line buffering and echo, leaving output
       # processing (and Ctrl-C as SIGINT) intact.
       def interact
-        UI.note("press #{UI.bold("d")} desktop · #{UI.bold("i")} iOS Simulator · #{UI.bold("b")} browser · " \
-                "#{UI.bold("l")} iOS logs · #{UI.bold("q")} quit", marker: "⌨", color: :cyan)
+        UI.note("press #{UI.bold("d")} desktop · #{UI.bold("i")} iOS Simulator · #{UI.bold("a")} Android · " \
+                "#{UI.bold("b")} browser · #{UI.bold("l")} iOS logs · #{UI.bold("q")} quit",
+                marker: "⌨", color: :cyan)
         saved_tty = `stty -g`.chomp
         system("stty", "-icanon", "-echo")
         loop do
           case $stdin.getc
           when "d"               then launch("desktop")
           when "i"               then launch("ios")
+          when "a"               then launch("android")
           when "b"               then launch("browser")
           when "l"               then toggle_logs
           when "q", "\u0004", nil then break # q, Ctrl-D, EOF (Ctrl-C stays a real SIGINT)

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

@@ -187,7 +187,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