yamine 0.10.2 → 0.10.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 06f020588bc63954dd44b5a99b598995ec3e6f562c03756b867d26ff44178af8
-  data.tar.gz: 97f1613f7ad01d1362e4098651048addd3a4a738912c6bd83427e3ea9453ad8d
+  metadata.gz: 073eb6f5386c8500d62348d2093ebc11fa13dc291f6907d11410bcb1b81e09eb
+  data.tar.gz: 9750f59d2dd9cce11832d232d3d1cb11248b31e52545133ab2b998d21bdf9549
 SHA512:
-  metadata.gz: 3f03809157db470e905542751e16d8a6cb6edd6b91a78637f20e85fb5670e6b30e15f717d1bbaed714c70b077a756fe97744bfb27521304606b2d661dea57eab
-  data.tar.gz: 83bb42d5eb49f6ee4007d04fa3e1b13024a46044d1afc7756a126f43384f60cb9c6ca57d7440d77ffcbacd37b9d95b04dbf8eb933bbf1676a10440e4951bdba7
+  metadata.gz: a0cb84ba9b5fccda18721eb0de3bbb05667cffe97caf8882a3d3217d8dbee339319af2c72090f3b5bee41df198b01cc345e2dcb0e74b8ca9af202f2cd688e7ee
+  data.tar.gz: 89f533e131495a41e6e1613e09017b5e3b4d3a834bbaa5507bf2d13bdcb16054fb9320f36585d9b858d4f34c96734b3a5285fe04a0a8e01fac8227689573dfb4

data/CHANGELOG.md

@@ -1,5 +1,77 @@
 # Changelog
 
