yamine 0.17.0 → 0.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3987eef1f0bc39291b8d264fd4b569fcb54106c23e78150594f62d86ca2d0351
-  data.tar.gz: e98404e9655e78861c289cb320bf544564e07e65e06fe32a496d5a3ff4ee52b9
+  metadata.gz: 43b8c059b0635ce4272b806fd2b8f70ae42ed6d591ed87536de9c86ed0419864
+  data.tar.gz: c34fb3a40d5c16442accee4dcbdb32b1b2b5013de5c3a823bade745b6ac65e88
 SHA512:
-  metadata.gz: 20018aea0d2229ab0c6c814d15deaeb176649fcdaa81937eb2c6f223607e50f2c34256ed078aca6ef0bb0a114cbd865bd6187dd2f74a1b981d2dbd7c8d7e141d
-  data.tar.gz: 808f2b4151de99fa3fe71ba8bbbfce6eb7dbe63298bea1da3c4fd05a5baea9da7f5d797ae792057f8ddd2f5500b19da47fd97af1641481764eb8f051605a0c0f
+  metadata.gz: 70495a26f226c3b0dac853c5a4ce1694207f4a9bbb73af92b44b37cc17ff3c13430af7440252102b8acd40f22ee7efdae5dfec26155678a5839e30b10c5c0d1a
+  data.tar.gz: e450abc81d00dad86bf03e540304ad43683e99329a60eb24ddea0122760048c88729e7fe33c9b93056a1840ec871e488ea458d1afdbd655b0dccd477369b8cb5

data/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 ## [Unreleased]
 
+## [0.18.0] — 2026-09-23
+
+### Changed
+
+- **Only environment-scoped env files — never plain `.env`.**
+  `worktree add` writes `.env.development` + `.env.test`; the plain
+  `.env` it also wrote in 0.17.0 is gone. Plain `.env` is the file
+  production-style tooling reads by name — kamal, docker
+  `--env-file`, and dotenv itself loads `.env` in *every* environment
+  — so a worktree's copy could leak development database URLs into a
+  production boot that happened to run from that directory.
+  `.env.development` / `.env.test` are invisible to a production boot
+  by construction. A yamine-authored `.env` from 0.17.0 is cleaned up
+  on sight (header-marked); a foreign `.env` — app-committed or
+  hand-written — is never touched.
+- **Env-file writes upsert instead of overwrite.** yamine's keys are
+  (re)written; every other line in the file survives, so a committed
+  env file's config or a developer's copied-in API keys are no longer
+  destroyed by `yamine db create`. The yamine header stays
+  idempotent across re-runs.
+
+
 ## [0.17.0] — 2026-09-23
 
 ### Added

data/README.md

@@ -253,13 +253,20 @@ yamine db create            # re-probe + provision (run after the app grows a da
    (any dotenv loader works). That is what reads the files
    `worktree add` writes into the worktree:
 
-   - `.env` / `.env.development` — the whole development set
-     (`DATABASE_URL` plus one `NAME_DATABASE_URL` per configuration),
+   - `.env.development` — the whole development set (`DATABASE_URL`
+     plus one `NAME_DATABASE_URL` per configuration),
    - `.env.test` — the test URL under `PRIMARY_DATABASE_URL`, the key
      Rails checks *before* `DATABASE_URL` for a flat test config, so it
      wins regardless of the order a loader reads the files in.
 
-   Mode 0600, git-excluded automatically, removed with the worktree.
+   Only these environment-scoped names are ever written — **never
+   plain `.env`**, the file production tooling reads by name (kamal,
+   docker `--env-file`, and dotenv itself loads `.env` in *every*
+   environment), so a production boot can never see a worktree's
+   database URLs. Mode 0600, git-excluded automatically, removed with
+   the worktree. Existing keys in those files are **upserted, never
+   clobbered** — your own entries (API keys, a committed env file's
+   config) survive `yamine db create`.
    A hand-run `rails console`, `rails test`, or `db:migrate` in the
    worktree therefore lands on the worktree's own databases — with
    **zero yamine-specific code in `database.yml`, ever**.
@@ -275,7 +282,7 @@ Credential keys travel too: `config/master.key`,
 `config/credentials/test.key` are copied at mode 0600. Production and
 staging keys stay in the main checkout where they belong.
 
-The main checkout never gets `.env` files or a suffix: its databases
+The main checkout never gets these env files or a suffix: its databases
 are its databases, untouched.
 
 

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

