ruby_everywhere 0.9.1 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d36d2151f58701a6eab470774617b2c81dd99b78caa9829a152017e9840652e9
-  data.tar.gz: 1315f5032b754d7a45418604850cd96f9168ddeb25a7faf24df91608df7ede8c
+  metadata.gz: effe761f70b4c3220e02788d26a8fc49278a52f3e3876c331e3f9f484867592f
+  data.tar.gz: 9e589059bea3245ad9540696a24edfb9261736e0d1f30467698aad051c78541e
 SHA512:
-  metadata.gz: a2a6201f5ecae1781fecca6750a8952250d78e22e8b45c224c696fab8717a4ff2bb173b591d1e8724d69c695633358a8fb5320e74e2e849fcab738d5f2870b68
-  data.tar.gz: acaed9ef6364a807dcdf85378e33bac32f99e5309be5e9fcc404c257f6c2dc348f5f61b5e2482582a4bfca56495677da97dcf9de51f308ef9522b8919854185f
+  metadata.gz: ca496e477bd712bc8a8687916f8f9c17e1a3736d944f245bd633812a479d7771e1457107dd3e7135a2536657e70c4a5aecebe6a5c3df5ee5d12428fe70b423ba
+  data.tar.gz: 28e6a3a1c4a6c6c90a455ad545354a1d6812ea3bd1c3ef57a6a1d252c7e7ddf30d5edf7375a7b99e53dd15e6e059c70b11c55ef7070f2df90906b9ca2b13f36b

data/lib/everywhere/commands/preview.rb

@@ -1,18 +1,23 @@
 # frozen_string_literal: true
 
 require "dry/cli"
+require "fileutils"
 require "socket"
 require "securerandom"
 require "shellwords"
 require "timeout"
 require "uri"
+require "yaml"
 require_relative "../shellout"
 require_relative "../console"
 require_relative "../child_processes"
 require_relative "../child_supervision"
+require_relative "../dock/info"
 require_relative "../framework"
 require_relative "../config"
 require_relative "../jump"
+require_relative "../paths"
+require_relative "../raw_tty"
 
 module Everywhere
   module Commands
@@ -70,12 +75,18 @@ module Everywhere
 
         start_server(port)
         warn_if_loopback_only if lan
+        # Everything below this line scrolls: the dev server's log starts
+        # flowing the moment a device connects, and the invitation was gone off
+        # the top of the screen with it. The dock pins it instead.
+        @dock = Dock::Info.open(keys: $stdin.tty?)
         announce
         wait
       rescue Interrupt
         nil
       ensure
-        teardown_children
+        # The dock has to let go of the terminal before anything else prints —
+        # teardown_children's own warnings included.
+        teardown_children(before: [-> { @dock&.close }])
       end
 
       private
