yamine 0.15.1 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb9ab4ec4d7e32278f307f3ebb9366b2a23ef7ec5b65016e6888c240ee90d951
-  data.tar.gz: 13f8a0d5340f03de8132101f5eb996b533aaf9b60a96b21bfbdddc6839ae4641
+  metadata.gz: 66abd82532420b13b18597a4d71b51485f06b09c14d5b0d4c3e777d8056e7145
+  data.tar.gz: be3bcb4b88ba0eeb444ed33d10c14c217cf145073f2f8cce78e62e4dc138bffd
 SHA512:
-  metadata.gz: 10b5b826f5cd2c007e181feaf9f671e0b654a80b13f922c3251d72912987ecd294fa3cdc1d17fa7e5f58dbed22aab8961598844b711c896301e4cb7b46a59399
-  data.tar.gz: cb4962d0c9db1711963bbee31b59f3ca062613562714dfeebed81cdff5c896caf0fb3cdc16296e5245db0885da8debf03b6a1ec9b527e98bb79c3b5e4e46ff08
+  metadata.gz: e03ba4c4510f03424190fdf58f0c5f6db6183425b75c31628df99724bf592edc068ab13cd6bf7abd28b04c577025b4ec913eb87d892b78524aab7aee35e83dbd
+  data.tar.gz: 9eaa287f5ee45e231cd82f29c8dbf0bf0f3e197cc825dfeccccb4f39ff02c826167d32516c23fef7c2a39804d662a69b417e082b1b9d2e6f1b562ce63597a95e

data/CHANGELOG.md

@@ -1,5 +1,90 @@
 # Changelog
 
+## [Unreleased]
+
+## [0.16.0] — 2026-09-23
+
+### Added
+
+- **Multi-database worktrees — the whole set, asked not guessed.**
+  `worktree add` now probes the app itself (`bin/rails runner` resolves
+  database.yml + credentials inside the app process; yamine never parses
+  config or touches a key) and provisions every database it declares:
+  each name gains a collision-guarded per-worktree suffix, the claim
+  records all names plus the server coordinates, schemas load once, and
+  `remove`/`clean` drop the entire set as a unit — orphaned worktrees
+  drop from the claim alone, without the app even booting. Boot injects
+  `DATABASE_URL` plus `NAME_DATABASE_URL` per configuration (Rails' own
+  convention), so supervised processes are isolated even in apps that
+  never heard of yamine. New surface: `yamine db describe` prints what
+  the app actually resolves (passwords masked), `db list` and
+  `worktree list` show every database under a claim, and `db create`
+  re-probes — run it after the app grows a database to self-heal every
+  worktree.
+- **`.yamine-db-suffix` — hand-run commands isolate too.** `add` writes
+  a token file (git-excluded automatically); a four-line suffix hook at
+  the top of `config/local.yml`'s sibling `database.yml` (see README)
+  makes a hand-run `rails console`, `rails test`, or `db:migrate` in
+  the worktree resolve to the worktree's databases — env injection only
+  ever reaches processes yamine spawns. Conformance is proven at
+  creation ("database.yml reads .yamine-db-suffix"); an app without the
+  hook still gets fully isolated boots via env, and gets told exactly
+  what the gap is at that moment.
+- **The test database joins the claim.** It is probed and suffixed like
+  the rest, schema-prepared on first creation (`db:test:prepare` — Rails
+  will not load schema into an empty test database by itself), and
+  dropped at teardown — a fresh worktree runs `rails test` as-is, and
+  no suffixed test database is ever left behind.
+- **Credential keys travel to worktrees.** `add` now copies
+  `config/master.key` and `config/credentials/*.key` (mode 0600) with
+  the rest of the per-checkout config — a credentials app could not
+  even boot in a fresh worktree before, let alone resolve its
+  databases.
+
+### Changed
+
+- **The main checkout of a Rails app boots in silence.** The
+  "app looks database-backed but no DATABASE_URL template found"
+  warning no longer fires on a main checkout — the app's own databases
+  ARE its databases; isolation is a worktree concern, and worktrees
+  get it from the probe.
+- **`clean` no longer gets stuck forever on unresolvable legacy
+  claims.** A pre-multi-database claim whose app declares no template
+  (credentials apps never did) could never be resolved by any future
+  command, so every `worktree clean` anywhere failed on it until it was
+  removed by hand. Such claims are now forgotten with a warning that
+  names the database, so a real leftover stays droppable by hand while
+  `clean` moves on.
+- The claims file (`databases.json`) is written mode 0600 —
+  multi-database claims carry the app's resolved connection URLs.
+
+### Fixed
+
+- **Every real Postgres drop has always crashed.** `pg_drop` passed
+  the environment as a keyword to `Open3.capture2` (spawn takes it
+  positionally), so the moment a `dropdb` was actually attempted —
+  `worktree remove`, `worktree clean`, any teardown against a reachable
+  server — it raised `ArgumentError` mid-teardown, after routes were
+  already stopped. Unit tests never saw it (an unreachable server
+  returns before the spawn). Drops now run, verified against a real
+  five-database app end to end.
+- **Boots of dependency-less Node stubs failed forever.** A committed
+  `package.json` with no dependencies (`{}`) demanded a `node_modules`
+  directory that `npm install` itself will never create — every fresh
+  clone and worktree of such an app failed its pre-flight. The check
+  now fires only when the manifest actually declares dependencies (an
+  unparseable manifest keeps the old conservative behavior).
+- **A hostname with no route answers 503, not 404.** The proxy was
+  answering 404 for "no app registered for this hostname" — the same status
+  an app gives for a path it does not have. A machine client (a health
+  check, an API client, an agent) that trusts the status concluded the app
+  had answered and went looking for a bug in the app's routes, when the app
+  was not running at all. It now answers 503 Service Unavailable with the
+  same helpful page (parent app, its directory, `yamine start`), so the
+  status alone says the app is not there — matching the 502 a registered
+  route with a dead backend already gets. Foreign hosts keep their bare 404
+  that names nothing.
+
 ## [0.15.1] — 2026-09-22
 
 ### Fixed

