yamine 0.12.0 → 0.13.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a9a67fc55d6a6514571970b0a4ee40a682878c28b4a2bdf3a140a7a509715c8
-  data.tar.gz: e3332534d4123efbc4fea82c06c0af753866d4ca48db335860e921121baf2e12
+  metadata.gz: 43ea000326072db8f0173360b3ef58a6cce132e20f372b65f0e777bafbb97e9d
+  data.tar.gz: 3e878d2cae8afffd1dca255a006a5863e12dbd4471a4b6214656dda5bc97d37f
 SHA512:
-  metadata.gz: 7306ce065ecb6ff40ee10465f3fffc5108d6786a596c2783194459ec143e42649026f7b14ba170e3bbc9561d14738a613b0da8654ed59a335ba2e54e818a6345
-  data.tar.gz: fb1603c3b379c8067ce51a9aec0baf51a669aec3a9a74002493d9d750e7d224ebb9c8feeb46d786a84f1c0f035d590960e4943feb56e0fb9da7c3c8da1b1b186
+  metadata.gz: 272dae53dfac6b0521c09c00ae096cdc10620dcabf8064a286a0fe25813a61738b3fefc4bb34cf8fdfdd8dd1467a0064ec4e8ceb6ec7b262a8ed638b66101bda
+  data.tar.gz: e16540d1830850c50a54451ec5f0bfb0ad87fd770b111a0b4276aad9a6916dadeeed4c106b61392e5fc5794e6276f003f718a5e53135885f36cc142944d1a12f

data/CHANGELOG.md

@@ -1,5 +1,66 @@
 # Changelog
 
+## [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
+
+- **The subdomain fallback is now opt-in: `proxy.subdomains`.** A route
+  used to answer its own subdomains unconditionally, so *any* label under
+  a live app silently resolved to that app. The expensive case is a
+  worktree: once `<branch>.myapp.localhost` became the worktree URL, the
+  same hostname with that worktree **stopped** answered as the main
+  checkout — HTTP 200, a real app, the wrong code, and nothing to
+  distinguish it from the right answer. You had to notice the branch
+  was running to know you were looking at someone else's build.
+
+  Unregistered hostnames now 404 instead, and the page names the parent
+  app and its directory: "`myapp.localhost` is running in `/code/myapp`.
+  If `my-branch.myapp.localhost` is a worktree or branch, start it there
+  (`yamine start`)." The failure states its own fix.
+
+  Opting in is one line per app that genuinely wants it:
+
+  ```yaml
+  proxy:
+    subdomains: true     # this app answers *.myapp.localhost
+  ```
+
+  `yamine alias <name> <port> --wildcard` is the same opt-in for a
+  single ad-hoc route. `yamine status` now reports which mode an app is
+  in, since it changes what an unregistered label resolves to.
+
+  Nothing depended on the ambient behavior: no sibling app config used
+  subdomains, and the only artifact was one test, now the opt-in test.
+  Route files written before this need no migration — the flag is absent
+  unless set, and absent means exact hostname only.
+
+### Fixed
+
+- **`proxy: false` on a process named `web` no longer fails validation.**
+  The EXAMPLE can only name one class per key (`true` → TrueClass), so a
+  literal `false` was compared as falseclass and rejected with the
+  self-contradictory "expected a boolean, got falseclass". Booleans are
+  now checked as booleans.
+
 ## [0.12.0] — 2026-09-11
 
 ### Fixed
@@ -84,10 +145,10 @@
 
 - **Ruby, git, and curl now trust the local CA — so an app can call
   another app at `https://<name>.localhost` with no configuration.** The
-  gap surfaced when anywaye (a Rails app) tried to reach anymark at
-  `https://anymark-directory.localhost`: `certificate verify failed`. The
-  CA was trusted everywhere a human looks (Safari, Chrome, curl) and
-  nowhere a child process looks — only Node was covered, via
+  gap surfaced when anywaye (a Rails app) tried to reach a second
+  checkout of anymark at its `.localhost` URL: `certificate verify
+  failed`. The CA was trusted everywhere a human looks (Safari, Chrome,
+  curl) and nowhere a child process looks — only Node was covered, via
   `NODE_EXTRA_CA_CERTS`.
 
   The naive fix is wrong in a way that shows up much later. `SSL_CERT_FILE`

data/README.md

@@ -91,6 +91,7 @@ of truth for service name, proxy TLD/host, processes, and env:
 service: myapp
 proxy:
   tld: localhost
+  subdomains: false      # opt in to answering *.myapp.localhost
 processes:
   web:
     cmd: bundle exec puma -b tcp://127.0.0.1:$PORT config.ru