@@ -115,6 +126,7 @@ module Everywhere
       def start_tunnel
         if @tunnel_name
           UI.step("starting named tunnel #{UI.bold(@tunnel_name)} → #{UI.cyan("https://#{@tunnel_host}")}")
+          warn_if_ingress_mismatch
           spawn_tunnel("cloudflared tunnel run --url http://127.0.0.1:#{@port} #{@tunnel_name.shellescape}")
           "https://#{@tunnel_host}"
         else
@@ -128,7 +140,7 @@ module Everywhere
       # and the on_line hook fishes out the URL.
       def quick_tunnel_url
         found = Queue.new
-        spawn_tunnel("cloudflared tunnel --url http://127.0.0.1:#{@port}",
+        spawn_tunnel("cloudflared --config #{blank_config.shellescape} tunnel --url http://127.0.0.1:#{@port}",
                      on_line: ->(line) { (url = line[TRYCLOUDFLARE_URL]) && found << url },
                      quiet: true)
         begin
@@ -139,6 +151,62 @@ module Everywhere
         end
       end
 
+      # Where cloudflared looks for a local config, in its own search order.
+      CLOUDFLARED_CONFIGS = ["~/.cloudflared/config.yml", "~/.cloudflared/config.yaml",
+                             "/etc/cloudflared/config.yml", "/usr/local/etc/cloudflared/config.yml"].freeze
+
+      # A named tunnel keeps the user's cloudflared config on purpose — its
+      # credentials live there — but when that config declares ingress rules
+      # they beat our --url: cloudflared routes by Host header. A host with no
+      # matching rule falls to the catch-all (conventionally http_status:404);
+      # a rule aimed at another port reaches the wrong server. Both look like
+      # a dead preview with no hint of why, so say so before it happens.
+      # Best-effort: a config we can't read just means cloudflared honors --url.
+      def warn_if_ingress_mismatch
+        rules = cloudflared_ingress
+        return if rules.nil? || rules.empty?
+
+        rule = rules.find { |r| r["hostname"].nil? || host_matches?(r["hostname"], @tunnel_host) }
+        service = rule&.fetch("service", nil).to_s
+        if rule.nil? || service.start_with?("http_status:")
+          UI.warn("your cloudflared config's ingress has no rule for #{@tunnel_host}, so requests will get " \
+                  "the catch-all#{" (#{service})" unless service.empty?} — add " \
+                  "{hostname: #{@tunnel_host}, service: http://localhost:#{@port}} above it")
+        elsif (svc_port = service[/:(\d+)\z/, 1]) && Integer(svc_port) != @port
+          UI.warn("your cloudflared config's ingress routes #{@tunnel_host} to #{service}, but this preview " \
+                  "runs on port #{@port} — point that rule at the preview, or match it with --port #{svc_port}")
+        end
+      end
+
+      def cloudflared_ingress(paths: CLOUDFLARED_CONFIGS)
+        path = paths.map { |p| File.expand_path(p) }.find { |p| File.file?(p) }
+        return nil unless path
+
+        config = YAML.safe_load(File.read(path))
+        rules = config.is_a?(Hash) ? config["ingress"] : nil
+        rules.is_a?(Array) ? rules.grep(Hash) : nil
+      rescue StandardError
+        nil
+      end
+
+      # cloudflared ingress hostnames may hold a * wildcard; fnmatch covers it.
+      def host_matches?(pattern, host)
+        File.fnmatch?(pattern.to_s, host.to_s, File::FNM_CASEFOLD)
+      end
+
+      # cloudflared reads ~/.cloudflared/config.yml even in quick-tunnel mode,
+      # and config ingress rules win over --url: a leftover named-tunnel config
+      # sees a *.trycloudflare.com Host, matches nothing, and its catch-all
+      # (conventionally http_status:404) answers every request. A blank config
+      # keeps the quick tunnel self-contained. Named tunnels (--tunnel-name)
+      # still read the user's config on purpose — their credentials live there.
+      def blank_config
+        path = File.join(Paths.cache_dir, "cloudflared-blank.yml")
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, "")
+        path
+      end
+
       # quiet drops the child's routine chatter but always lets errors
       # through — a quick tunnel that can't connect must say why.
       def spawn_tunnel(cmd, on_line: nil, quiet: false)
@@ -205,13 +273,26 @@ module Everywhere
       end
 
       def announce
-        link = share_link || connect_url
+        @link = share_link || connect_url
         UI.step("preview of #{UI.bold(@config.name)} is live → #{UI.cyan(@url)}")
-        Console.print(qr_ansi(link)) if $stdout.tty?
-        Console.print("  Scan with your phone's camera, or send:\n\n    #{UI.cyan(link)}\n\n")
+        show_qr
         Console.print("  #{UI.dim("Manual entry in Jump:")} #{@url}  #{UI.dim("token:")} #{@token}\n")
         Console.print(UI.dim("  The link and QR die with this session — Ctrl-C to stop.\n"))
         UI.note("waiting for devices…", marker: "⌁", color: :cyan)
+        @dock.show(footer_facts)
+      end
+
+      # What stays on screen. The QR is ~17 rows — far too tall to pin — so the
+      # footer carries what a person can act on without it: the link to forward,
+      # and the URL and token for Jump's manual entry form.
+      def footer_facts = [["link", @link], ["url", @url], ["token", @token]]
+
+      # Printed at announce time and again on `s`, once the logs have scrolled
+      # the code away. A non-tty stdout gets the link alone — an ANSI QR down a
+      # pipe is noise.
+      def show_qr
+        Console.print(qr_ansi(@link)) if $stdout.tty?
+        Console.print("  Scan with your phone's camera, or send:\n\n    #{UI.cyan(@link)}\n\n")
       end
 
       # Half-block rendering: ▀ painted fg-for-top-module, bg-for-bottom packs
@@ -246,14 +327,23 @@ module Everywhere
 
       # --- the wait loop --------------------------------------------------------
 
+      # RawTty only when the dock is offering keys: it puts the terminal in
+      # -icanon -echo for the whole process, which a piped or CI run has no use
+      # for — and its ensure is what puts the terminal back, so the watch loop
+      # has to run inside it rather than beside it.
+      def wait
+        @dock.keys? ? RawTty.with { watch } : watch
+      end
+
       # The server's death ends the session; the tunnel's doesn't. Quick
       # tunnels are explicitly best-effort — Cloudflare recycles them — so a
       # dead tunnel is restarted and the fresh URL re-announced. (The token
       # survives, but the origin changed, so recents/short links need the new
-      # invitation.)
-      def wait
+      # invitation — including the copy pinned in the footer.)
+      def watch
         loop do
-          sleep 1
+          break if pause == :quit
+
           web = @children.synchronize { @pids[:web] }
           UI.die!("the dev server exited — scroll up for its output") unless ChildProcesses.alive?(web)
 
@@ -267,7 +357,45 @@ module Everywhere
         end
       end
 
-      # --- child supervision (dev.rb's pattern, without the dock) ---------------
+      # A second between checks, spent waiting on a keystroke when there is a
+      # terminal to take one from — so a key is acted on the moment it's pressed
+      # rather than up to a second later, and the loop keeps its one pacing
+      # point either way.
+      def pause
+        return sleep(1) unless @dock.keys?
+        return unless IO.select([$stdin], nil, nil, 1)
+
+        case $stdin.getc
+        when "s"                then show_qr
+        when "r"                then restart_server
+        when "q", "\u0004", nil then :quit # q, Ctrl-D, EOF (Ctrl-C stays a real SIGINT)
+        end
+      end
+
+      # Replace just the dev server, keeping the tunnel and the pairing token —
+      # how a gem update or an everywhere.yml change gets picked up without
+      # invalidating the invitation everyone already scanned. start_server
+      # rebuilds the env, so the same @token rides back in; connected devices
+      # see a blip, not a disconnect. The config is reloaded so a renamed app
+      # announces under its new name if the tunnel later restarts.
+      def restart_server
+        UI.step("restarting the dev server #{UI.dim("(the tunnel, link and token stay)")}")
+        stop_child(:web)
+        wait_for_port_close
+        @config = Everywhere::Config.load(@framework.root)
+        start_server(@port.to_s)
+        UI.note("server is back — same URL, same token", marker: "⌁", color: :cyan)
+      end
+
+      # stop_child has reaped the process, but the kernel can hold its listener
+      # a beat longer; start_server's already-running guard would read that as
+      # a stranger's server and kill the whole session.
+      def wait_for_port_close(timeout: 10)
+        deadline = Clock.monotonic + timeout
+        sleep 0.1 while port_open?(@port) && Clock.monotonic < deadline
+      end
+
+      # --- child supervision (dev.rb's pattern, its own no-pty fallback) --------
 
       def spawn_child(env, cmd, chdir:)
         return Shellout.spawn_pty(env, cmd, chdir: chdir) if Shellout.pty?

data/lib/everywhere/dock/footer.rb

@@ -95,6 +95,49 @@ module Everywhere
 
       def plain_width(segments) = segments.sum { |s| plain(s).length } + (GAP.length * [segments.size - 1, 0].max)
 
+      # --- info rows -----------------------------------------------------------
+
+      # `every preview`'s footer: labelled facts (the share link, the tunnel
+      # URL, the pairing token) instead of target states. items: [[label,
+      # value], …].
+      #
+      # Packed across as many rows as it takes rather than truncated to one,
+      # which is the one place this parts ways with status_row: these values
+      # exist to be scanned, read aloud and typed in by hand, and half a URL or
+      # a clipped token is worse than useless.
+      def info(items, cols:, keys: nil, rule: true)
+        cols = [cols.to_i, 1].max
+        lines = []
+        lines << UI.gray("─" * cols) if rule
+        lines.concat(pack(items.map { |label, value| info_pair(label, value) }, cols))
+        lines << keys_row(keys, cols) if keys
+        lines
+      end
+
+      # Greedy: keep adding facts to the current row while they fit, start a new
+      # row when they don't. A single fact wider than the terminal is the only
+      # thing that ever gets cut (by fit).
+      def pack(pairs, cols)
+        rows = []
+        row = []
+        pairs.each do |pair|
+          if row.any? && row_width(row + [pair]) > cols
+            rows << fit(row, cols)
+            row = [pair]
+          else
+            row << pair
+          end
+        end
+        rows << fit(row, cols) if row.any?
+        rows
+      end
+
+      def info_pair(label, value)
+        ["#{label} #{value}", "#{UI.dim(label)} #{UI.cyan(value)}"]
+      end
+
+      def row_width(pairs) = pairs.sum { |plain, _| plain.length } + (GAP.length * [pairs.size - 1, 0].max)
+
       # --- keys row ------------------------------------------------------------
 
       # Named keys with dot separators, then named keys packed tighter, then

data/lib/everywhere/dock/info.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "../dock"
+
+module Everywhere
+  class Dock
+    # The pinned footer for `every preview`.
+    #
+    # Same machinery as the dev dock — it owns the terminal through Console and
+    # repaints around every write (see Dock::Screen) — but what it pins is a
+    # handful of facts rather than a set of running targets: the share link, the
+    # URL to type in by hand and the pairing token. Preview prints those once
+    # and then relays the dev server's log, which used to bury them within
+    # seconds; the whole point of the command is that someone can still see how
+    # to connect five minutes in.
+    #
+    # It carries no state of its own to spin, so the base class's ticker only
+    # ever redraws it on a resize.
+    class Info < Dock
+      KEYS = [
+        ["s", "show the QR"],
+        ["r", "restart server"],
+        ["q", "quit"]
+      ].freeze
+
+      def self.open(items = [], io: $stdout, keys: true, size: nil)
+        return Null.new unless drawable?(io, size)
+
+        new(items, io: io, keys: keys, size: size).tap(&:install)
+      end
+
+      def initialize(items = [], io: $stdout, keys: true, size: nil)
+        super([], io: io, keys: keys, size: size)
+        @items = items
+      end
+
+      # Whether the keymap in the footer is a promise we can keep — the caller
+      # owns the key loop, so it has to know whether to read stdin at all.
+      def keys? = @keys
+
+      # Replace the facts and repaint now. A quick tunnel that dropped comes
+      # back on a different hostname, so the footer must not outlive its URL.
+      def show(items)
+        @items = items
+        @dirty = true
+        refresh
+      end
+
+      private
+
+      def footer_rows
+        Footer.info(@items,
+                    cols: [@screen.cols - 1, 1].max,
+                    keys: (@keys ? KEYS : nil),
+                    rule: @screen.rows >= 24)
+      end
+
+      # The headless stand-in, as with Dock::Null: no escape sequences, and
+      # never installed as Console's sink, so a piped or CI run prints exactly
+      # what it printed before the footer existed.
+      class Null
+        def install = self
+        def keys? = false
+        def show(_items) = nil
+        def emit(_text) = nil
+        def refresh = nil
+        def clear = nil
+        def close = nil
+      end
+    end
+  end
+end

data/lib/everywhere/version.rb

@@ -3,7 +3,7 @@
 require "json"
 
 module Everywhere
-  VERSION = "0.9.1"
+  VERSION = "0.10.0"
 
   # Version of the @rubyeverywhere/bridge JS this gem ships. bridge/ in the
   # gem IS the npm package (served to Rails apps by Everywhere::Engine,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_everywhere
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.10.0
 platform: ruby
 authors:
 - Andrea Fomera
@@ -156,6 +156,7 @@ files:
 - lib/everywhere/desktop_dev_app.rb
 - lib/everywhere/dock.rb
 - lib/everywhere/dock/footer.rb
+- lib/everywhere/dock/info.rb
 - lib/everywhere/dock/screen.rb
 - lib/everywhere/dock/state.rb
 - lib/everywhere/emulator.rb