yamine 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de59fb684553be7e33ba1a9ea4688bb075a3147ae6225cdc634818c869900163
-  data.tar.gz: 920ac5409e8e0803ed3e3d8ba01663ea03f1543db30e4921585ef6bfdf0d33be
+  metadata.gz: 1fef68ea493be93af6dfb3271b446b793536a373d11b030f62e54c0d90438e88
+  data.tar.gz: 69c64d3bd1523b05ca6277f76329e20415879f16c95cd0640e30c9adf77f69cf
 SHA512:
-  metadata.gz: 8f0cb59209724dd41946c4e0e82c6e2aa01ac9e49575bf461610ed525d98d50fb1566260cf83f7a0b50e19cffd4ab9d6658e372d1c094529e12276e256541161
-  data.tar.gz: 8bb784a546f91a27c5a9b00584fbe14560022d655acd861d5bfdba13db8f187b70913fd129b46b73948068d17c1affca556fd0eb4a67690074d74dbcfdb96214
+  metadata.gz: 2864def84f4afefe2dd79adda834a2381964e964da864f99c8740321c19559669ad48874cce4485222c0a09d5a285b343d99d2fdea5f1029ee54f8dc8cd86a76
+  data.tar.gz: fe58b77da7a315e3f6aa3fd59f7c153fe8a0d342ffdbbdf923e4199e8ccba02b039c2cde777a7c9d1855d127563ef3f021171b308c1696f5f7446b9ac068430e

data/CHANGELOG.md

@@ -1,5 +1,67 @@
 # Changelog
 
