yamine 0.15.2 → 0.17.0

data/lib/yamine/database.rb

@@ -32,6 +32,17 @@ module Yamine
 
     MAX_IDENTIFIER_BYTES = 63
     STATE_FILE = "databases.json"
+    # The per-worktree environment files yamine writes: `.env` carries
+    # the development set for ANY dotenv-style loader (framework-agnostic),
+    # `.env.test` carries PRIMARY_DATABASE_URL — the key Rails checks
+    # *before* DATABASE_URL for a flat test config, so the test URL wins
+    # no matter which order a loader reads the two files in. Hand-run
+    # commands (`rails console`, `rails test`, `db:migrate`) pick these
+    # up; env injection still covers processes yamine spawns itself.
+    ENV_FILES = %w[.env .env.development .env.test].freeze
+    # 0.16.0's marker file — removed in favor of .env; deleted on sight
+    # so upgraded worktrees don't accumulate dead files.
+    LEGACY_MARKER_FILE = ".yamine-db-suffix"
 
     # Database name for a worktree dir + env (development/test).
     # Main checkout (no worktree marker) keeps the bare name.
@@ -77,7 +88,12 @@ module Yamine
       if map.key?(name) && map[name]["dir"] != dir
         return nil
       end
-      map[name] = { "dir" => dir, "claimed_at" => Time.now.utc.iso8601 }
+      # Merge, don't replace: boot re-claims on every run, and a
+      # multi-database claim's suffix/names/bases are stored under
+      # this key — a fresh hash would erase them and orphan the whole
+      # set on the next drop.
+      map[name] = (map[name] || {}).merge("dir" => dir,
+        "claimed_at" => Time.now.utc.iso8601)
       save_map(state_dir, map)
       name
     rescue SystemCallError
@@ -93,13 +109,134 @@ module Yamine
       {}
     end
 
+    # Claim URLs carry database passwords (the app's own resolved
+    # config, probed at worktree-add time), so the state file is
+    # private — it held no secrets before multi-database claims.
     def save_map(state_dir, map)
       FileUtils.mkdir_p(state_dir)
-      File.write(File.join(state_dir, STATE_FILE), JSON.pretty_generate(map))
+      path = File.join(state_dir, STATE_FILE)
+      File.write(path, JSON.pretty_generate(map))
+      File.chmod(0o600, path)
     rescue SystemCallError
       nil
     end
 
