yamine 0.11.0 → 0.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1efaa2b9488a10007f6a386cf874eb78b3e8489e9b772efb2e88713286e98e2d
-  data.tar.gz: 410ac56d153c94589d1d36fd1a6b5670ac215c6c5999ca956590acd3d7c46a98
+  metadata.gz: e48f66da1b02dd9ea589c1a30225d6b1f9dc46cd1abd92ffad90c27422b6d4ca
+  data.tar.gz: '0209cb0ce1c976c5f6a934ba0a74283f3b8064e2fc9aed493208c74077dd5a62'
 SHA512:
-  metadata.gz: ed28898e26abce37591fb15902697e2f96d2dc4ed4bc20d951872c48f586e19482affdafb24606bbe8c95cd0016b63a637d45f23c15fd7778f6ebd9a2415e0b7
-  data.tar.gz: 075d1d80e12a0578377d956421bfbc7ac9dc61e414552262d0ffd61ea9613f1382732135c5b8e7c7af8fbfb9d54e02905d05bc53347cba7054ced38879fef0d4
+  metadata.gz: 2626fc9696988148d9637ffd1ce14adc7d7d656b03d61854296ff3b6c818fd82ff840fce5904395ac8d2b54c027c9f7e63f47f0f077609f896542af06c282d28
+  data.tar.gz: 110d265a913ee76a3ff40328c40cfdc0475e195c3e1518a490294dd2bb7bca0536edbaeedba7bc37815625aa3975880efdb1b1a66252b3c2a9ed16d6a2b5abd1

data/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## [0.11.1] — 2026-09-11
+
+### Fixed
+
+- **`env:` in `config/local.yml` now actually reaches the processes.**
+  It never did. `build_env` was written, correct-looking, and had no
+  callers — so every top-level `env.clear` value and every `env.secret`
+  was parsed, validated, and dropped on the floor. It stayed invisible
+  because `DATABASE_URL` had its own path to the child; a config whose
+  *integration* depended on that block booted with the variable blank,
+  which looks exactly like a code bug.
+
+  Found while wiring a Rails app to a sibling service at
+  `https://other-app.localhost`: the URL was in `config/local.yml`, the
+  process had `nil`.
+
+  Both levels now merge, process over top-level, with `env.secret` names
+  resolved from `config/local.secrets` (or an existing export). A declared
+  secret nobody supplies warns at boot instead of starting blank — an app
+  with a missing API key fails somewhere far less obvious later.
+
+  yamine's own variables (`PORT`, `YAMINE_URL`, `DATABASE_URL`, the TLS
+  paths) are applied *after* the config, so a stray key in `local.yml`
+  cannot steer a process off its route. Pinned end to end by a test that
+  spawns a real process and reads the value out of its environment —
+  asserting on `build_env`'s return would have passed on the broken
+  version too.
+
 ## [0.11.0] — 2026-09-11
 
 ### Added

data/lib/yamine/cli/boot.rb

@@ -241,7 +241,8 @@ module Yamine
           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)
+            rails_dev_host: item[:hostname], database_url: db_url,
+            extra_env: build_env(resolved, item[:entry], proc_name: item[:name]))
           routes_registered << { hostnames: item[:hostnames], app: app }
 
           say opts, "  -> #{item[:url]}"
@@ -261,7 +262,8 @@ module Yamine
           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])
+            database_url: db_url, force: opts[:force],
+            extra_env: build_env(resolved, item[:entry], proc_name: item[:name]))
           # 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.
@@ -359,7 +361,8 @@ module Yamine
         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,
-          database_url: db_url)
+          database_url: db_url,
+          extra_env: build_env(resolved, entry, proc_name: proc_name))
         children << { name: proc_name, pid: app.pid }
         say opts, "  [#{proc_name}] background (pid #{app.pid})"
       end
@@ -398,18 +401,44 @@ module Yamine
         end
       end
 
-      def build_env(ctx, resolved, entry)
+      # The environment a process gets, from the config.
+      #
+      # Two levels, and the merge order is the point: top-level `env:`
+      # describes the whole app (an API URL every process needs), a
+      # process's own `env:` describes that process, and the process wins
+      # where they collide — "this one worker talks to staging" should not
+      # require restructuring the file.
+      #
+      # `env.clear` is literal values; `env.secret` names keys whose values
+      # come from config/local.secrets (dotenv, gitignored), so a credential
+      # stays out of the config file while still reaching the process. A
+      # named secret that is missing is reported rather than silently
+      # dropped: an app booting with a blank API key fails later, somewhere
+      # far less obvious.
+      def build_env(resolved, entry, proc_name: nil)
         env = {}
-        # Merge config env.clear
-        config_env = resolved.secrets || {}
+
+        top = resolved.env.is_a?(Hash) ? resolved.env : {}
+        (top["clear"] || {}).each { |k, v| env[k] = v }
+
         entry_env = entry["env"] || {}
         (entry_env["clear"] || {}).each { |k, v| env[k] = v }
-        # Merge secrets from config/local.secrets
-        secret_keys = entry_env["secret"] || []
-        secret_keys.each do |k|
-          env[k] = config_env[k] if config_env.key?(k)
+
+        secrets = resolved.secrets || {}
+        (Array(top["secret"]) + Array(entry_env["secret"])).uniq.each do |key|
+          if secrets.key?(key)
+            env[key] = secrets[key]
+          elsif ENV.key?(key)
+            # Already in the environment (a shell export, an agent's
+            # session) — the declaration is satisfied.
+            env[key] = ENV[key]
+          else
+            label = proc_name ? "#{proc_name}: " : ""
+            $stderr.puts "  #{label}warning: env.secret lists #{key}, but it is not in " \
+                         "config/local.secrets (and not in the environment) — starting without it"
+          end
         end
-        # Host env (dotenv from .env) already in ENV
+
         env
       end
 

data/lib/yamine/runner.rb

@@ -93,11 +93,16 @@ module Yamine
     # register: false spawns without a route (background processes).
     # Child output goes to log/yamine-<name>.log so `--wait` failure
     # payloads can tail it (same file the managed path uses).
+    #
+    # extra_env is the config's env.clear/env.secret for this process —
+    # 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)
+      rails_dev_host: nil, register: true, database_url: nil, spec: nil,
+      extra_env: nil)
       port ||= Ports.find_free
       env = child_env(dir, url: url, port: port, rails_dev_host: rails_dev_host,
-        database_url: database_url)
+        database_url: database_url, 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)
@@ -124,9 +129,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)
+      database_url: nil, force: false, extra_env: nil)
       env = child_env(dir, url: url, port: port, rails_dev_host: rails_dev_host,
-        database_url: database_url)
+        database_url: database_url, 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)
@@ -151,8 +156,12 @@ module Yamine
       false
     end
 
-    def child_env(dir, url:, port:, rails_dev_host: nil, database_url: nil)
-      env = { "YAMINE_URL" => url }
+    def child_env(dir, url:, port:, rails_dev_host: nil, database_url: 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.
+      env = (extra_env || {}).transform_keys(&:to_s).transform_values(&:to_s)
+      env["YAMINE_URL"] = url
       env["PORT"] = port.to_s if port
       env["HOST"] = "127.0.0.1"
 

data/lib/yamine/version.rb

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

metadata

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