+## [0.6.0] — Unreleased
+
+`yamine start --wait` + boot readiness protocol. The remaining gap from
+“one-storey building” onwards: boot had no definitive answer — agents
+polled, guessed from logs, and raced half-booted routes. Now every phase
+(deps, db, schema, per-process health) has a real event and `--wait`
+delivers one call with a pass/fail payload. Credentials-only DB URLs
+warn loudly instead of sharing silently.
+
+### Added
+
+- `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 so a crash fails fast), per-phase
+  timeouts (deps 30s, db 15s, schema 90s, process 45s or per-healthcheck
+  timeout). `Yamine::WaitPayload` success/failure payloads for `--json`.
+- `yamine start --wait [--json]`: spawns every process, polls until
+  healthy, registers routes only on success, kills everything (including
+  background children) and exits 1 with the failed phase + that process's
+  own log tail on failure — no half-booted routes. `--wait` is kept as a no-op alias;
+  `--no-wait` keeps the old sequential fire-and-forget path.
+  `--json` is only meaningful with wait (now default).
+- Per-process `healthcheck: { path: /up, timeout: 30 }` in
+  `config/local.yml`, respected by `--wait`. Absent means TCP accept.
+- Boot phases now visible: deps pre-flight, db (`exists?`/`ensure_exists`
+  split so provenance doesn't need a second probe), schema, per-process.
+  `Runner#spawn_http`/`adopt`/`spawned?` support the concurrent path;
+  `boot_run` child output is logged so failure payloads can tail it.
+
+### Fixed
+
+- Top-level `db: false` opts out of per-worktree databases (exotic
+  setups: manual `establish_connection`, shared staging DB, …). Validated
+  as boolean-or-mapping; `x-` extensions still ignored. `db.schema_load`
+  moves to top-level `db` (per-process ghost `db` entry was a category
+  error). Credentials-stored `DATABASE_URL`s now work when the template is
+  declared in `env.clear` (password via `local.secrets`); when no template
+  exists but the app looks database-backed (`database.yml` adapter or
+  `pg`/`mysql2`/`trilogy` in `Gemfile`) boot warns loudly with the fix
+  instead of silently sharing one database. Framework-agnostic: injection
+  is still `DATABASE_URL`, no `ask-auth` dep, no Rails load at boot.
+
+## [0.5.0] — Unreleased
+
+Per-worktree databases: every worktree directory gets its own database
+so concurrent agents never share tables.
+
+### Added
+
+- `Yamine::Database`: `<sanitized-dir-basename>_<env>` naming
+  (`/code/myapp-fix` → `myapp_fix_development`; main keeps the bare
+  name), 63-byte Postgres cap with hash-suffix truncation, collision
+  guard via state map (silent sharing would be the bug this kills).
+- Boot resolves the DB once, creates it (`createdb`/`mysqladmin`,
+  never raises — warns and shares template on failure), runs the app's
+  schema-load (`db.schema_load` in config, Rails default, else nothing),
+  and injects `DATABASE_URL` into every process. SQLite left alone.
+- `yamine db list|create|drop` and `yamine worktree list|clean`
+  (orphan reaping for deleted worktrees). Branch plays no part —
+  directories are stable, branches hop.
+
 ## [0.3.0] — Unreleased
 
 Renamed from `ask-local` to **`yamine`** (يمين, "right hand" — the local

data/README.md

@@ -91,6 +91,12 @@ processes:
     proxy: false
 ```
 
+Optional top-level `db: false` opts out of per-worktree databases
+(exotic setups — manual `establish_connection`, shared staging DB, …);
+`db.schema_load` overrides the schema-load command. Per-process
+`healthcheck: { path: /up, timeout: 30 }` declares what `--wait` polls
+(TCP accept when absent).
+
 `yamine init` creates the file (migrating an existing Procfile);
 Rails apps need no extra gem — yamine injects `RAILS_DEVELOPMENT_HOSTS`
 so the proxied hostname is allowed automatically. `yamine`
@@ -133,19 +139,21 @@ yamine --tld preview.example.com                # your own domain (OAuth parity)
 ## Commands
 
 ```bash
-yamine                        # infer name, boot app
+yamine                        # boot app (waits until healthy, then supervises)
+yamine start --no-wait        # fire-and-forget (register routes immediately)
+yamine start --json           # machine-readable wait result (--wait default)
 yamine run -- <cmd>           # run explicit command through proxy
-yamine <name> <cmd>           # explicit app name
 yamine get <name>             # print URL for cross-service wiring
 yamine alias <name> <port>    # static route (e.g. Docker)
 yamine list [--json]          # show active routes (+ backend liveness)
 yamine status [--json]        # show effective naming context here
 yamine doctor [--json]        # machine-readable health checks
 yamine open [name]            # open the app URL in a browser
-yamine doctor                 # read-only health check (state, proxy, routes, DNS, CA)
 yamine trust                  # add local CA to system trust store
 yamine clean                  # remove state and hosts entries
 yamine prune                  # remove stale routes
+yamine db list|create|drop    # per-worktree databases
+yamine worktree list|clean    # worktree databases + orphan cleanup
 yamine stop                   # stop this app's backend + routes
 yamine restart                # touch tmp/restart.txt (managed apps reboot)
 yamine log [-f] [n]           # tail (or follow) this app's backend log
@@ -186,12 +194,18 @@ connection (verified end-to-end: RFC 6455 handshake + frame echo).
 
 ## Machine-readable output
 
-`list`, `status`, and `doctor` accept `--json` with stable keys for
+`list`, `status`, `doctor`, and `yamine start --wait` accept `--json` with stable keys for
 agents and scripts (`DevUrl` in ask-ruby-harness consumes the same data
 in-process). Hostnames that fall outside the configured TLDs get a bare
 404 naming nothing — route names never leak to foreign hosts
 (DNS-rebinding boundary).
 
+`yamine start` (default `--wait`) exits 0 only once every HTTP route is healthy
+(healthcheck path when declared, TCP accept otherwise). On failure it
+exits 1 with the failed process, its phase, and the tail of its own log
+— no guessing, no polling, no half-booted routes. `--no-wait` keeps the
+old fire-and-forget path.
+
 ## Log rotation
 
 `proxy.log` and per-app backend logs rotate at 5MB

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

@@ -33,11 +33,13 @@ no extra gem — the proxied hostname is allowed automatically via
 `RAILS_DEVELOPMENT_HOSTS`.
 
 ```bash
-yamine start          # setup if needed, then boot every process
-yamine                # same as start
-yamine stop           # stop this app's backend + routes
-yamine status         # show service, processes, and URLs
-yamine log [-f]       # tail the web process log
+yamine start              # setup if needed, then boot every process (waits until healthy)
+yamine start --no-wait   # fire-and-forget (register routes immediately)
+yamine start --json       # machine-readable wait result (--wait default)
+yamine                    # same as start
+yamine stop               # stop this app's backend + routes
+yamine status             # show service, processes, and URLs
+yamine log [-f]           # tail the web process log
 ```
 
 `$PORT` and `YAMINE_URL` are injected per process; HTTP processes get
@@ -96,6 +98,7 @@ proxy:
 yamine doctor                 # read-only: proxy, routes, DNS, CA trust
 yamine list --json            # routes as stable JSON
 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

data/lib/yamine/cli/boot.rb

@@ -16,7 +16,7 @@ module Yamine
       # boots every process, supervises the tree, cleans up on exit.
       def run_inferred(ctx, args)
         variant = ENV["YAMINE_VARIANT"]
-        opts = ctx.parse_flags(args, %i[variant tld force])
+        opts = ctx.parse_flags(args, %i[variant tld force app_port wait no_wait json])
         resolved = resolve!(ctx, variant: opts[:variant] || variant, tld: opts[:tld])
         # Ownership gate before any side effects: no proxy spawn, no
         # port allocation when we'd refuse anyway.
@@ -43,6 +43,7 @@ module Yamine
         tld = resolved.tld
         host = resolved.host
         processes = resolved.processes
+        events = opts[:events]
 
         if processes.empty?
           $stderr.puts "Error: no processes in config/local.yml. Add at least one."
@@ -55,6 +56,20 @@ module Yamine
           exit 1
         end
 
+        # Pre-flight: verify runtime deps BEFORE spawning anything.
+        # A missing bundle fails here in seconds with the fix, instead
+        # of a 60s Puma crash-loop ending in "did not boot".
+        deps = Readiness.phase(:deps, "check", out: events) do
+          ok, fix = Readiness.check_deps(Dir.pwd)
+          raise fix unless ok
+
+          "dependencies satisfied"
+        end
+        unless deps.status == "ok"
+          $stderr.puts "Error: #{deps.detail}"
+          exit 1
+        end
+
         runner = Runner.new(store: ctx.store)
         children = []
         routes_registered = []
@@ -62,59 +77,182 @@ module Yamine
         puts "yamine (#{service})"
         puts "--"
 
+        # Per-worktree database: one database per directory so concurrent
+        # agents never share tables. Resolved once, injected into every
+        # process as DATABASE_URL, created on demand with the app's own
+        # schema-load command. SQLite needs nothing (relative paths
+        # already isolate); the branch plays no part (dirs are stable,
+        # branches hop).
+        db_name = Database.name_for(Dir.pwd, env: rails_env,
+          state_dir: ctx.store.dir)
+        db_created, db_url = setup_database(ctx, resolved, db_name, events: events)
+        puts "  [db] #{db_name}#{db_created ? " (created)" : ""}" if db_url
+
+        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)
+        else
+          boot_sequential(ctx, runner, resolved, opts, spawn_plan, children,
+            routes_registered, db_url, events: events)
+        end
+
+        background = processes.select { |_, v| v["proxy"] == false }
+        unless background.empty?
+          puts "  [background] #{background.keys.join(', ')}"
+        end
+
+        puts
+        ctx.report_unresolved(routes_registered.flat_map { |r| r[:hostnames] })
+
+        # Supervisor: exit when ANY child dies (loud cleanup).
+        all_pids = routes_registered.map { |r| r[:app].pid } + children.map { |c| c[:pid] }
+        all_hostnames = routes_registered.flat_map { |r| r[:hostnames] }
+        trap_cleanup(ctx, all_hostnames, all_pids)
+        supervise_tree(ctx, all_hostnames, all_pids)
+      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
+      # paths share one rule.
+      def collect_spawns(ctx, runner, resolved, opts, db_url, children)
+        plan = []
+        processes = resolved.processes
         processes.each do |proc_name, entry|
           hostname = Resolver.hostname_for(resolved, proc_name)
           if entry["proxy"] == false