+    # ── multi-database claims ─────────────────────────────────────
+    #
+    # A multi-database claim carries the whole set beside the usual
+    # dir/claimed_at:
+    #   suffix  the token every database name gains — also the marker
+    #           file's contents, the one string yamine and the app's
+    #           database.yml must agree on, byte for byte
+    #   names   config name -> actual database name
+    #   bases   config name -> the app's own URL (server coordinates
+    #           for create/drop; where the suffix gets inserted)
+    # Single-database claims predate this and have none of the three;
+    # every reader falls back to the claim key as the one name.
+
+    # The suffix for a worktree: the claim key minus the env. Base
+    # names already carry the environment (myrr_markdown_development),
+    # so appending "_development" a second time only burns identifier
+    # budget. The claim key keeps the env (and the collision guard);
+    # the suffix is what has to fit inside a database name.
+    def suffix_for(claim_name, env)
+      stripped = claim_name.delete_suffix("_#{env}")
+      stripped.empty? ? claim_name : stripped
+    end
+
+    # Fit the suffix so `base + "_" + suffix` stays within the
+    # identifier cap for ANY base: budget against the longest one.
+    # Fitting happens once, here, because the marker file holds the
+    # suffix and the app only concatenates — a hand-run `rails
+    # console` must arrive at byte-identical names with no truncation
+    # logic of its own. Returns nil when even a hash-shortened suffix
+    # cannot fit (a base name so long no suffix follows it); callers
+    # name the problem instead of guessing.
+    def fit_suffix(suffix, dir, base_databases)
+      longest = base_databases.map { |d| d.to_s.bytesize }.max || 0
+      budget = MAX_IDENTIFIER_BYTES - longest - 1
+      return suffix if budget.positive? && suffix.bytesize <= budget
+      return nil if budget < 8
+
+      keep = budget - 7
+      "#{suffix.byteslice(0, keep).gsub(/_+\z/, "")}_#{short_hash(dir)}"
+    end
+
+    # The actual database name for one base under a suffix. Raises
+    # rather than truncating: silent truncation would diverge from
+    # what the marker file produces inside the app, and yamine names
+    # and app names disagreeing is exactly the bug this prevents.
+    # fit_suffix makes this unreachable for fitted suffixes; the
+    # raise guards programmatic misuse.
+    def multiname(base_database, suffix)
+      name = "#{base_database}_#{suffix}"
+      raise ArgumentError,
+        "database name exceeds #{MAX_IDENTIFIER_BYTES} bytes: #{name}" if name.bytesize > MAX_IDENTIFIER_BYTES
+
+      name
+    end
+
+    # Write the worktree's environment files: `.env` with the whole
+    # development set (dotenv-compatible — any framework or plain Ruby
+    # app that loads .env gets hand-run isolation for free) and
+    # `.env.test` with the test URL under PRIMARY_DATABASE_URL.
+    # Private (URLs carry whatever the app's config carries), and the
+    # 0.16.0 marker file is removed on the way past.
+    def write_env_files(dir, dev_env, test_url: nil)
+      FileUtils.rm_f(File.join(dir, LEGACY_MARKER_FILE))
+      return if dev_env.nil? && test_url.nil?
+
+      unless dev_env.nil? || dev_env.empty?
+        body = dotenv_body(dev_env.reject { |k, _v| k == "PRIMARY_DATABASE_URL" })
+        write_env_file(File.join(dir, ".env"), body)
+        # Same content under the env-specific name: a loader that
+        # prefers .env.development over .env finds identical values.
+        write_env_file(File.join(dir, ".env.development"), body)
+      end
+      return if test_url.nil? || test_url.to_s.empty?
+
+      write_env_file(File.join(dir, ".env.test"),
+        dotenv_body({ "PRIMARY_DATABASE_URL" => test_url }))
+    end
+
+    def write_env_file(path, body)
+      File.write(path, body)
+      File.chmod(0o600, path)
+    end
+
+    # dotenv format: single-quoted values (literal — no interpolation
+    # of a password's `$` or `#`), with the two escapes the dotenv
+    # grammar allows inside them.
+    def dotenv_body(env)
+      header = "# Per-worktree databases, written by yamine (worktree add).\n" \
+              "# Loaded by dotenv-rails / any dotenv loader; removed with this worktree.\n"
+      lines = env.map { |k, v| "#{k}='#{dotenv_escape(v.to_s)}'" }
+      "#{header}#{lines.join("\n")}\n"
+    end
+
+    def dotenv_escape(value)
+      value.gsub("\\") { "\\\\" }.gsub("'") { "\\'" }
+    end
+
+    # Keep files out of `git status` without touching the committed
+    # .gitignore: git's exclude file lives in the shared git dir, so
+    # entries cover every worktree of the repo. Idempotent per line.
+    def exclude_files(dir, names)
+      out, status = Open3.capture2("git", "-C", dir, "rev-parse", "--git-path", "info/exclude")
+      return unless status.success?
+
+      path = out.strip
+      path = File.expand_path(path, dir) unless path.start_with?("/")
+      FileUtils.mkdir_p(File.dirname(path))
+      existing = File.file?(path) ? File.read(path).lines.map(&:strip) : []
+      additions = Array(names).reject { |n| existing.include?(n) }
+      return if additions.empty?
+
+      File.open(path, "a") { |f| additions.each { |n| f.puts n } }
+    rescue SystemCallError, IOError
+      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
@@ -127,6 +264,29 @@ module Yamine
       load_map(state_dir).select { |_, v| !File.directory?(v["dir"]) }
     end
 
+    # The multi-database claim under `key`, or nil — single-database
+    # claims (and foreign keys) simply have no names, and every reader
+    # falls back to the key itself as the one database name.
+    def multi_claim(state_dir, key)
+      info = load_map(state_dir)[key]
+      info if info.is_a?(Hash) && info["names"].is_a?(Hash) && !info["names"].empty?
+    end
+
+    # Every [database_name, server_url] pair a claim stands for: N
+    # pairs for a multi claim, nil for a legacy single claim (caller
+    # falls back to the key + its own template lookup). bases may lag
+    # names on older claims; a missing base falls back to the first —
+    # all of an app's databases live on one server in every layout
+    # yamine has seen.
+    def claim_pairs(info)
+      names = info.is_a?(Hash) ? info["names"] : nil
+      return nil if names.nil? || names.empty?
+
+      bases = info["bases"] || {}
+      default = bases.values.first
+      names.filter_map { |cfg, db| [db, (bases[cfg] || default)] }
+    end
+
     # Adapter detection from DATABASE_URL scheme. Returns :postgres,
     # :mysql, :sqlite, or :unknown. Only postgres/mysql get create +
     # DATABASE_URL treatment; sqlite is left alone (relative paths