+## [0.10.4] — 2026-09-11
+
+### Fixed
+
+- **A stale `tmp/pids/server.pid` no longer kills the boot 2s in.** The
+  anywaye incident: an interrupted earlier run left puma alive, Rails
+  refused to start ("A server is already running (pid: N)"), `web` died
+  before its first healthcheck, and the failure line only said "process
+  exited" — the actual reason sat in the log file. Now:
+  - Pre-flight `Readiness.server_pid_conflict` checks the pidfile BEFORE
+    spawning. A live holder is a conflict, not a mystery crash; a dead
+    pid is fine (Rails overwrites it).
+  - When the holder is this app's own leftover puma (`puma ... [app]`),
+    yamine reaps it automatically. Anything else fails with the exact
+    fix (`kill N && rm tmp/pids/server.pid`), or `--force` to take over.
+  - `Readiness.fatal_line` recognizes the common killers (already
+    running, address in use, missing gems, missing database) in the
+    process's own log and puts the real reason in the failure line.
+- **No more orphans on any failure path.** The incident left puma +
+  solid-queue + ask-app-server running for 24 minutes with no routes
+  after the CLI exited. Now `Runner#boot_run` reaps the backend when
+  registration is refused (quota/conflict), `boot_concurrent` tracks
+  every spawned HTTP backend in `children` before adopt, and `boot_all`
+  wraps spawn+boot so a raise mid-boot kills every child and removes
+  every route already registered. Tests pin all three (with `expects`
+  so they cannot pass vacuously).
+
+## [0.10.3] — 2026-09-11
+
+### Added
+
+- **`yamine start` waits by default** (was opt-in `--wait`). Every HTTP
+  process is spawned concurrently, each `healthcheck: { path: /up,
+  timeout: 30 }` or TCP accept is polled, and routes are registered only
+  when all are healthy (`ready:` + `WaitPayload` with `--json`). On
+  failure everything spawned (including background children) is killed and
+  the CLI exits 1 with the failed process's own `log/yamine-<name>.log`
+  tail and no half-booted routes. `--wait` is kept as a no-op alias;
+  `--no-wait` restores the old sequential fire-and-forget path.
+- `Yamine::Readiness` phased events (`phase`/`action`/`status`/
+  `duration_ms`/`detail`), `check_deps` pre-flight, `wait_healthy`
+  (healthcheck path or TCP accept), concurrent `wait_all` (one thread per
+  process, dead-PID short-circuit), per-phase timeouts (deps 30s, db 15s,
+  schema 90s, process 45s or per-healthcheck). `Yamine::WaitPayload`
+  success/failure payloads. `Runner#spawn_http`/`adopt`/`spawned?`, `boot_run`
+  output is logged and `Database.exists?` splits from `ensure_exists` for
+  provenance without a second probe.
+- Top-level `db: false` opts out of per-worktree databases (validated
+  boolean-or-mapping, `x-` extensions still ignored), `db.schema_load`
+  moves to top-level `db`. Template discovery checks `ENV` then top-level
+  `env.clear` then per-process `env.clear`.
+
+### Fixed
+
+- **`yamine --force` (and bare `yamine --wait`/`--no-wait`) no longer hits
+  the "no longer supported" error.** Boot-flag dispatch now routes bare
+  `yamine --flag` to `run_inferred` instead of the legacy single-name
+  path, and `--help`/`--version` are handled before boot. `run_named`
+  now guides `unknown flag \`--flag\`` toward `--help`.
+- **`yamine` no longer wastes a 2s health wait before reporting the
+  ownership conflict.** The conflict you hit (`"anywaye.localhost" is
+  already registered by a running agent "kaka@...` + stale background
+  jobs already spawned) now fails before any spawn, `prune_stale` discards
+  crashed state, and the message distinguishes same-agent-different-dir
+  ("stop the other instance") from foreign agent ("work in your own
+  worktree"). Guidance now says `yamine start --force   (or bare \`yamine
+  --force\`)`.
+- **Credentials-only `DATABASE_URL`s no longer share silently.** When no
+  template exists but `database.yml`/`Gemfile` proves server-backed, boot
+  warns loudly with the `env.clear` + `local.secrets` fix. Injection is
+  still `DATABASE_URL`, no `ask-auth` dep, no Rails load at boot.
+
 ## [0.10.2] — 2026-09-10
 
 ### Added

data/lib/yamine/cli/boot.rb

@@ -46,8 +46,12 @@ module Yamine
       end
 
       def run_named(ctx, name, _args)
-        $stderr.puts "Error: `yamine #{name}` is no longer supported."
-        $stderr.puts "  All processes come from config/local.yml. Run `yamine init` to create one."
+        if name.to_s.start_with?("-")
+          $stderr.puts "Error: unknown flag `#{name}`. Try `yamine --help` or `yamine start --help`."
+        else
+          $stderr.puts "Error: `yamine #{name}` is no longer supported."
+          $stderr.puts "  All processes come from config/local.yml. Run `yamine init` to create one."
+        end
         exit 1
       end
 
@@ -86,6 +90,28 @@ module Yamine
           exit 1
         end
 
+        # Pre-flight: a live tmp/pids/server.pid makes Rails refuse to
+        # boot ("A server is already running") the moment web starts.
+        # When the holder is this app's own puma (`puma ... [app]`), take
+        # over automatically — that is one of ours. Anything else is not
+        # ours to kill: fail with the exact fix before spawning.
+        conflict_ok, conflict_detail, conflict_pid = Readiness.server_pid_conflict(Dir.pwd)
+        unless conflict_ok
+          if own_orphan_puma?(conflict_pid, resolved.app, Dir.pwd)
+            say opts, "  reaping own orphaned server (pid #{conflict_pid})"
+            reap_stale_server(conflict_pid)
+          elsif opts[:force]
+            say opts, "  --force: taking over pid #{conflict_pid}"
+            reap_stale_server(conflict_pid)
+          else
+            $stderr.puts "Error: #{conflict_detail}."
+            $stderr.puts "  Rails will refuse to boot while it runs. Free it first:"
+            $stderr.puts "    kill #{conflict_pid} && rm tmp/pids/server.pid"
+            $stderr.puts "  Or re-run with --force to let yamine take over that pid."
+            exit 1
+          end
+        end
+
         runner = Runner.new(store: ctx.store)
         children = []
         routes_registered = []
@@ -107,12 +133,21 @@ module Yamine
         with_wait = !opts[:no_wait]
         spawn_plan = collect_spawns(ctx, runner, resolved, opts, db_url, children)
 
-        if with_wait
-          boot_concurrent(ctx, runner, resolved, opts, spawn_plan, children,
-            routes_registered, db_url, db_name, db_created, events: events)
-        else
-          boot_sequential(ctx, runner, resolved, opts, spawn_plan, children,
-            routes_registered, db_url, events: events)
+        begin
+          if with_wait
+            boot_concurrent(ctx, runner, resolved, opts, spawn_plan, children,
+              routes_registered, db_url, db_name, db_created, events: events)
+          else
+            boot_sequential(ctx, runner, resolved, opts, spawn_plan, children,
+              routes_registered, db_url, events: events)
+          end
+        rescue StandardError
+          # A raise mid-boot (route conflict, quota, unexpected error)
+          # must never leave half a tree running: reap every child and
+          # every route already registered, then surface the error.
+          children.each { |c| stop_spawned_pid(c[:pid]) }
+          cleanup_routes(ctx, routes_registered.flat_map { |r| r[:hostnames] })
+          raise
         end
 
         background = processes.select { |_, v| v["proxy"] == false }
@@ -133,6 +168,35 @@ module Yamine
         supervise_tree(ctx, all_hostnames, named_pids, reporter: events)
       end
 
+      # TERM the old server and make sure the pidfile no longer names
+      # a live process before we spawn (wait a moment; then remove the
+      # file if the process is still refusing to die, so Rails can boot
+      # over it — the socket it held is already ours to take).
+      def reap_stale_server(pid)
+        Process.kill("TERM", pid)
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 5
+        while Process.clock_gettime(Process::CLOCK_MONOTONIC) < deadline
+          break unless ProxyControl.pid_alive?(pid)
+          sleep 0.2
+        end
+        FileUtils.rm_f(File.join(Dir.pwd, "tmp", "pids", "server.pid"))
+      rescue SystemCallError
+        FileUtils.rm_f(File.join(Dir.pwd, "tmp", "pids", "server.pid"))
+      end
+
+      # Is this pid a leftover backend of THIS app? `puma (tcp://...)
+      # [app]` names the app; we also accept a command containing the
+      # app dir. Only then may we reap it unasked.
+      def own_orphan_puma?(pid, app, dir)
+        _out, status = Open3.capture2("ps", "-p", pid.to_s, "-o", "command=")
+        return false unless status.success?
+
+        cmd = _out.to_s
+        cmd.include?("[#{app}]") || cmd.include?(File.expand_path(dir))
+      rescue SystemCallError
+        false
+      end
+
       # One pass over config: background processes spawn immediately
       # (no route to wait on), HTTP processes become a spawn plan the
       # boot mode executes. Compound-line refusal happens here so both
@@ -194,12 +258,18 @@ module Yamine
         apps = {}
         plan.each do |item|
           say opts, "  [#{item[:name]}] #{item[:url]}"
+          app = runner.spawn_http(name: item[:name], hostname: item[:hostname],
+            url: item[:url], dir: Dir.pwd, command: item[:command],
+            port: item[:port], rails_dev_host: item[:hostname],
+            database_url: db_url, force: opts[:force])
+          # Tracked before registration so any later failure (a raise
+          # during adopt, a crash while another process waits) can
+          # always reap it. Duplicate names in named_pids are harmless.
+          children << { name: item[:name], pid: app.pid }
           apps[item[:name]] = {
             item: item,
-            app: runner.spawn_http(name: item[:name], hostname: item[:hostname],
-              url: item[:url], dir: Dir.pwd, command: item[:command],
-              port: item[:port], rails_dev_host: item[:hostname],
-              database_url: db_url, force: opts[:force])
+            log_path: File.join(Dir.pwd, "log", "yamine-#{item[:name]}.log"),
+            app: app
           }
         end
         wait_result = Readiness.wait_all(apps, sink: events)
@@ -298,20 +368,32 @@ module Yamine
       # Compares our worktree dir (spec.dir) against the owner's: same
       # dir + same agent is a restart, anything else names the owner.
       def check_worktree_ownership!(ctx, resolved, force:)
+        return if force
+
         mine = Agent.name
         here = File.expand_path(Dir.pwd)
+        # Stale pids (agent died, worktree deleted) must not block a restart.
+        ctx.store.prune_stale
         Resolver.hostnames(resolved).each do |hostname|
           entry = ctx.store.find(hostname)
           next unless entry
           next unless entry["pid"] != 0 && ProxyControl.pid_alive?(entry["pid"])
           next if entry["agent"] == mine && entry.dig("spec", "dir") == here
-          next if force
 
           owner = entry["agent"] && !entry["agent"].empty? ? "agent #{entry["agent"].inspect}" : "PID #{entry["pid"]}"
           dir = entry.dig("spec", "dir")
-          $stderr.puts "Error: #{hostname} is live and owned by #{owner}#{dir ? " (#{dir})" : ""}."
-          $stderr.puts "  Work in your own worktree (each branch gets its own URL), or take over explicitly:"
-          $stderr.puts "    yamine start --force"
+          same_agent = entry["agent"] == mine
+          same_dir = entry.dig("spec", "dir") == here
+          if same_agent && !same_dir
+            $stderr.puts "Error: #{hostname} was started from a different directory by the same agent #{mine.inspect}:"
+            $stderr.puts "  running: #{dir || "(unknown)"}"
+            $stderr.puts "  current: #{here}"
+            $stderr.puts "  Stop the other instance first (`yamine stop` there) or take over explicitly:"
+          else
+            $stderr.puts "Error: #{hostname} is live and owned by #{owner}#{dir ? " (#{dir})" : ""}."
+            $stderr.puts "  Work in your own worktree (each branch gets its own URL), or take over explicitly:"
+          end
+          $stderr.puts "    yamine start --force   (or bare `yamine --force`)"
           exit 1
         end
       end

data/lib/yamine/cli.rb

@@ -25,9 +25,21 @@ module Yamine
 
     def run(argv)
       args = argv.dup
-      if args.empty? || (!SUBCOMMANDS.include?(args.first) && !args.first.start_with?("-"))
+      if args.empty?
         return BootCommand.run_inferred(Context.new, args)
       end
+      # --help / --version are handled by `help` below, not by boot.
+      if args.first&.start_with?("-")
+        first = args.first.to_s
+        if %w[--help -h --version -v].include?(first)
+          return help if %w[--help -h].include?(first)
+          return (puts "yamine #{VERSION}"; 0) if %w[--version -v].include?(first)
+        end
+        return BootCommand.run_inferred(Context.new, args)
+      end
+      unless SUBCOMMANDS.include?(args.first)
+        return BootCommand.run_named(Context.new, args.first, args[1..])
+      end
 
       cmd = args.shift
       ctx = Context.new

data/lib/yamine/readiness.rb

@@ -168,8 +168,7 @@ module Yamine
       until Process.clock_gettime(Process::CLOCK_MONOTONIC) > deadline
         unless process_alive?(app.pid)
           ms = elapsed_ms(started)
-          return fail_result(name, started, ms,
-            "process exited before becoming healthy — see log/yamine-#{name}.log", sink)
+          return fail_result(name, started, ms, died_detail(name, slot), sink)
         end
         ok, detail = probe(item[:hostname], item[:port], path: path)
         if ok
@@ -182,13 +181,24 @@ module Yamine
       ms = elapsed_ms(started)
       status = process_alive?(app.pid) ? "timeout" : "fail"
       detail = process_alive?(app.pid) ? "no healthy response within #{timeout}s (#{last_error})" :
-        "process exited before becoming healthy — see log/yamine-#{name}.log"
+        died_detail(name, slot)
       event = Event.new(phase: "process", action: name, status: status,
         duration_ms: ms, detail: detail)
       sink&.event(event)
       { name: name, status: status, phase: "process", detail: detail, duration_ms: ms }
     end
 
+    # Why a process that died before answering died: the recognized
+    # fatal line when there is one, else point at its log.
+    def died_detail(name, slot)
+      reason = fatal_line(slot[:log_path])
+      if reason
+        "process exited: #{reason} (log/yamine-#{name}.log)"
+      else
+        "process exited before becoming healthy — see log/yamine-#{name}.log"
+      end
+    end
+
     def ok_result(name, started, ms, path, sink)
       detail = path ? "healthcheck #{path} returned 2xx-3xx" : "port accepted connection"
       event = Event.new(phase: "process", action: name, status: "ok",
@@ -204,6 +214,53 @@ module Yamine
       { name: name, status: "fail", phase: "process", detail: detail, duration_ms: ms }
     end
 
+    # Rails refuses to boot when tmp/pids/server.pid names a live
+    # process ("A server is already running (pid: N)") — the classic
+    # interrupted-run leftover. Report the exact reason and the fix
+    # BEFORE spawning anything, instead of letting `web` die 2s later.
+    # Returns [ok, detail, pid]; ok is true when there is nothing in the
+    # way (no file, unreadable, or a dead pid — Rails overwrites those).
+    def server_pid_conflict(dir = Dir.pwd)
+      path = File.join(dir, "tmp", "pids", "server.pid")
+      return [true, nil, nil] unless File.file?(path)
+
+      pid = File.read(path).strip.to_i
+      return [true, nil, nil] unless pid.positive? && process_alive?(pid)
+
+      [false, "a Rails server is already running (pid #{pid}, from #{path})", pid]
+    rescue SystemCallError, ArgumentError
+      [true, nil, nil]
+    end
+
+    # Known fatal patterns in a dying backend's log. The log line that
+    # killed the process is more useful than "process exited" — agents
+    # should not have to open the file to learn why.
+    FATAL_PATTERNS = [
+      [/A server is already running \(pid:\s*(\d+)/i,
+        ->(m) { "another server is already running (pid #{m[1]}); stale tmp/pids/server.pid" }],
+      [/Address already in use/i,
+        ->(_m) { "address already in use; another process holds the port" }],
+      [/Bundler::GemNotFound|Could not find .* locally installed gems|run `?bundle install/i,
+        ->(_m) { "gems missing; run `bundle install`" }],
+      [/ActiveRecord::NoDatabaseError|PG::ConnectionBad|database .* does not exist/i,
+        ->(_m) { "database unreachable or missing; check DATABASE_URL / the database server" }]
+    ].freeze
+
+    def fatal_line(path)
+      return nil unless path && File.file?(path)
+
+      lines = File.readlines(path).last(80)
+      FATAL_PATTERNS.each do |pattern, describe|
+        match = lines.reverse.find { |l| l.match?(pattern) }
+        next unless match
+
+        return describe.call(match.match(pattern))
+      end
+      nil
+    rescue SystemCallError
+      nil
+    end
+
     def process_alive?(pid)
       Process.kill(0, pid)
       true

data/lib/yamine/runner.rb

@@ -103,10 +103,17 @@ module Yamine
       Process.detach(pid)
       target = "127.0.0.1:#{port}"
       if register
-        spec ||= { "dir" => File.expand_path(dir), "proc" => name }
-        @store.add_route(hostname, target, Process.pid, kind: "tcp",
-          force: force, spec: spec)
-        write_backend_pid(hostname, pid)
+        begin
+          spec ||= { "dir" => File.expand_path(dir), "proc" => name }
+          @store.add_route(hostname, target, Process.pid, kind: "tcp",
+            force: force, spec: spec)
+          write_backend_pid(hostname, pid)
+        rescue StandardError
+          # Registration refused (quota, conflict): the backend is
+          # already spawned — never leave it running without a route.
+          stop_pid(pid)
+          raise
+        end
       end
       App.new(name: name, hostname: hostname, url: url, pid: pid,
         target: target, kind: "tcp", command: command)

data/lib/yamine/version.rb

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

metadata

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