yamine 0.13.0 → 0.13.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f7c7127a262069469056cf55f94b5785de8e1890bc0814d84453159e1a01096
-  data.tar.gz: 0001bfbad73772c3caa7e615384a0c70dfa82732987174f55cbfbffac703dd15
+  metadata.gz: 122503332845c1bbee6034e7262b763d38c2d4c849723e9519dfc7e91f0739b6
+  data.tar.gz: 5ae28759ce2ba01f7c9239056ca49d0ceda6f0958e26a534561fdcab76a485f3
 SHA512:
-  metadata.gz: 702d9b80482ac8f541f16ab5946b8916b0c23750774e398eabe85cd940a5d39306bdc188e010065e17ecf91081feb79b94d021a24c71186978ba8d1e4ede7dba
-  data.tar.gz: f0f12d6cc5b32bcc46804ef3009a72ab4fac500f792b6d6ea39f05324857031b4cb0f06fe131ef291a61f2faf1d1fd87eb85520d6698b63a6a5b6dde394e637d
+  metadata.gz: 35f7dc98e1beaa8fcbf46dc2dbb735656789c193d2ed713e395fc038fa9a7801fcec6ea552c3affc67c82f0a3101b3200eb6126459f0588b723245318e257981
+  data.tar.gz: c3f54ddcc3cb3d0f6b99bca81770fc4addd61cadb22baf176c81042b9609edb079b69f2f41dd265378b08c44eb1a322dc00cffca580496741086750671950007

data/CHANGELOG.md

@@ -1,5 +1,53 @@
 # 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
+
+- **`worktree clean` no longer reports "could not drop — remove manually"
+  for a database that never existed.** `dropdb` fails on a missing
+  database, and the old code collapsed that into a generic failure. Now
+  `Database.drop` returns an honest three-state outcome — `:dropped`,
+  `:missing` (nothing to drop, not an error), `:failed` (server
+  unreachable or drop refused) — by splitting "server reachable" from
+  "database present". Clean prints each outcome (`dropped N`,
+  `N did not exist — nothing to drop`) plus a summary line, exits 1 only
+  when something really failed, and **keeps the claim of a failed drop**
+  so the next clean can retry it (the old code deleted all claims
+  regardless, losing track of databases it failed to drop).
+- `db drop` and `db create` resolve the DATABASE_URL template the way
+  boot does (ENV, then config env.clear) instead of ENV-only, so they
+  work from a shell without the variable exported.
+
 ## [0.13.0] — 2026-09-11
 
 ### Changed

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".
@@ -546,13 +546,7 @@ module Yamine
       end
 
       def database_template_from_config(resolved)
-        top = resolved.env.is_a?(Hash) ? resolved.env["clear"] : nil
-        from_top = top.is_a?(Hash) ? top["DATABASE_URL"] : nil
-        return from_top if from_top && !from_top.to_s.strip.empty?
-
-        env = resolved.processes.values.map { |e| e["env"] || {} }
-        clear = env.map { |e| e["clear"] || {} }.reduce({}, :merge)
-        clear["DATABASE_URL"]
+        Database.template_for(resolved)
       end
 
       # Schema-load on first boot uses the app's own command when declared

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/cli/system.rb

@@ -893,9 +893,9 @@ module Yamine
         resolved = Resolver.resolve(Dir.pwd)
         name = Database.name_for(Dir.pwd, env: boot_env_name,
           state_dir: ctx.store.dir)
-        template = ENV["DATABASE_URL"]
+        template = drop_template
         unless template && !template.strip.empty?
-          $stderr.puts "Error: set DATABASE_URL (template with host/user; database segment is replaced)."
+          $stderr.puts "Error: no DATABASE_URL template found (ENV or env.clear in config/local.yml)."
           exit 1
         end
         if Database.ensure_exists(name, template)
@@ -917,38 +917,41 @@ module Yamine
           $stderr.puts "Error: worktree #{info["dir"]} still exists. Use --force to drop #{name} anyway."
           exit 1
         end