@@ -162,10 +163,25 @@ yamine --variant demo                           # -> https://demo.myapp.localhos
 yamine --tld preview.example.com                # your own domain (OAuth parity)
 ```
 
-Because a registered route answers `*.` subdomains of itself, any
-`<label>.myapp.localhost` reaches the main checkout until a worktree
-registers that exact name — at which point the exact route wins and the
-worktree takes over.
+## Subdomains are opt-in
+
+A route answers its exact hostname. `*.myapp.localhost` reaches
+`myapp.localhost` only if that app asked for it:
+
+```yaml
+proxy:
+  subdomains: true     # this app answers its own subdomains
+```
+
+```bash
+yamine alias tenant1 4001 --wildcard   # one route, its subdomains
+```
+
+Off is the useful default. An unregistered label under a live app is far
+more likely to be a worktree whose stack is stopped than a tenant, and
+handing that label to the parent app means HTTP 200 with the wrong code.
+Instead the request 404s and names the parent app, its directory, and how
+to start it. `yamine status` reports which mode an app is in.
 
 ## Commands
 

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

@@ -98,6 +98,17 @@ Only an explicit variant ever looks for an overlay file — a branch name
 that happens to match one on disk is ignored. `yamine status` shows
 `variant:` and `overlay:` separately.
 
+## Subdomains are opt-in
+
+A route answers its exact hostname. `*.myapp.localhost` reaches the app
+only if it asked (`proxy.subdomains: true` in `config/local.yml`, or
+`yamine alias <name> <port> --wildcard` for one route).
+
+So a worktree whose stack is not running gets a 404 that names the parent
+app, its directory, and `yamine start` — not the parent app's code. If
+you hit a `.localhost` URL that loads but looks wrong, check you started
+the worktree you think you did; `yamine status` in it prints the URL.
+
 ## First time on a machine
 
 Run `yamine start` — it does the one-shot CA trust, port 443, and

data/lib/yamine/cli/boot.rb

@@ -243,6 +243,7 @@ module Yamine
             url: item[:url], dir: Dir.pwd, command: item[:command],
             port: item[:port], force: opts[:force],
             rails_dev_host: item[:hostname], database_url: db_url,
+            subdomains: resolved.subdomains,
             extra_env: build_env(resolved, item[:entry], proc_name: item[:name]))
           routes_registered << { hostnames: item[:hostnames], app: app }
 
@@ -281,7 +282,8 @@ module Yamine
         if failed.empty?
           apps.each do |name, slot|
             runner.adopt(slot[:item][:hostname], slot[:app], force: opts[:force],
-              spec: { "dir" => File.expand_path(Dir.pwd), "proc" => name })
+              spec: { "dir" => File.expand_path(Dir.pwd), "proc" => name },
+              subdomains: resolved.subdomains)
             routes_registered << { hostnames: slot[:item][:hostnames], app: slot[:app] }
             say opts, "  -> #{slot[:item][:url]}"
           end
@@ -544,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/routes.rb

@@ -147,14 +147,20 @@ module Yamine
           puts "Removed alias #{hostname}."
           return
         end
-        name, port_or_url = args
-        raise Error, "Usage: yamine alias <name> <port|url>" unless name && port_or_url
+        name, port_or_url = args.reject { |a| a.start_with?("--") }
+        raise Error, "Usage: yamine alias <name> <port|url> [--wildcard]" unless name && port_or_url
 
         hostname = alias_hostname(name)
         target = port_or_url.match?(/\A\d+\z/) ? "127.0.0.1:#{port_or_url}" : port_or_url
         force = args.include?("--force")
-        ctx.store.add_route(hostname, target, 0, kind: "tcp", force: force)
-        puts "#{hostname} -> #{target}"
+        # --wildcard is the per-route escape hatch for the tenant case:
+        # this alias answers its own subdomains. Config `proxy.subdomains`
+        # is the same opt-in for a whole app at boot.
+        wildcard = args.include?("--wildcard")
+        ctx.store.add_route(hostname, target, 0, kind: "tcp", force: force,
+          subdomains: wildcard)
+        suffix = wildcard ? " (and its subdomains)" : ""
+        puts "#{hostname} -> #{target}#{suffix}"
       end
 
       # A name containing dots is treated as a full hostname (any TLD);
@@ -282,6 +288,7 @@ module Yamine
           host: resolved.host, host_source: resolved.sources[:host],
           variant: resolved.variant, variant_source: resolved.sources[:variant],
           overlay: resolved.overlay, overlay_source: resolved.sources[:overlay],
+          subdomains: resolved.subdomains,
           urls: urls,
           processes: resolved.processes.keys,
           framework: Framework.detect(Dir.pwd).to_s
@@ -302,6 +309,9 @@ module Yamine
         # explicit --variant / YAMINE_VARIANT ever sets it, so say so
         # rather than letting the two look like one setting.
         puts "overlay:   #{payload[:overlay] ? "#{payload[:overlay]} (merged)" : "(none)"}"
+        # Off by default; say when it is on, because it changes what an
+        # unregistered label under this app resolves to.
+        puts "subdomains: #{payload[:subdomains] ? "own subdomains resolve here" : "exact hostname only"}"
         puts "processes: #{payload[:processes].join(", ")}"
         puts "urls:"
         urls.each { |u| puts "  #{u}" }

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/config.rb

@@ -51,7 +51,12 @@ module Yamine
       "service" => "myapp",
       "proxy" => {
         "tld" => "localhost",
-        "host" => "myapp.local.example.com"
+        "host" => "myapp.local.example.com",
+        # Opt this app into answering its own subdomains. Off by default:
+        # an unregistered label under a live app is far more likely to be
+        # a stopped worktree than a tenant, and resolving it to the wrong
+        # app is worse than not resolving it.
+        "subdomains" => false
       },
       # db: false opts out of per-worktree databases entirely (exotic
       # setups: manual establish_connection, shared staging DB, ...).
@@ -178,6 +183,14 @@ module Yamine
       data[key]
     end
 
+    # Whether this app answers its own subdomains. Off unless asked: the
+    # ambient fallback used to hand any unregistered label to whichever
+    # app owned the parent name, which reads as the right app running the
+    # wrong code — the worktree case that motivated the opt-in.
+    def subdomains?
+      proxy_config["subdomains"] == true
+    end
+
     private
 
     def load_secrets
@@ -274,6 +287,9 @@ module Yamine
       if value["tld"] && !Sanitize.valid_tld?(value["tld"].downcase)
         raise ConfigError, "#{context}: invalid tld #{value["tld"].inspect}"
       end
+      if value.key?("subdomains") && ![true, false].include?(value["subdomains"])
+        raise ConfigError, "#{context}: subdomains must be a boolean"
+      end
     end
 
     def validate_db(value, context)
@@ -364,13 +380,28 @@ module Yamine
         elsif example_value.is_a?(Array) && value.is_a?(Array)
           validate_array_of!(value, example_value.first.class) unless example_value.empty?
         elsif !example_value.nil?
-          expected = type_description(example_value.class)
-          unless value.is_a?(example_value.class) || (example_value.is_a?(String) && value.is_a?(String))
-            raise ConfigError, "#{current_context}: expected #{expected}, got #{value.class.name.downcase}"
+          # Booleans are one type, but the example can only name one class
+          # (TrueClass for `true`), so a literal `false` compared as
+          # falseclass and was rejected: `proxy: false` on a process
+          # raised "expected a boolean, got falseclass". Ask the value
+          # what it is instead of the example.
+          if boolean?(example_value)
+            unless boolean?(value)
+              raise ConfigError, "#{current_context}: expected a boolean, got #{value.class.name.downcase}"
+            end
+          else
+            expected = type_description(example_value.class)
+            unless value.is_a?(example_value.class) || (example_value.is_a?(String) && value.is_a?(String))
+              raise ConfigError, "#{current_context}: expected #{expected}, got #{value.class.name.downcase}"
+            end
           end
         end
       end
 
+      def boolean?(value)
+        value == true || value == false
+      end
+
       def validate_array_of!(array, type)
         array.each_with_index do |value, index|
           with_context(index) do

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/proxy.rb

@@ -106,6 +106,17 @@ module Yamine
     end
 
     # Pure request-routing core, tested without sockets.
+    #
+    # Exact hostname first, then an opted-in wildcard. The wildcard is
+    # deliberately not ambient: a route only answers its own subdomains
+    # when it registered with `subdomains: true` (config
+    # `proxy.subdomains`, or `yamine alias --wildcard`).
+    #
+    # It used to be unconditional, which meant every unregistered label
+    # under any live app silently resolved to that app. The expensive
+    # case is a worktree: `<branch>.myapp.localhost` answered as the main
+    # checkout — a wrong-but-working app, indistinguishable from the
+    # right one. An unregistered hostname now 404s, and says so.
     def route(authority, routes)
       host = Hostname.strip_port(authority)
       return nil if host.empty? || host.bytesize > MAX_HOSTNAME_BYTES
@@ -113,8 +124,7 @@ module Yamine
       exact = routes.find { |r| r["hostname"] == host }
       return exact if exact
 
-      wildcard = routes.find { |r| host.end_with?(".#{r["hostname"]}") }
-      wildcard
+      routes.find { |r| r["subdomains"] && host.end_with?(".#{r["hostname"]}") }
     end
 
     def check_hops(headers)
@@ -452,9 +462,23 @@ module Yamine
         return respond(sock, 404, "<h1>Not Found</h1>")
       end
 
+      # A label in front of a live app is almost always a worktree or a
+      # branch whose stack is not running. Name the parent it would fall
+      # under and where it lives, so "the app loaded but it's the wrong
+      # code" becomes "that worktree isn't running" without a search.
+      parent = routes.find { |r| bare.end_with?(".#{r["hostname"]}") }
+      hint = if parent
+        dir = parent.dig("spec", "dir")
+        where = dir ? " in #{escape(dir)}" : ""
+        "<p><strong>#{escape(parent["hostname"])}</strong> is running#{where}.</p>" \
+          "<p>If #{escape(bare)} is a worktree or branch, start it there " \
+          "(<code>yamine start</code>), or open " \
+          "<strong>#{escape(parent["hostname"])}</strong> instead.</p>"
+      end
+
       items = routes.map { |r| "<li>#{escape(r["hostname"])}</li>" }.join
       body = "<h1>No app registered for #{escape(bare)}</h1>" \
-             "<ul>#{items}</ul>"
+             "#{hint}<ul>#{items}</ul>"
       respond(sock, 404, body)
     end
 

data/lib/yamine/resolver.rb

@@ -9,7 +9,7 @@ module Yamine
     module_function
 
     Result = Struct.new(:app, :tld, :host, :processes, :secrets,
-      :sources, :variant, :overlay, :db, :env, keyword_init: true)
+      :sources, :variant, :overlay, :subdomains, :db, :env, keyword_init: true)
 
     # Two axes, and keeping them apart is the whole point:
     #
@@ -69,6 +69,7 @@ module Yamine
         sources: sources,
         variant: variant_name,
         overlay: overlay,
+        subdomains: config.subdomains?,
         db: config.data["db"],
         env: config.env_config
       )

data/lib/yamine/route_store.rb

@@ -76,7 +76,12 @@ module Yamine
     # `agent` records the owner (defaults to Agent.name); foreign-owned
     # live routes can only be taken with force: true, and the conflict
     # error names the other agent plus its worktree dir.
-    def add_route(hostname, target, pid, kind:, force: false, spec: nil, agent: nil)
+    #
+    # `subdomains` opts this route into answering its own subdomains.
+    # Absent (the default, and what every pre-existing route file has)
+    # means exact hostname only — see Proxy#route for why.
+    def add_route(hostname, target, pid, kind:, force: false, spec: nil, agent: nil,
+      subdomains: false)
       agent ||= Agent.name
       killed = nil
       with_lock do
@@ -101,6 +106,7 @@ module Yamine
         entry = { "hostname" => hostname, "target" => target, "kind" => kind,
                   "pid" => pid, "agent" => agent }
         entry["spec"] = spec if spec
+        entry["subdomains"] = true if subdomains
         routes << entry
         save_routes(routes)
       end

data/lib/yamine/runner.rb

@@ -99,7 +99,7 @@ module Yamine
     # win over it, because those describe the boot rather than the app.
     def boot_run(name:, hostname:, url:, dir:, command:, port: nil, force: false,
       rails_dev_host: nil, register: true, database_url: nil, spec: nil,
-      extra_env: nil)
+      extra_env: nil, subdomains: false)
       port ||= Ports.find_free
       env = child_env(dir, url: url, port: port, rails_dev_host: rails_dev_host,
         database_url: database_url, extra_env: extra_env)
@@ -111,7 +111,7 @@ module Yamine
         begin
           spec ||= { "dir" => File.expand_path(dir), "proc" => name }
           @store.add_route(hostname, target, Process.pid, kind: "tcp",
-            force: force, spec: spec)
+            force: force, spec: spec, subdomains: subdomains)
           write_backend_pid(hostname, pid)
         rescue StandardError
           # Registration refused (quota, conflict): the backend is
@@ -140,9 +140,9 @@ module Yamine
     end
 
     # Register an already-spawned backend: route + sidecar, together.
-    def adopt(hostname, app, force: false, spec: nil)
+    def adopt(hostname, app, force: false, spec: nil, subdomains: false)
       @store.add_route(hostname, app.target, Process.pid, kind: app.kind,
-        force: force, spec: spec)
+        force: force, spec: spec, subdomains: subdomains)
       write_backend_pid(hostname, app.pid)
       nil
     end

data/lib/yamine/version.rb

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

metadata

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