-            boot_background(ctx, runner, resolved, proc_name, entry, opts, children)
+            boot_background(ctx, runner, resolved, proc_name, entry, opts,
+              children, db_url)
             next
           end
           next unless hostname
 
           url = Hostname.url(hostname, port: ctx.proxy_port, tls: ctx.proxy_tls)
-          hostnames = [hostname]
-          puts "  [#{proc_name}] #{url}"
-
-          # Each process cmd runs through the shell so $PORT (and other
-          # env refs) expand — same trust boundary as a Procfile line
-          # (repo code, not user input). Compound lines are refused.
           cmd = entry["cmd"].to_s
           if cmd.match?(Yamine::Procfile::COMPOUND)
             $stderr.puts "  [#{proc_name}] ERROR: compound line (&&, ||, |, ;) — run explicitly: yamine run -- #{cmd}"
             next
           end
-
           port = opts[:app_port] || Ports.find_free
-          shell_cmd = ["sh", "-c", cmd]
+          plan << { name: proc_name, entry: entry, hostname: hostname,
+            hostnames: [hostname], url: url, port: port,
+            command: ["sh", "-c", cmd] }
+        end
+        plan
+      end
+
+      # Default: sequential boot, route registered per process as before.
+      def boot_sequential(ctx, runner, resolved, opts, plan, children,
+        routes_registered, db_url, events: nil)
+        plan.each do |item|
+          puts "  [#{item[:name]}] #{item[:url]}"
           # Always allow the proxied hostname in Rails dev (Rails ignores
           # this env var when not a Rails app — safe for every framework).