@@ -189,7 +349,11 @@ module Yamine
       return :failed unless reachable
 
       uri = URI.parse(database_url)
-      _out, status = Open3.capture2("dropdb", name, env: pg_env(uri))
+      # env as the FIRST positional (like ensure_postgres): Open3
+      # forwards kwargs to spawn, and spawn has no env: option — as a
+      # kwarg this raised ArgumentError on every real drop, crashing
+      # teardown after the routes were already stopped.
+      _out, status = Open3.capture2(pg_env(uri), "dropdb", name)
       return :dropped if status.success?
 
       reachable, exists = pg_state(name, database_url)
@@ -293,9 +457,12 @@ module Yamine
       args
     end
 
+    # PGHOST only when the URL names a host: an empty authority
+    # (postgres:///dbname) means the unix socket, and forcing
+    # 127.0.0.1 there would reach the wrong server — or none.
     def pg_env(uri)
       {
-        "PGHOST" => uri.host || "127.0.0.1",
+        "PGHOST" => (uri.host unless uri.host.to_s.empty?),
         "PGPORT" => (uri.port || 5432).to_s,
         "PGUSER" => URI.decode_www_form_component(uri.user || ENV["USER"].to_s),
         "PGPASSWORD" => uri.password ? URI.decode_www_form_component(uri.password) : nil

data/lib/yamine/probe.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+require "timeout"
+
+module Yamine
+  # What databases an app actually has — asked, never guessed.
+  #
+  # A Rails multi-database app keeps its per-database URLs wherever it
+  # likes (credentials, ENV, hard-coded); yamine must not parse
+  # database.yml or touch decryption keys to learn them. The app
+  # itself answers: `bin/rails runner` prints the resolved
+  # configuration for the environment, so whatever the app would
+  # really connect to is exactly what yamine provisions, names, and
+  # drops. Credentials decrypt inside that process — the probe never
+  # sees a key.
+  #
+  # The runner emits one `YAMINE_DBS=<json>` line; Rails boot noise
+  # shares stdout, so the marker (never the last line) finds the
+  # payload. Any failure — no bin/rails, boot error, timeout — returns
+  # nil: the caller falls back to the single-database path. A probe is
+  # an enhancement, not a requirement, and it must never take a boot
+  # down with it.
+  module Probe
+    module_function
+
+    MARKER = "YAMINE_DBS="
+    TIMEOUT = 90
+
+    # Runs inside the app (bin/rails runner), so configuration_hash is
+    # fully resolved: Rails has already parsed any `url:` into
+    # components and decrypted credentials. The URL is rebuilt here
+    # from those components — a password travels from credentials to
+    # the claim file without yamine ever parsing config itself.
+    # SQLite-family adapters keep their scheme and skip the host part;
+    # relative paths already isolate per-worktree, so they never enter
+    # the multi-database claim.
+    SCRIPT = <<~'RUBY'
+      require "json"
+      require "uri"
+      rows = ActiveRecord::Base.configurations
+        .configs_for(env_name: ENV.fetch("RAILS_ENV", "development"))
+        .map do |c|
+          h = c.configuration_hash
+          db = h[:database].to_s
+          url = h[:url].to_s
+          if url.empty?
+            scheme = { "postgresql" => "postgres", "postgres" => "postgres",
+                       "postgis" => "postgres", "mysql2" => "mysql",
+                       "trilogy" => "mysql" }[h[:adapter].to_s]
+            if scheme
+              info = +""
+              if h[:username]
+                info << URI.encode_www_form_component(h[:username].to_s)
+                if h[:password]
+                  info << ":" << URI.encode_www_form_component(h[:password].to_s)
+                end
+                info << "@"
+              end
+              host = h[:host].to_s
+              authority = host.empty? ? "#{info}" : "#{info}#{host}#{h[:port] ? ":#{h[:port]}" : ""}"
+              url = "#{scheme}://#{authority}/#{db}"
+            else
+              url = "#{h[:adapter]}:#{db}"
+            end
+          end
+          { "name" => c.name, "database" => db, "url" => url,
+            # What DATABASE_URL held INSIDE the app — the discriminator
+            # between "no .env loader ran" (nil) and "loader ran but
+            # database.yml's url: keys took precedence over it".
+            "env_database_url" => ENV["DATABASE_URL"] }
+        end
+      puts "YAMINE_DBS=#{JSON.generate(rows)}"
+    RUBY
+
+    # [{ "name", "database", "url" }, ...] for the environment, or nil
+    # when the app cannot answer (not Rails, boot failure, timeout).
+    def rails_databases(dir, env: nil)
+      env ||= ENV.fetch("RAILS_ENV", "development")
+      bin = File.join(dir, "bin", "rails")
+      return nil unless File.file?(bin)
+
+      out = +""
+      status = nil
+      # A stray DATABASE_URL (or NAME_DATABASE_URL) in the caller's
+      # environment would win over database.yml inside the resolver —
+      # the probe must see the app's own configuration. spawn MERGES
+      # the env hash over the inherited one, so merely omitting the
+      # keys would leave them in place: pass them as nil to unset.
+      scrub = ENV.keys
+        .select { |k| k == "DATABASE_URL" || k.end_with?("_DATABASE_URL") }
+        .to_h { |k| [k, nil] }
+      child_env = scrub.merge("RAILS_ENV" => env)
+      Open3.popen2e(child_env, bin, "runner", SCRIPT, chdir: dir) do |stdin, stdout, wait|
+        stdin.close
+        begin
+          Timeout.timeout(TIMEOUT) { out = stdout.read }
+        rescue Timeout::Error
+          Process.kill("KILL", wait.pid) rescue nil
+          wait.value rescue nil
+          return nil
+        end
+        status = wait.value
+      end
+      return nil unless status&.success?
+
+      parse(out)
+    rescue SystemCallError, IOError
+      nil
+    end
+
+    # The marker line amidst whatever the boot printed. JSON parse
+    # failure returns nil rather than raising: garbage in, "cannot
+    # probe" out.
+    def parse(output)
+      line = output.to_s.lines.find { |l| l.start_with?(MARKER) }
+      return nil unless line
+
+      rows = JSON.parse(line.delete_prefix(MARKER).strip)
+      return nil unless rows.is_a?(Array)
+
+      rows.select { |r| r.is_a?(Hash) && r["name"] && r["url"] && r["database"] }
+        .then { |r| r.empty? ? nil : r }
+    rescue JSON::ParserError
+      nil
+    end
+
+    # The subset that lives on a server (postgres/mysql). SQLite and
+    # friends need no provisioning — their relative paths are already
+    # per-worktree — so they never enter a claim.
+    def server_backed(rows)
+      rows.select { |r| %i[postgres mysql].include?(Yamine::Database.adapter_for(r["url"])) }
+    end
+  end
+end

data/lib/yamine/proxy.rb

@@ -485,7 +485,12 @@ module Yamine
       items = routes.map { |r| "<li>#{escape(r["hostname"])}</li>" }.join
       body = "<h1>No app registered for #{escape(bare)}</h1>" \
              "#{hint}<ul>#{items}</ul>"
-      respond(sock, 404, body)
+      # 503, not 404: 404 says the app answered and has nothing at that path,
+      # and a client that believes it goes looking for a bug in the app. This
+      # is the proxy saying the app is not there — the same answer a dead
+      # backend gets (502 Bad Gateway), so no caller has to read the body to
+      # tell "not running" from "the app said no".
+      respond(sock, 503, body)
     end
 
     def render_bad_gateway(sock)

data/lib/yamine/readiness.rb

@@ -68,7 +68,8 @@ module Yamine
     end
 
     # Pre-flight: verify runtime dependencies before spawning anything.
-    # Ruby (bundle check), Node (node_modules present). Returns [ok, fix].
+    # Ruby (bundle check), Node (node_modules present — but only when the
+    # manifest actually declares dependencies). Returns [ok, fix].
     # Fast-fails with the fix instead of letting Puma crash-loop for 60s.
     def check_deps(dir = Dir.pwd)
       gemfile = File.join(dir, "Gemfile")
@@ -80,7 +81,8 @@ module Yamine
         end
       end
       package = File.join(dir, "package.json")
-      if File.file?(package) && !File.directory?(File.join(dir, "node_modules"))
+      if File.file?(package) && !File.directory?(File.join(dir, "node_modules")) &&
+         package_declares_dependencies?(package)
         return [false, "node_modules missing — run `npm install` in #{dir}"]
       end
       [true, nil]
@@ -88,6 +90,29 @@ module Yamine
       [false, e.message.lines.first&.strip]
     end
 
+    # Does this manifest need an install at all? A stub `{}`
+    # (dependency-less apps keep one so tooling finds a manifest) has
+    # nothing to install — `npm install` creates no node_modules for
+    # it — and demanding the directory would fail every fresh clone
+    # and worktree of such an app forever. An unreadable manifest
+    # keeps the old directory check: honest conservatism.
+    def package_declares_dependencies?(path)
+      data = JSON.parse(File.read(path))
+      return false unless data.is_a?(Hash)
+
+      %w[dependencies devDependencies optionalDependencies peerDependencies workspaces]
+        .any? do |key|
+          value = data[key]
+          if value.is_a?(Hash) || value.is_a?(Array)
+            !value.empty?
+          else
+            !value.nil?
+          end
+        end
+    rescue JSON::ParserError, SystemCallError
+      true
+    end
+
     # Poll an HTTP route until healthy or timeout. Healthy = healthcheck
     # path returns 2xx-3xx, or (no healthcheck) TCP accept on the port.
     # Returns [healthy, detail].

data/lib/yamine/runner.rb

@@ -100,11 +100,11 @@ module Yamine
     # yamine's own keys (PORT, YAMINE_URL, DATABASE_URL, the TLS vars)
     # 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, subdomains: false)
+      rails_dev_host: nil, register: true, database_url: nil, database_env: nil,
+      spec: 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)
+        database_url: database_url, database_env: database_env, extra_env: extra_env)
       path = log_path(dir, name)
       pid = with_clean_env { spawn(env, *command, chdir: dir, out: path, err: [:child, :out]) }
       Process.detach(pid)
