yamine 0.13.1 → 0.13.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 43ea000326072db8f0173360b3ef58a6cce132e20f372b65f0e777bafbb97e9d
-  data.tar.gz: 3e878d2cae8afffd1dca255a006a5863e12dbd4471a4b6214656dda5bc97d37f
+  metadata.gz: 122503332845c1bbee6034e7262b763d38c2d4c849723e9519dfc7e91f0739b6
+  data.tar.gz: 5ae28759ce2ba01f7c9239056ca49d0ceda6f0958e26a534561fdcab76a485f3
 SHA512:
-  metadata.gz: 272dae53dfac6b0521c09c00ae096cdc10620dcabf8064a286a0fe25813a61738b3fefc4bb34cf8fdfdd8dd1467a0064ec4e8ceb6ec7b262a8ed638b66101bda
-  data.tar.gz: e16540d1830850c50a54451ec5f0bfb0ad87fd770b111a0b4276aad9a6916dadeeed4c106b61392e5fc5794e6276f003f718a5e53135885f36cc142944d1a12f
+  metadata.gz: 35f7dc98e1beaa8fcbf46dc2dbb735656789c193d2ed713e395fc038fa9a7801fcec6ea552c3affc67c82f0a3101b3200eb6126459f0588b723245318e257981
+  data.tar.gz: c3f54ddcc3cb3d0f6b99bca81770fc4addd61cadb22baf176c81042b9609edb079b69f2f41dd265378b08c44eb1a322dc00cffca580496741086750671950007

data/CHANGELOG.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## [0.13.2] — 2026-09-12
+
+### Fixed
+
+- **"Resolves" now means "resolves for every client", not "the system
+  resolver said yes".** `Hosts.resolves?` asked `Addrinfo.getaddrinfo`,
+  which on macOS answers any `.localhost` name unconditionally — so
+  doctor and boot reported every `.localhost` route as fully resolved
+  even with no `/etc/hosts` entry, while a client that resolves only
+  from the hosts file (a CGO-disabled Go binary; AnyGit is the case
+  that found it) could not resolve any of them. That invisible gap is
+  why `sudo yamine hosts sync` existed as a manual step at all.
+
+  The check is now state-based. `Hosts.hosts_entry?` reads the hosts
+  file directly — any loopback mapping counts, hand-added entries
+  included, not just yamine's managed block — and `Hosts.resolution`
+  classifies each route as `ok` (every client resolves it), `warn`
+  (browsers and curl fine via the RFC 6761 `.localhost` special case;
+  file-only resolvers cannot see it), or `fail` (nothing resolves it).
+  Doctor renders the warn class with its existing `[warn]` state instead
+  of a failure — the 0.7.0 lesson, kept by severity and wording rather
+  than by a probe — and boot names the two gaps separately.
+
+  `.localhost` names are classified on file absence alone: the system
+  resolver's unconditional yes carries no information, and acting on it
+  was the bug. getaddrinfo now runs only for custom-TLD names the file
+  does not answer (real DNS or `/etc/resolver` setups stay `ok`), so
+  the common doctor path does no probing at all.
+
 ## [0.13.1] — 2026-09-12
 
 ### Fixed

data/README.md

@@ -122,7 +122,9 @@ destination pattern). Naming a variant also prefixes the hostname — see
 below for how that differs from a worktree's automatic prefix.
 
 `.localhost` resolves to loopback natively in Chrome, Firefox, and Edge —
-no DNS server, no `/etc/resolver`. Safari may need `yamine hosts sync`.
+no DNS server, no `/etc/resolver`. Safari, custom TLDs, and resolvers
+that read only `/etc/hosts` (CGO-disabled Go binaries are the common
+case) need `yamine hosts sync`.
 
 ## Hostname shape
 

data/lib/ask/skills/yamine/SKILL.md