-        if drop_database(ctx, name)
+        template = drop_template
+        unless template && !template.strip.empty?
+          $stderr.puts "Error: no DATABASE_URL template found (ENV or env.clear in config/local.yml) — cannot reach the server to drop #{name}."
+          exit 1
+        end
+        case Database.drop(name, template)
+        when :dropped
           map.delete(name)
           Database.save_map(ctx.store.dir, map)
           puts "Dropped #{name}."
-        else
-          $stderr.puts "Error: could not drop #{name}."
+        when :missing
+          map.delete(name)
+          Database.save_map(ctx.store.dir, map)
+          puts "#{name} did not exist — nothing to drop (claim removed)."
+        when :failed
+          $stderr.puts "Error: could not drop #{name} — is the database server running? The claim is kept."
           exit 1
         end
       end
 
-      def drop_database(_ctx, name)
-        template = ENV["DATABASE_URL"]
-        return false unless template && !template.strip.empty?
+      # Template for reaching the database server outside of boot:
+      # ENV first, then the app's config (env.clear). Runs from the
+      # main checkout, so the config's own template is the usual source.
+      def drop_template
+        env = ENV["DATABASE_URL"]
+        return env if env && !env.strip.empty?
 
-        case Database.adapter_for(template)
-        when :postgres
-          uri = URI.parse(template)
-          _out, status = Open3.capture2("dropdb", name, env: Database.pg_env(uri))
-          status.success?
-        when :mysql
-          uri = URI.parse(template)
-          args = ["-h", uri.host || "127.0.0.1", "-u",
-                  URI.decode_www_form_component(uri.user || "root")]
-          _out, status = Open3.capture2("mysqladmin", *args, "drop", name, "-f")
-          status.success?
-        else
-          false
-        end
-      rescue SystemCallError
-        false
+        config = Config.load(Dir.pwd)
+        return nil unless config
+
+        Database.template_for(TemplateSource.new(config.env_config, config.processes))
       end
 
+      TemplateSource = Struct.new(:env, :processes)
+
       def boot_env_name
         ENV.fetch("RAILS_ENV", "development")
       end
@@ -974,16 +977,31 @@ module Yamine
             puts "No orphaned worktree databases."
             return
           end
+          template = drop_template
+          unless template && !template.strip.empty?
+            $stderr.puts "Error: no DATABASE_URL template found (ENV or env.clear in config/local.yml) — cannot drop the orphaned databases."
+            exit 1
+          end
+          dropped, missing, failed = [], [], []
           orphaned.each do |name, _info|
-            if drop_database(ctx, name)
-              puts "Dropped orphaned #{name}."
-            else
-              $stderr.puts "Could not drop #{name} — remove manually."
+            case Database.drop(name, template)
+            when :dropped then dropped << name
+            when :missing then missing << name
+            when :failed then failed << name
             end
           end
+          dropped.each { |n| puts "  dropped #{n}" }
+          missing.each { |n| puts "  #{n} did not exist — nothing to drop" }
+          failed.each { |n| warn "  could not drop #{n} — is the server running? Claim kept for a retry." }
+          # Forget only the claims we actually handled; a failed drop
+          # stays recorded so the next clean can retry it.
           map = Database.load_map(ctx.store.dir)
-          orphaned.each_key { |name| map.delete(name) }
+          (dropped + missing).each { |n| map.delete(n) }
           Database.save_map(ctx.store.dir, map)
+          summary = "Cleaned #{orphaned.length} orphaned claim(s): #{dropped.length} dropped, #{missing.length} already gone"
+          summary += ", #{failed.length} failed" if failed.any?
+          puts "#{summary}."
+          exit 1 if failed.any?
         else
           raise Error, "Usage: yamine worktree [list|clean]"
         end

data/lib/yamine/database.rb

@@ -100,6 +100,28 @@ module Yamine
       nil
     end
 