@@ -131,9 +131,9 @@ module Yamine
     # Returns the placeholder App (target known before bind). Fate of
     # the backend is decided by wait, not by spawn.
     def spawn_http(name:, hostname:, url:, dir:, command:, port:, rails_dev_host: nil,
-      database_url: nil, force: false, extra_env: nil)
+      database_url: nil, database_env: nil, force: false, extra_env: nil)
       env = child_env(dir, url: url, port: port, rails_dev_host: rails_dev_host,
-        database_url: database_url, extra_env: extra_env)
+        database_url: database_url, database_env: database_env, extra_env: extra_env)
       path = log_path(dir, name)
       pid = with_clean_env { spawn(env, *command, chdir: dir, out: path, err: [:child, :out]) }
       Process.detach(pid)
@@ -158,7 +158,8 @@ module Yamine
       false
     end
 
-    def child_env(dir, url:, port:, rails_dev_host: nil, database_url: nil, extra_env: nil)
+    def child_env(dir, url:, port:, rails_dev_host: nil, database_url: nil,
+      database_env: nil, extra_env: nil)
       # The config's own variables first, so everything below overrides
       # them: PORT, YAMINE_URL, DATABASE_URL, and the TLS paths describe
       # *this boot* and must not be lost to a stray key in local.yml.