@@ -116,9 +116,11 @@ 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. It writes
-`.env` / `.env.development` (the development set) and `.env.test`
+`.env.development` (the development set) and `.env.test`
 (`PRIMARY_DATABASE_URL` — the key Rails checks first for a flat test
-config) into the worktree, git-excluded automatically. Then boot with
+config) into the worktree, git-excluded automatically — never plain `.env`
+(production tooling reads that name), and existing keys in those files
+are upserted, not clobbered. 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;
@@ -133,7 +135,7 @@ worktree after the app grows a database).
 
 Isolation reaches two places: supervised boots via injected
 `DATABASE_URL` / `NAME_DATABASE_URL` env vars, and hand-run commands
-(`rails console`, `rails test`, `db:migrate`) via the `.env` files —
+(`rails console`, `rails test`, `db:migrate`) via these env files —
 which require a dotenv loader in the app (`gem "dotenv-rails",
 groups: [:development, :test]`) and **component-form development/test
 config** (`database:` keys, never `url:` — a `url:` key takes

data/lib/yamine/database.rb

@@ -32,17 +32,29 @@ 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),
+    # The per-worktree environment files yamine writes — ONLY
+    # environment-scoped names, never plain `.env`. Production-style
+    # tooling reads `.env` by name (kamal, docker --env-file, and
+    # dotenv itself loads `.env` in *every* environment), so a
+    # worktree's plain `.env` could leak dev database URLs into a
+    # production boot that happened to run from this directory.
+    # `.env.development` / `.env.test` are invisible to a production
+    # boot by construction — dotenv only ever reads
+    # `.env.#{Rails.env}` for the current environment.
+    #
     # `.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.
+    # *before* DATABASE_URL for a flat test config, so the test URL
+    # wins no matter which order a loader reads the files in. Hand-run
+    # commands (`rails console`, `rails test`, `db:migrate`) pick
+    # these up; env injection still covers processes yamine spawns.
+    ENV_FILES = %w[.env.development .env.test].freeze
+    # 0.16.0's marker file — removed in favor of env files; deleted on
+    # sight so upgraded worktrees don't accumulate dead files.
     LEGACY_MARKER_FILE = ".yamine-db-suffix"
+    # 0.17.0 wrote plain `.env` too; this header marks it as ours to
+    # delete. A `.env` WITHOUT the header belongs to the app or the
+    # developer and is never touched.
+    LEGACY_ENV_HEADER = "written by yamine"
 
     # Database name for a worktree dir + env (development/test).
     # Main checkout (no worktree marker) keeps the bare name.
@@ -176,44 +188,63 @@ module Yamine
       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.
+    # Write the worktree's environment files (see ENV_FILES for the
+    # why of the names). Upsert semantics: our keys are (re)written,
+    # every other line in the file survives — a committed env file's
+    # non-database config, or a developer's copied-in API keys, must
+    # not be destroyed by `yamine db create`. Private mode; the
+    # 0.16.0 marker and a yamine-authored 0.17.0 `.env` are removed
+    # on the way past.
     def write_env_files(dir, dev_env, test_url: nil)
       FileUtils.rm_f(File.join(dir, LEGACY_MARKER_FILE))
+      remove_legacy_worktree_env(dir)
       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)
+        merge_env_file(File.join(dir, ".env.development"),
+          dev_env.reject { |k, _v| k == "PRIMARY_DATABASE_URL" })
       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 }))
+      merge_env_file(File.join(dir, ".env.test"),
+        { "PRIMARY_DATABASE_URL" => test_url })
     end
 
-    def write_env_file(path, body)
+    # 0.17.0 wrote plain `.env` — remove it ONLY when yamine authored
+    # it; an app-committed or developer-written `.env` is theirs.
+    def remove_legacy_worktree_env(dir)
+      path = File.join(dir, ".env")
+      return unless File.file?(path)
+      return unless File.read(path).include?(LEGACY_ENV_HEADER)
+
+      FileUtils.rm_f(path)
+    end
+
+    # Upsert our keys into a dotenv file, preserving every other line.
+    # Our header is placed once (idempotent across re-runs).
+    def merge_env_file(path, env)
+      existing = File.file?(path) ? File.read(path).lines : []
+      key_res = env.keys.map { |k| /\A\s*#{Regexp.escape(k)}\s*=/ }
+      kept = existing.reject { |line| key_res.any? { |re| line.match?(re) } }
+      unless kept.any? { |line| line.include?(LEGACY_ENV_HEADER) }
+        kept = yamine_env_header.lines + kept
+      end
+      body = kept.join
+      body += "\n" unless body.empty? || body.end_with?("\n")
+      body += env.map { |k, v| "#{k}='#{dotenv_escape(v.to_s)}'\n" }.join
       File.write(path, body)
       File.chmod(0o600, path)
     end
 
+    def yamine_env_header
+      "# Per-worktree databases, written by yamine (worktree add).\n" \
+      "# Environment-scoped (.env.development/.env.test) so a production\n" \
+      "# boot never reads these; other keys in this file are preserved.\n"
+    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

data/lib/yamine/version.rb

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

metadata

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