+    # The DATABASE_URL template per-worktree names derive from: ENV
+    # first, then the config's top-level env.clear, then per-process
+    # env.clear (configs written before top-level env existed). Shared
+    # by boot, `db create/drop`, and `worktree clean` so they all agree.
+    # Takes anything responding to .env (resolver Result / Config) —
+    # pass env_config for a bare Config.
+    def template_for(resolved)
+      source = if resolved.respond_to?(:env)
+        resolved.env
+      else
+        resolved.env_config
+      end
+      top = source.is_a?(Hash) ? source["clear"] : nil
+      from_top = top.is_a?(Hash) ? top["DATABASE_URL"] : nil
+      return from_top if from_top && !from_top.to_s.strip.empty?
+
+      processes = resolved.respond_to?(:processes) ? resolved.processes : {}
+      env = processes.values.map { |e| e["env"] || {} }
+      clear = env.map { |e| e["clear"] || {} }.reduce({}, :merge)
+      clear["DATABASE_URL"]
+    end
+
     # Databases whose worktree dirs no longer exist (for `worktree clean`).
     def orphaned(state_dir)
       load_map(state_dir).select { |_, v| !File.directory?(v["dir"]) }
@@ -146,6 +168,73 @@ module Yamine
       end
     end
 
+    # Drop a database with an honest outcome. Returns :dropped,
+    # :missing (the database did not exist — nothing to do, NOT an
+    # error), or :failed (server unreachable, drop refused). The
+    # distinction matters: `worktree clean` used to print "could not
+    # drop — remove manually" for a database that never existed,
+    # sending the user hunting for locks and permissions that were
+    # never the problem.
+    def drop(name, database_url)
+      case adapter_for(database_url)
+      when :postgres then pg_drop(name, database_url)
+      when :mysql then mysql_drop(name, database_url)
+      else :failed
+      end
+    end
+
+    def pg_drop(name, database_url)
+      reachable, exists = pg_state(name, database_url)
+      return :missing if reachable && !exists
+      return :failed unless reachable
+
+      uri = URI.parse(database_url)
+      _out, status = Open3.capture2("dropdb", name, env: pg_env(uri))
+      return :dropped if status.success?
+
+      reachable, exists = pg_state(name, database_url)
+      reachable && exists ? :failed : :dropped
+    rescue SystemCallError
+      :failed
+    end
+
+    def mysql_drop(name, database_url)
+      reachable, exists = mysql_state(name, database_url)
+      return :missing if reachable && !exists
+      return :failed unless reachable
+
+      uri = URI.parse(database_url)
+      _out, status = Open3.capture2("mysqladmin", *mysql_args(uri), "drop", name, "-f")
+      return :dropped if status.success?
+
+      reachable, exists = mysql_state(name, database_url)
+      reachable && exists ? :failed : :dropped
+    rescue SystemCallError
+      :failed
+    end
+
+    # [server_reachable, database_exists] — the split that lets drop
+    # tell "nothing to drop" apart from "could not reach the server".
+    def pg_state(name, database_url)
+      uri = URI.parse(database_url)
+      out, status = Open3.capture2(pg_env(uri), "psql", "-lqt")
+      return [false, false] unless status.success?
+
+      [true, out.split("\n").any? { |l| l.split("|").first.to_s.strip == name }]
+    rescue SystemCallError
+      [false, false]
+    end
+
+    def mysql_state(name, database_url)
+      uri = URI.parse(database_url)
+      out, status = Open3.capture2("mysql", *mysql_args(uri), "-e", "SHOW DATABASES;")
+      return [false, false] unless status.success?
+
+      [true, out.split("\n").include?(name)]
+    rescue SystemCallError
+      [false, false]
+    end
+
     # Create the database if missing. Uses createdb/mysqladmin when
     # available; returns true/false, never raises (boot reports, not dies).
     def ensure_exists(name, database_url)

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.0"
+  VERSION = "0.13.2"
 end

metadata

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