@@ -190,10 +191,17 @@ module Yamine
       # proxied hostname so Rails apps boot behind yamine with zero
       # config — this replaces the yamine-rails hosts patch.
       env["RAILS_DEVELOPMENT_HOSTS"] = rails_dev_host if rails_dev_host
-      # Per-worktree database: every process in this worktree shares one
-      # isolated database. Frameworks that honor DATABASE_URL (Rails,
-      # Django, most Node) get isolation for free; others ignore it.
-      env["DATABASE_URL"] = database_url if database_url
+      # Per-worktree databases: the whole isolated set this checkout
+      # claims — DATABASE_URL for primary plus NAME_DATABASE_URL per
+      # extra config (Rails' own convention), so a multi-database app
+      # gets every database redirected, not just the first. Frameworks
+      # that honor DATABASE_URL (Rails, Django, most Node) get
+      # isolation for free; others ignore it.
+      if database_env
+        database_env.each { |k, v| env[k.to_s] = v.to_s if v }
+      elsif database_url
+        env["DATABASE_URL"] = database_url
+      end
       env
     end
 

data/lib/yamine/version.rb

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

data/lib/yamine.rb

@@ -4,6 +4,7 @@ require_relative "yamine/version"
 require_relative "yamine/errors"
 require_relative "yamine/agent"
 require_relative "yamine/database"
+require_relative "yamine/probe"
 require_relative "yamine/sanitize"
 require_relative "yamine/hostname"
 require_relative "yamine/inference"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yamine
 version: !ruby/object:Gem::Version
-  version: 0.15.2
+  version: 0.17.0
 platform: ruby
 authors:
 - Kaka Ruto
@@ -103,6 +103,7 @@ files:
 - lib/yamine/log.rb
 - lib/yamine/ownership.rb
 - lib/yamine/ports.rb
+- lib/yamine/probe.rb
 - lib/yamine/procfile.rb
 - lib/yamine/proxy.rb
 - lib/yamine/proxy_control.rb