@@ -144,8 +144,10 @@ yamine prune                  # clear stale routes from crashed sessions
 yamine start --json           # boot readiness payload (pass/fail + log tail)
 ```
 
-If a hostname does not resolve: `yamine hosts sync`. If the browser
-warns about TLS: `yamine trust`.
+If a hostname does not resolve — or boot/doctor report it as not in
+`/etc/hosts` and you use clients that read only that file (CGO-disabled
+Go binaries): `yamine hosts sync`. If the browser warns about TLS:
+`yamine trust`.
 
 ## When NOT to use yamine
 

data/lib/yamine/cli/boot.rb

@@ -157,7 +157,7 @@ module Yamine
         end
 
         say opts
-        ctx.report_unresolved(routes_registered.flat_map { |r| r[:hostnames] })
+        ctx.report_resolution_gaps(routes_registered.flat_map { |r| r[:hostnames] })
 
         # Supervisor: exit when ANY child dies (loud cleanup). pid => name
         # so the message names the casualty instead of "a process".

data/lib/yamine/cli/context.rb

@@ -35,11 +35,22 @@ module Yamine
         ProxyControl.proxy_tls(store)
       end
 
-      def report_unresolved(hostnames)
-        missing = Hosts.unresolved(hostnames)
-        return if missing.empty?
+      # Boot-time DNS report. Two distinct gaps, named separately: a fail
+      # resolves nowhere; a warn resolves in browsers and curl (the RFC
+      # 6761 .localhost special case) but not for clients that read only
+      # /etc/hosts — which is exactly the gap `hosts sync` closes.
+      def report_resolution_gaps(hostnames)
+        groups = Hosts.resolution(hostnames)
+        return if groups[:fail].empty? && groups[:warn].empty?
 
-        warn "Warning: #{missing.join(", ")} will not resolve. Run: yamine hosts sync"
+        unless groups[:fail].empty?
+          warn "Warning: #{groups[:fail].join(", ")} will not resolve. Run: yamine hosts sync"
+        end
+        unless groups[:warn].empty?
+          warn "Warning: #{groups[:warn].join(", ")} not in /etc/hosts — browsers and curl " \
+            "resolve them anyway, but clients that only read /etc/hosts (CGO-disabled Go " \
+            "binaries) cannot. Run: yamine hosts sync if you use such clients."
+        end
       end
 
       def wait_for_exit(pid, timeout:)

data/lib/yamine/doctor.rb

@@ -160,12 +160,24 @@ module Yamine
       hostnames = store.load_routes.map { |r| r["hostname"] }
       return Check.new(name: "dns", ok: true, message: "no routes to resolve") if hostnames.empty?
 
-      missing = Hosts.unresolved(hostnames)
-      if missing.empty?
+      groups = Hosts.resolution(hostnames)
+      problems = []
+      problems << "#{groups[:fail].join(", ")} do not resolve — run: yamine hosts sync" unless groups[:fail].empty?
+      unless groups[:warn].empty?
+        problems << "#{groups[:warn].join(", ")} not in /etc/hosts — browsers and curl " \
+          "resolve them anyway, but clients that only read the hosts file " \
+          "(CGO-disabled Go binaries) cannot — run: yamine hosts sync if you use such clients"
+      end
+
+      if problems.empty?
         Check.new(name: "dns", ok: true, message: "all #{hostnames.length} hostname(s) resolve")
+      elsif groups[:fail].empty?
+        # Only the file-only-resolver gap: most clients are fine, so this
+        # is a warn, not a failure — failing here sent browser-only users
+        # to an elevated hosts write they did not need (the 0.7.0 lesson).
+        Check.new(name: "dns", ok: true, warn: true, message: problems.join("; "))
       else
-        Check.new(name: "dns", ok: false,
-          message: "#{missing.join(", ")} do not resolve — run: yamine hosts sync")
+        Check.new(name: "dns", ok: false, message: problems.join("; "))
       end
     end
 

data/lib/yamine/hosts.rb

@@ -4,9 +4,11 @@ require "socket"
 require "timeout"
 
 module Yamine
-  # /etc/hosts sync for Safari + custom TLDs (.localhost resolves natively
-  # in Chrome/Firefox/Edge; Safari uses the system resolver).
-  # Same managed-block approach as portless hosts.ts.
+  # /etc/hosts sync for the client classes that cannot resolve the routes
+  # on their own: custom TLDs, and resolvers that read only the hosts file
+  # (a CGO-disabled Go binary is the common case — no system resolver, no
+  # RFC 6761 special-casing). Same managed-block approach as portless
+  # hosts.ts.
   module Hosts
     BEGIN_MARKER = "# --- yamine begin ---"
     END_MARKER = "# --- yamine end ---"
@@ -44,14 +46,13 @@ module Yamine
     # Bring the managed block to exactly these hostnames. Idempotent: when
     # the block already matches, this is a no-op returning true.
     #
-    # The short-circuit is load-bearing, not an optimization. /etc/hosts is
+    # The sync short-circuit is load-bearing, not an optimization. /etc/hosts is
     # root-owned on a normal machine, so a rewrite fails without sudo — and
     # `setup` and every boot's workstation check run this. Without the
     # guard, a machine whose hosts file was already correct got a
     # "could not write /etc/hosts (try sudo yamine hosts sync)" warning on
     # every run, sending people to an elevated write for a file that
-    # needed nothing. (Chrome/Firefox/Edge resolve *.localhost natively;
-    # /etc/hosts only matters for Safari and custom TLDs.)
+    # needed nothing.
     def sync(hostnames, path = PATH)
       return true if synced?(hostnames, path)
 
@@ -85,26 +86,60 @@ module Yamine
       false
     end
 
-    # Does the hostname resolve for the programs that will actually use
-    # it — browsers, curl, the app's own HTTP clients? That question can
-    # only be answered by the SYSTEM resolver (getaddrinfo), which reads
-    # nsswitch (so /etc/hosts counts) and implements the RFC 6761
-    # special-use TLDs.
+    # Loopback mappings that count as "this name reaches the proxy".
+    LOOPBACK = %w[127.0.0.1 ::1].freeze
+
+    # Does the hosts file map this hostname to loopback? That is the one
+    # resolution source every client shares — browsers and curl, the
+    # system resolver, and resolvers that read only the file (a
+    # CGO-disabled Go binary is the common case). The whole file is
+    # searched, not just the managed block, so a hand-added entry counts;
+    # only loopback mappings count, since the proxy serves on loopback
+    # and any other address points the name away from yamine.
+    def hosts_entry?(hostname, path = PATH)
+      target = hostname.to_s.downcase
+      File.foreach(path) do |line|
+        parts = line.split("#", 2).first.to_s.split
+        next unless parts.length > 1 && LOOPBACK.include?(parts.first.downcase)
+        return true if parts[1..].any? { |name| name.downcase == target }
+      end
+      false
+    rescue SystemCallError
+      false
+    end
+
+    # Where one hostname stands for the clients that will actually use
+    # it — a question with three answers no single resolver probe can
+    # produce:
+    #
+    #   :ok   — every client resolves it: mapped in the hosts file, or
+    #           found by the system resolver without it (real DNS or an
+    #           /etc/resolver entry for a custom TLD).
+    #   :warn — browsers and curl handle it (the RFC 6761 .localhost
+    #           special case), but file-only resolvers cannot see it.
+    #   :fail — nothing resolves it.
     #
-    # Ruby's Resolv is a pure-Ruby DNS client: it never sees /etc/hosts
-    # and knows nothing about RFC 6761, so it reports "no address for
-    # myapp.localhost" on a machine where .localhost resolves perfectly.
-    # That false negative sent users to `sudo yamine hosts sync` — an
-    # elevated write to /etc/hosts — to fix a problem they did not have.
-    def resolves?(hostname)
+    # .localhost names are classified :warn on file absence alone. The
+    # system resolver answers any .localhost unconditionally, so probing
+    # it carries no information — and acting on that probe is how doctor
+    # and boot once reported every .localhost as fully resolved while a
+    # CGO-disabled Go binary could not resolve any of them.
+    def classification(hostname, path = PATH)
+      return :ok if hosts_entry?(hostname, path)
+      return :warn if hostname.to_s.downcase.end_with?(".localhost")
+
       Timeout.timeout(2) { Addrinfo.getaddrinfo(hostname, nil) }
-      true
+      :ok
     rescue SocketError, SystemCallError, Timeout::Error
-      false
+      :fail
     end
 
-    def unresolved(hostnames)
-      hostnames.reject { |h| resolves?(h) }
+    # Partition hostnames into { ok:, warn:, fail: } for the consumers
+    # that report one line per state (doctor, boot).
+    def resolution(hostnames, path = PATH)
+      groups = { ok: [], warn: [], fail: [] }
+      hostnames.each { |h| groups[classification(h, path)] << h }
+      groups
     end
   end
 end

data/lib/yamine/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Yamine
-  VERSION = "0.13.1"
+  VERSION = "0.13.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yamine
 version: !ruby/object:Gem::Version
-  version: 0.13.1
+  version: 0.13.2
 platform: ruby
 authors:
 - Kaka Ruto