-          app = runner.boot_run(name: proc_name, hostname: hostname, url: url,
-            dir: Dir.pwd, command: shell_cmd, port: port, force: opts[:force],
-            rails_dev_host: hostname)
-          register_all(ctx, hostnames, app, force: opts[:force],
-            spec: { "dir" => File.expand_path(Dir.pwd), "proc" => proc_name })
-          routes_registered << { hostnames: hostnames, app: app }
-
-          puts "  -> #{url}"
+          # DATABASE_URL points at this worktree's own database; non-Ruby
+          # frameworks that honor it get isolation for free, others ignore it.
+          # boot_run registers the route + backend sidecar itself
+          # (register: true default); no separate adopt step needed.
+          app = runner.boot_run(name: item[:name], hostname: item[:hostname],
+            url: item[:url], dir: Dir.pwd, command: item[:command],
+            port: item[:port], force: opts[:force],
+            rails_dev_host: item[:hostname], database_url: db_url)
+          routes_registered << { hostnames: item[:hostnames], app: app }
+
+          puts "  -> #{item[:url]}"
         end
+        children
+      end
 
-        background = processes.select { |_, v| v["proxy"] == false }
-        unless background.empty?
-          puts "  [background] #{background.keys.join(', ')}"
+      # --wait: spawn everything first, then poll every port/path until
+      # healthy. No route exists until its backend answers, so half-boots
+      # never leak into the proxy. A backend that dies before its route
+      # registers is cleaned up like any other failed process.
+      def boot_concurrent(ctx, runner, resolved, opts, plan, children,
+        routes_registered, db_url, db_name, db_created)
+        apps = {}
+        plan.each do |item|
+          puts "  [#{item[:name]}] #{item[:url]}"
+          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])
+          }
         end
+        wait_result = Readiness.wait_all(apps, tls: ctx.proxy_tls, out: nil)
+        failed = wait_result.select { |r| r[:status] != "ok" }
+
+        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 })
+            routes_registered << { hostnames: slot[:item][:hostnames], app: slot[:app] }
+            puts "  -> #{slot[:item][:url]}"
+          end
+        end
+        finish_wait(ctx, resolved, apps, wait_result, failed, routes_registered,
+          children, db_name, db_url, db_created, json: opts[:json])
+      end
 
-        puts
-        ctx.report_unresolved(routes_registered.flat_map { |r| r[:hostnames] })
+      # --wait epilogue: on success the summary payload (URLs + per-process
+      # health) goes to stdout and boot continues into supervision. On
+      # failure every spawned child is killed and removed, the failure
+      # payload (failed phase + log tail) prints, and start exits 1 —
+      # no half-booted routes left behind.
+      def finish_wait(ctx, resolved, apps, wait_result, failed, routes_registered,
+        children, db_name, db_url, db_created, json: false)
+        urls = apps.transform_values { |slot| slot[:item][:url] }
+        if failed.empty?
+          puts "ready: #{urls.map { |n, u| "#{n}=#{u}" }.join(" ")}"
+          payload = Yamine::WaitPayload.success(resolved, wait_result, urls: urls,
+            db_name: db_name, db_url: db_url, created: db_created) if json
+          puts JSON.generate(payload) if json
+          return
+        end
 