data/README.md

@@ -170,9 +170,11 @@ yamine worktree clean                # tear down everything already merged
 ```
 
 `add` lands the worktree beside the repo, copies the gitignored
-per-checkout config (`config/local.yml`, `config/local.secrets`) the
-branch needs, runs `bundle install`, and pre-creates the per-worktree
-database with schema — the next step is just `yamine start` in it.
+per-checkout config (`config/local.yml`, `config/local.secrets`,
+`config/master.key`, `config/credentials/*.key`) the branch needs, runs
+`bundle install`, asks the app what databases it has, and provisions
+the whole set with schema — the next step is just `yamine start` in
+it.
 
 `clean` is the done-and-merged sweep: it tears down every worktree
 whose branch is merged (stop, drop database, remove worktree, delete
@@ -190,6 +192,76 @@ yamine --variant demo                           # -> https://demo.myapp.localhos
 yamine --tld preview.example.com                # your own domain (OAuth parity)
 ```
 
+### Multi-database apps
+
+A Rails multi-database app (five databases is normal: primary, cache,
+queue, cable, errors) gets **the whole set** per worktree — asked, not
+guessed. `worktree add` boots `bin/rails runner` once inside the app so
+database.yml and credentials resolve exactly as the app would resolve
+them (yamine never parses config or touches a key), suffixes every
+database name with a collision-guarded per-worktree token, creates and
+schema-loads them, and records names plus server coordinates in the
+claim. Boot injects `DATABASE_URL` and one `NAME_DATABASE_URL` per
+configuration (Rails' own convention), so supervised processes are
+isolated even in an app that never heard of yamine. `remove`/`clean`
+drop the entire set as a unit — including from an orphaned claim whose
+directory is already gone, without the app booting.
+
+```bash
+yamine db describe          # what THIS checkout resolves to (passwords masked)
+yamine db list              # every claim, every database under it
+yamine db create            # re-probe + provision (run after the app grows a database)
+```
+
+**Hand-run commands.** Env injection only reaches processes yamine
+spawns; a `rails console`, `rails test`, or `db:migrate` you run by
+hand reads the environment you gave it. For those, opt the app in with
+the suffix hook — a one-time addition at the top of
+`config/database.yml`:
+
+```erb
+<%
+  yamine_suffix = begin
+    f = Rails.root.join(".yamine-db-suffix")
+    f.exist? ? f.read.strip : ""
+  rescue StandardError
+    ""
+  end
+  yamine_db_url = lambda do |url|
+    next url if yamine_suffix.empty? || url.nil? || url.to_s.empty?
+    require "uri"
+    begin
+      uri = URI.parse(url.to_s)
+      uri.path = "#{uri.path}_#{yamine_suffix}" if uri.path && uri.path != "/"
+      uri.to_s
+    rescue URI::InvalidURIError
+      url
+    end
+  end
+%>
+```
+
+Then wrap each database URL (and a bare test database name) with it:
+
+```yaml
+development:
+  primary:
+    url: <%= yamine_db_url.call(Rails.application.credentials.dig(:database, :primary, :url)) %>
+test:
+  database: <%= ENV.fetch("TEST_DATABASE_NAME") { "myapp_test#{yamine_suffix.empty? ? "" : "_#{yamine_suffix}"}" } %>
+```
+
+`worktree add` writes the `.yamine-db-suffix` token (git-excluded
+automatically) and then *proves* the hook works — you'll see
+`database.yml reads .yamine-db-suffix — hand-run commands are isolated
+too`. Without the hook, supervised boots are still fully isolated via
+env; `add` says exactly what the hand-run gap is. The test database is
+part of the claim too: created and schema-prepared on first add (so
+`rails test` runs as-is), dropped at teardown — never left behind.
+
+The main checkout has no marker file, so nothing changes there: its
+databases are its databases.
+
 ## Subdomains are opt-in
 
 A route answers its exact hostname. `*.myapp.localhost` reaches
@@ -207,8 +279,9 @@ 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.
+Instead the request fails with 503 and names the parent app, its directory,
+and how to start it — the app is not there, which is not the same statement
+as the app answering 404. `yamine status` reports which mode an app is in.
 
 ## Commands
 
@@ -225,7 +298,7 @@ yamine open [name]            # open the app URL in a browser
 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 db list|create|drop|describe    # per-worktree databases (multi-database aware)
 yamine worktree list|add|remove|clean   # worktree lifecycle
 yamine stop                   # stop this app's backend + routes
 yamine restart                # touch tmp/restart.txt (managed apps reboot)

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

@@ -108,26 +108,47 @@ yamine worktree clean [--dry-run]
 ```
 
 `add` creates the git worktree beside the repo, copies the gitignored
-per-checkout config (`config/local.yml`, `config/local.secrets`), runs
-`bundle install`, and pre-creates the per-worktree database — then boot
-with `yamine start` inside it. `clean` tears down every worktree whose
-branch is merged (stops backends, drops the database, removes the
-worktree, deletes the branch) and forgets claims of directories that
-vanished. It never touches uncommitted work; unmerged branches survive
+per-checkout config (`config/local.yml`, `config/local.secrets`,
+credential keys), runs `bundle install`, **asks the app what databases
+it has** (one `bin/rails runner` probe — database.yml and credentials
+resolve inside the app; yamine never parses them), and provisions the
+whole set with schema — every database of a multi-database app gets a
+per-worktree suffix, the test database included and schema-prepared, so
+`rails test` runs as-is. Then boot with `yamine start` inside it.
+`remove` and `clean` drop the entire set as a unit — including from an
+orphaned claim whose directory is gone, without booting the app — and
+`clean` never touches uncommitted work; unmerged branches survive
 everything except `remove --force`. Prefer `clean --dry-run` first, and
-`clean` over `rm -rf` — a removed worktree leaves no routes, database,
+`clean` over `rm -rf` — a removed worktree leaves no routes, databases,
 or stale hosts entries behind.
 
+`yamine db describe` shows what the current checkout resolves to
+(passwords masked); `yamine db list` shows every database under every
+claim; `yamine db create` re-probes and self-heals (run it in each
+worktree after the app grows a database).
+
+Supervised boots are isolated via injected `DATABASE_URL` /
+`NAME_DATABASE_URL` env vars. **Hand-run commands are not** — unless
+the app carries the `.yamine-db-suffix` hook from the yamine README at
+the top of `config/database.yml`. `worktree add` writes that token
+file and prints `database.yml reads .yamine-db-suffix` when the hook
+is in place; if instead you see a warning that database.yml does not
+read it, hand-run `rails console` / `rails test` / `db:migrate` in
+that worktree would use the main checkout's databases — add the hook
+from the README, then `yamine db create`.
+
 ## 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.
+So a worktree whose stack is not running gets a 503 that names the parent
+app, its directory, and `yamine start` — not the parent app's code. The
+status says the app is not there, so a script can tell "not running" from
+"the app answered 404". 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