yamine 0.7.1 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 96bdebf9dc726c4caf747a07f2599bbde292a975e3395bd7cf43b1daf752bea3
-  data.tar.gz: 4abda73bc87a74f344070a3d69e87d470b788f05d04abfa4d6fb5783649fea20
+  metadata.gz: 46a9c0208ca1d5581c3c25d45b60370a6e37c7dd4fcf721bda7a5573fc1c70db
+  data.tar.gz: 0b534671965987794b3872969dcc3065dfca5532a401f12701e531a0779e7820
 SHA512:
-  metadata.gz: 627bc6d9fcb038635d90ec9b49eb7a321fae414cb58ed584b02f4bcc7fbd8fd3a49fe98b610d7fb033564c416ab8ccdbed1b87c5ef6983ef7c70023eca351110
-  data.tar.gz: 19a0c6f70d82fddf4385c616e820d04d00a12d60be5016a13ce12054da5bf82aeb5fc7a47940d030518645eda95dac28a1957502d7df139715da65695681863f
+  metadata.gz: 339e64fabec8dab3c019bfdec8ec8f9f558dc4700b647fd462c4898e4f8796f93c1b65078d9ff171c338f38c70d055a8185b1d21bb547c63831bd816c5b7c6de
+  data.tar.gz: a71d56eef8327103f46a050307bb01095810ccd70085f3728a430617d3230cf567ffe3e9a04047428d6988d63efa7dd6965546bbb5e689f270991f8d4cc55d6d

data/CHANGELOG.md

@@ -1,5 +1,40 @@
 # Changelog
 
+## [0.8.1] — 2026-09-10
+
+### Fixed
+
+- **An already-correct `/etc/hosts` no longer reports a failure.**
+  `Hosts.sync` rewrote the file unconditionally, so on a normal machine
+  (where `/etc/hosts` is root-owned) it raised `Errno::EACCES`, returned
+  false, and made `yamine start` print "could not write /etc/hosts (try
+  sudo yamine hosts sync)" on every boot — pointing at an elevated write
+  for a file that already had exactly the right block. `synced?` existed
+  for precisely this guard but `sync` never consulted it. `sync` is now a
+  no-op returning true when the block already matches, and the setup step
+  reports "already lists N hostname(s)" instead of implying a failure.
+  Chrome/Firefox/Edge resolve `*.localhost` natively anyway; the file only
+  matters for Safari and custom TLDs.
+
+
+## [0.8.0] — 2026-09-10
+
+### Fixed
+
+- **`--json` progress is flushed as it happens.** stdout is
+  block-buffered when it is a pipe — exactly how an agent reads the
+  stream — so the per-phase events added in 0.7.0 stayed in the buffer
+  until it filled or the process exited, making a slow boot look frozen.
+  That is the "poll and guess" behaviour the JSON stream exists to
+  replace. Every line is now flushed before the next phase runs.
+
+### Changed
+
+- The yamine agent skill documents the boot stream: the human
+  phase lines, the `--json` contract (one flushed object per line, human
+  banner on stderr, payload last), and that failures carry the log tail
+  and path.
+
 ## [0.7.1] — 2026-09-10
 
 ### Fixed

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

@@ -46,6 +46,28 @@ yamine log [-f]           # tail the web process log
 stable URLs, background ones are supervised without routes. A process
 that exits cleans up the whole tree.
 
+The boot narrates every phase — deps, db, schema, and each process's
+healthcheck — one line per phase, so a slow boot is never a black box:
+
+```
+  [deps] ok (479ms) dependencies satisfied
+  [web] ok (2.2s) healthcheck /up returned 2xx-3xx
+```
+
+With `--json` the same events stream to stdout as one JSON object per
+line, flushed as they happen (safe to read incrementally), and the
+human banner moves to stderr — so stdout stays parseable and the final
+payload is the last line:
+
+```
+{"phase":"deps","action":"deps","status":"ok","duration_ms":479,...}
+{"phase":"process","action":"web","status":"ok","duration_ms":2223,...}
+{"ok":true,"service":"myapp","urls":{"web":"https://myapp.localhost"},...}
+```
+
+On failure the payload carries the failed phase, that process's log tail,
+and the log path — no need to go digging.
+
 ## Cross-service wiring
 
 ```bash

data/lib/yamine/cli/system.rb

@@ -220,6 +220,8 @@ module Yamine
         hostnames = ctx.store.load_routes.map { |r| r["hostname"] }
         if hostnames.empty?
           puts "    No routes registered yet — hosts sync will happen on the next boot."
+        elsif Yamine::Hosts.synced?(hostnames)
+          puts "    /etc/hosts already lists #{hostnames.length} hostname(s)."
         elsif Yamine::Hosts.sync(hostnames)
           puts "    Synced #{hostnames.length} hostname(s) to /etc/hosts."
         else
@@ -758,8 +760,12 @@ module Yamine
           end
         end
 
-        # 3. Hosts (best-effort: only needed for Safari; warn, don't fail)
-        unless Hosts.sync(ctx.store.load_routes.map { |r| r["hostname"] })
+        # 3. Hosts (best-effort: only needed for Safari and custom TLDs —
+        # Chrome/Firefox/Edge resolve *.localhost natively). Already-synced
+        # is the common case and must stay silent: warning there sent
+        # people to a sudo write for a file that needed nothing.
+        hostnames = ctx.store.load_routes.map { |r| r["hostname"] }
+        unless hostnames.empty? || Yamine::Hosts.synced?(hostnames) || Hosts.sync(hostnames)
           warn "Warning: could not write /etc/hosts (try sudo yamine hosts sync)."
         end
       end

data/lib/yamine/hosts.rb

@@ -41,7 +41,20 @@ module Yamine
       names
     end
 
+    # Bring the managed block to exactly these hostnames. Idempotent: when
+    # the block already matches, this is a no-op returning true.
+    #
+    # The short-circuit is load-bearing, not an optimization. /etc/hosts is
+    # root-owned on a normal machine, so a rewrite fails without sudo — and
+    # `setup` and every boot's workstation check run this. Without the
+    # guard, a machine whose hosts file was already correct got a
+    # "could not write /etc/hosts (try sudo yamine hosts sync)" warning on
+    # every run, sending people to an elevated write for a file that
+    # needed nothing. (Chrome/Firefox/Edge resolve *.localhost natively;
+    # /etc/hosts only matters for Safari and custom TLDs.)
     def sync(hostnames, path = PATH)
+      return true if synced?(hostnames, path)
+
       content = read(path)
       block = managed_block(hostnames)
       if content.include?(BEGIN_MARKER)

data/lib/yamine/log.rb

@@ -96,6 +96,12 @@ module Yamine
 
       # One JSON object per line — the agent contract. Same events, no
       # prose.
+      #
+      # Every line is flushed. stdout is block-buffered when it is a pipe
+      # or a file, which is exactly how an agent reads it, so without the
+      # flush the whole progress stream stays invisible until the buffer
+      # fills or the process exits — the "poll and guess" behaviour the
+      # JSON stream exists to replace, now with extra steps.
       class Json
         def initialize(io = $stdout)
           @io = io
@@ -103,12 +109,18 @@ module Yamine
 
         def event(event)
           require "json"
-          @io.puts JSON.generate(event.to_h)
+          emit(event.to_h)
         end
 
         def note(message)
-          require "json"
-          @io.puts JSON.generate({ note: message })
+          emit({ note: message })
+        end
+
+        private
+
+        def emit(payload)
+          @io.puts JSON.generate(payload)
+          @io.flush if @io.respond_to?(:flush)
         end
       end
     end

data/lib/yamine/version.rb

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

metadata

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