-        # Supervisor: exit when ANY child dies (loud cleanup).
-        all_pids = routes_registered.map { |r| r[:app].pid } + children.map { |c| c[:pid] }
-        all_hostnames = routes_registered.flat_map { |r| r[:hostnames] }
-        trap_cleanup(ctx, all_hostnames, all_pids)
-        supervise_tree(ctx, all_hostnames, all_pids)
+        apps.each_value { |slot| stop_spawned(slot[:app]) }
+        children.each { |c| stop_spawned_pid(c[:pid]) }
+        first = failed.first
+        payload = Yamine::WaitPayload.failure(resolved, wait_result, failed: first,
+          log_tail: tail_for(failed.first, apps))
+        if json
+          puts JSON.generate(payload)
+        else
+          $stderr.puts "Error: #{first[:name]} failed (#{first[:phase]}): #{first[:detail]}"
+          $stderr.puts payload[:log_tail].to_s.lines.last(10).join if payload[:log_tail]
+          $stderr.puts "Full log: #{payload[:log_path]}" if payload[:log_path]
+        end
+        cleanup_routes(ctx, apps.values.map { |slot| slot[:item][:hostname] })
+        exit 1
+      end
+
+      def tail_for(failure, apps)
+        name = failure[:name]
+        slot = apps[name]
+        path = slot ? File.expand_path(File.join(Dir.pwd, "log", "yamine-#{name}.log")) : nil
+        lines = path && File.file?(path) ? File.readlines(path).last(20).join : "(no log file)"
+        { path: path, tail: lines }
+      rescue SystemCallError
+        { path: path, tail: "(unreadable log)" }
+      end
+
+      def stop_spawned(app)
+        stop_spawned_pid(app.pid)
+      end
+
+      def stop_spawned_pid(pid)
+        Process.kill("TERM", pid)
+      rescue SystemCallError
+        nil
       end
 
       # A background process (proxy: false) is spawned, logged, and
       # supervised exactly like an HTTP one — it just gets no route.
-      def boot_background(ctx, runner, resolved, proc_name, entry, opts, children)
+      def boot_background(ctx, runner, resolved, proc_name, entry, opts, children, db_url)
         cmd = entry["cmd"].to_s
         if cmd.match?(Yamine::Procfile::COMPOUND)
           $stderr.puts "  [#{proc_name}] ERROR: compound line (&&, ||, |, ;) — run explicitly: yamine run -- #{cmd}"
@@ -124,7 +262,8 @@ module Yamine
         url = "background://#{resolved.app}/#{proc_name}"
         app = runner.boot_run(name: proc_name, hostname: "#{resolved.app}.#{proc_name}.internal",
           url: url, dir: Dir.pwd, command: ["sh", "-c", cmd], port: port,
-          force: opts[:force], rails_dev_host: nil, register: false)
+          force: opts[:force], rails_dev_host: nil, register: false,
+          database_url: db_url)
         children << { name: proc_name, pid: app.pid }
         puts "  [#{proc_name}] background (pid #{app.pid})"
       end
@@ -166,6 +305,138 @@ module Yamine
         env
       end
 
