yamine 0.12.0 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a9a67fc55d6a6514571970b0a4ee40a682878c28b4a2bdf3a140a7a509715c8
-  data.tar.gz: e3332534d4123efbc4fea82c06c0af753866d4ca48db335860e921121baf2e12
+  metadata.gz: 6f7c7127a262069469056cf55f94b5785de8e1890bc0814d84453159e1a01096
+  data.tar.gz: 0001bfbad73772c3caa7e615384a0c70dfa82732987174f55cbfbffac703dd15
 SHA512:
-  metadata.gz: 7306ce065ecb6ff40ee10465f3fffc5108d6786a596c2783194459ec143e42649026f7b14ba170e3bbc9561d14738a613b0da8654ed59a335ba2e54e818a6345
-  data.tar.gz: fb1603c3b379c8067ce51a9aec0baf51a669aec3a9a74002493d9d750e7d224ebb9c8feeb46d786a84f1c0f035d590960e4943feb56e0fb9da7c3c8da1b1b186
+  metadata.gz: 702d9b80482ac8f541f16ab5946b8916b0c23750774e398eabe85cd940a5d39306bdc188e010065e17ecf91081feb79b94d021a24c71186978ba8d1e4ede7dba
+  data.tar.gz: f0f12d6cc5b32bcc46804ef3009a72ab4fac500f792b6d6ea39f05324857031b4cb0f06fe131ef291a61f2faf1d1fd87eb85520d6698b63a6a5b6dde394e637d

data/CHANGELOG.md

@@ -1,5 +1,47 @@
 # Changelog
 
+## [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 +126,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

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/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/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.0"
 end

metadata

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