+      # Rails env for database naming: RAILS_ENV when set, else development.
+      # Non-Rails apps ignore it (their DATABASE_URL template decides).
+      def rails_env
+        ENV.fetch("RAILS_ENV", "development")
+      end
+
+      # Resolve this worktree's database, create it if missing, and run
+      # the app's schema-load command on first creation. Returns
+      # [created, url]: created is true only when this boot created the
+      # database (so --wait can report provenance without a second
+      # probe), url is nil when there is nothing to inject.
+      #
+      # Template sources: ENV DATABASE_URL, then config env.clear
+      # DATABASE_URL (top-level env, falling back to per-process env
+      # for configs written before top-level env existed). Injected
+      # DATABASE_URL overrides database.yml/credentials at connection
+      # time (ActiveRecord merges env over file config), so credentials
+      # apps work — they just need the template declared in config.
+      def setup_database(ctx, resolved, db_name, events: nil)
+        return [false, nil] if db_opted_out?(resolved)
+
+        template = ENV["DATABASE_URL"] || database_template_from_config(resolved)
+        if template.nil? || template.strip.empty?
+          warn_missing_template(resolved)
+          return [false, nil]
+        end
+
+        url = Database.url_for(db_name, template)
+        return [false, nil] unless url
+
+        db_event = Readiness.phase(:db, "ensure #{db_name}", out: events) do
+          existed = Database.exists?(db_name, template)
+          raise "database server unreachable — is postgres/mysql running?" unless Database.ensure_exists(db_name, template)
+
+          existed ? "already exists" : "created #{db_name}"
+        end
+        unless db_event.status == "ok"
+          $stderr.puts "  [db] WARNING: #{db_event.detail} — processes share the template database."
+          return [false, nil]
+        end
+        created = db_event.detail.to_s.start_with?("created")
+
+        schema_event = Readiness.phase(:schema, "load #{db_name}", out: events) do
+          next "skipped (already exists)" unless created
+
+          run_schema_load(resolved, url)
+        end
+        unless schema_event.status == "ok"
+          $stderr.puts "  [db] WARNING: schema load #{schema_event.status}: #{schema_event.detail}."
+        end
+        [created, url]
+      end
+
+      # Top-level `db: false` opts out of per-worktree databases.
+      # (A `db` process entry still boots as a process — only the
+      # explicit top-level key opts out.)
+      def db_opted_out?(resolved)
+        resolved.db == false
+      end
+
+      # The dangerous case made loud: the app looks database-backed
+      # (server adapter in database.yml, or pg/mysql2 in the Gemfile)
+      # but no template was declared, so every worktree would silently
+      # share one database. Name the fix; do not guess.
+      def warn_missing_template(resolved)
+        return unless database_backed?
+
+        $stderr.puts "  [db] WARNING: app looks database-backed but no DATABASE_URL template found."
+        $stderr.puts "    Each worktree would share one database. Declare the template in config/local.yml:"
+        $stderr.puts "      env:"
+        $stderr.puts "        clear:"
+        $stderr.puts "          DATABASE_URL: postgres://user@localhost:5432/myapp_development"
+        $stderr.puts "    (password via config/local.secrets + env.secret), or opt out with top-level `db: false`."
+      end
+
+      # Heuristics, deliberately conservative: only warn when there is
+      # positive evidence of a server database. SQLite-only and
+      # database-less apps stay silent.
+      def database_backed?
+        database_yml_server? || gemfile_server_adapter?
+      end
+
+      def database_yml_server?(path = File.join(Dir.pwd, "config", "database.yml"))
+        return false unless File.file?(path)
+
+        content = File.read(path)
+        content.match?(/adapter:\s*(postgresql|postgres|postgis|mysql2?|trilogy)/i)
+      rescue SystemCallError
+        false
+      end
+
+      def gemfile_server_adapter?(path = File.join(Dir.pwd, "Gemfile"))
+        return false unless File.file?(path)
+
+        content = File.read(path)
+        content.match?(/gem\s+["'](pg|mysql2|trilogy)["']/)
+      rescue SystemCallError
+        false
+      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"]
+      end
+
+      # Schema-load on first boot uses the app's own command when declared
+      # (top-level db.schema_load in config/local.yml), else a Rails
+      # default when a Rails app is detected, else nothing (frameworks
+      # without a schema concept need no step). Returns a detail string.
+      def run_schema_load(resolved, url)
+        cmd = db_schema_load(resolved) ||
+          ("bin/rails db:schema:load" if rails_app?)
+        return "no schema-load command" unless cmd
+
+        ok = system({ "DATABASE_URL" => url, "RAILS_ENV" => rails_env },
+          "sh", "-c", cmd, chdir: Dir.pwd, out: File::NULL, err: File::NULL)
+        ok ? "loaded schema via #{cmd}" : raise("schema-load exited non-zero: #{cmd}")
+      end
+
+      def db_schema_load(resolved)
+        resolved.db.is_a?(Hash) ? resolved.db["schema_load"] : nil
+      end
+
+      def rails_app?
+        File.file?(File.join(Dir.pwd, "config", "application.rb"))
+      end
+
       def supervise_tree(ctx, hostnames, pids)
         loop do
           sleep 0.5
@@ -218,21 +489,6 @@ module Yamine
         end
       end
 
-      def register_all(ctx, hostnames, app, force:, spec: nil)
-        hostnames[1..].each do |h|
-          ctx.store.add_route(h, app.target, Process.pid, kind: app.kind,
-            force: force, spec: spec)
-          write_backend_sidecar(ctx, h, app.pid)
-        end
-      end
-
-      def write_backend_sidecar(ctx, hostname, pid)
-        ctx.store.ensure_dir
-        File.write(File.join(ctx.store.dir, "backend-#{hostname}.pid"), "#{pid}\n")
-      rescue SystemCallError
-        nil
-      end
-
       def cleanup_routes(ctx, hostnames)
         hostnames.each do |h|
           begin

data/lib/yamine/cli/context.rb

@@ -81,7 +81,7 @@ module Yamine
           elsif arg.start_with?("--")
             key = arg.sub(/\A--/, "").tr("-", "_").to_sym
             if known.include?(key)
-              if %i[branch force].include?(key)
+              if %i[branch force wait no_wait json].include?(key)
                 opts[key] = true
                 i += 1
               else