yamine 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 03b07451fa5f83423efb747feb496c8617bef2fde5b4f4bf0d595d759efd1083
-  data.tar.gz: 64fd53920c5f4740402982dc9f56f07a835c83fb5c2a7eb741c636573b69cfad
+  metadata.gz: de59fb684553be7e33ba1a9ea4688bb075a3147ae6225cdc634818c869900163
+  data.tar.gz: 920ac5409e8e0803ed3e3d8ba01663ea03f1543db30e4921585ef6bfdf0d33be
 SHA512:
-  metadata.gz: 73b3fbdd108a91942ba53c29a41cd73825d3f3ea11a24ebc60c42786a792dc74553fe67938b28b2d4787011b021542bf17a633713d1178caa231a359bdd344a9
-  data.tar.gz: 315127dad685afebc614c3c76d8e8ecda53413aef997cea0e82730f8a169cbb066a4bcedb25c78cf502631062751b9911f8986842beac14440c4a9f25d4c5e9c
+  metadata.gz: 8f0cb59209724dd41946c4e0e82c6e2aa01ac9e49575bf461610ed525d98d50fb1566260cf83f7a0b50e19cffd4ab9d6658e372d1c094529e12276e256541161
+  data.tar.gz: 8bb784a546f91a27c5a9b00584fbe14560022d655acd861d5bfdba13db8f187b70913fd129b46b73948068d17c1affca556fd0eb4a67690074d74dbcfdb96214

data/lib/yamine/agent.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Yamine
+  # Agent identity for multi-agent codebases.
+  #
+  # Every route records which agent booted it so concurrent agents can
+  # coexist: list shows owners, conflicts name the other agent, quotas
+  # are enforced per agent, and stop/prune can target one agent without
+  # touching another's live backends. Identity comes from YAMINE_AGENT
+  # (set by the harness per session); without it we fall back to
+  # USER@HOST so humans sharing a machine still get distinct owners.
+  module Agent
+    module_function
+
+    def name
+      env = ENV["YAMINE_AGENT"]
+      return env.strip unless env.nil? || env.strip.empty?
+
+      user = ENV["USER"] || ENV["LOGNAME"] || "unknown"
+      host = begin
+        require "socket"
+        Socket.gethostname
+      rescue StandardError
+        "localhost"
+      end
+      "#{user}@#{host}"
+    end
+
+    # Default per-agent route cap. Generous: N agents x M services must
+    # fit in the ephemeral port range with headroom. Overridable via
+    # YAMINE_MAX_ROUTES (0 disables the cap).
+    DEFAULT_MAX_ROUTES = 32
+
+    def max_routes
+      raw = ENV["YAMINE_MAX_ROUTES"]
+      return DEFAULT_MAX_ROUTES if raw.nil? || raw.strip.empty?
+
+      Integer(raw)
+    rescue ArgumentError
+      DEFAULT_MAX_ROUTES
+    end
+  end
+end

data/lib/yamine/cli/boot.rb

@@ -18,6 +18,9 @@ module Yamine
         variant = ENV["YAMINE_VARIANT"]
         opts = ctx.parse_flags(args, %i[variant tld force])
         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.
+        check_worktree_ownership!(ctx, resolved, force: opts[:force])
         ensure_proxy!(ctx)
         boot_all(ctx, resolved, opts)
       end
@@ -60,9 +63,11 @@ module Yamine
         puts "--"
 
         processes.each do |proc_name, entry|
-          next if entry["proxy"] == false
-
           hostname = Resolver.hostname_for(resolved, proc_name)
+          if entry["proxy"] == false
+            boot_background(ctx, runner, resolved, proc_name, entry, opts, children)
+            next
+          end
           next unless hostname
 
           url = Hostname.url(hostname, port: ctx.proxy_port, tls: ctx.proxy_tls)
@@ -101,9 +106,49 @@ module Yamine
         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 }
-        trap_cleanup(ctx, routes_registered.flat_map { |r| r[:hostnames] }, all_pids)
-        supervise_tree(ctx, routes_registered.flat_map { |r| r[:hostnames] }, all_pids)
+        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
+
+      # 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)
+        cmd = entry["cmd"].to_s
+        if cmd.match?(Yamine::Procfile::COMPOUND)
+          $stderr.puts "  [#{proc_name}] ERROR: compound line (&&, ||, |, ;) — run explicitly: yamine run -- #{cmd}"
+          return
+        end
+        port = opts[:app_port] || Ports.find_free
+        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)
+        children << { name: proc_name, pid: app.pid }
+        puts "  [#{proc_name}] background (pid #{app.pid})"
+      end
+
+      # Refuse to boot over another agent's live routes unless forced.
+      # Compares our worktree dir (spec.dir) against the owner's: same
+      # dir + same agent is a restart, anything else names the owner.
+      def check_worktree_ownership!(ctx, resolved, force:)
+        mine = Agent.name
+        here = File.expand_path(Dir.pwd)
+        Resolver.hostnames(resolved).each do |hostname|
+          entry = ctx.store.find(hostname)
+          next unless entry
+          next unless entry["pid"] != 0 && ProxyControl.pid_alive?(entry["pid"])
+          next if entry["agent"] == mine && entry.dig("spec", "dir") == here
+          next if force
+
+          owner = entry["agent"] && !entry["agent"].empty? ? "agent #{entry["agent"].inspect}" : "PID #{entry["pid"]}"
+          dir = entry.dig("spec", "dir")
+          $stderr.puts "Error: #{hostname} is live and owned by #{owner}#{dir ? " (#{dir})" : ""}."
+          $stderr.puts "  Work in your own worktree (each branch gets its own URL), or take over explicitly:"
+          $stderr.puts "    yamine start --force"
+          exit 1
+        end
       end
 
       def build_env(ctx, resolved, entry)

data/lib/yamine/cli/routes.rb

@@ -8,12 +8,16 @@ module Yamine
       module_function
 
       # yamine get <name> [--service x] [--variant y] [--tld z]
+      # yamine get --all [--json]
       #
       # Variant and TLDs are inherited from the CURRENT directory's
       # context (worktree branch, YAMINE_* env, config) so cross-service
       # wiring works inside a variant: from a fix-ui worktree,
       # `get backend` -> https://fix-ui.backend.localhost.
       def get(ctx, args)
+        if args.delete("--all")
+          return registry(ctx, args)
+        end
         name = args.first
         raise Error, "Usage: yamine get <name> [--service s] [--variant v] [--tld t]" unless name
 
@@ -36,7 +40,8 @@ module Yamine
           { hostname: r["hostname"],
             url: Hostname.url(r["hostname"], port: port, tls: tls),
             target: r["target"], kind: r["kind"],
-            pid: r["pid"], supervised: !r["spec"].nil?,
+            pid: r["pid"], agent: r["agent"],
+            supervised: !r["spec"].nil?,
             alive: alive_state(ctx, r) }
         end
         if json
@@ -56,6 +61,34 @@ module Yamine
         puts
       end
 
+      # Shared discovery: `get --all` lists every live route (any owner)
+      # with its URL and agent, so one agent can find another's services
+      # without coupling. `--json` emits the same stable keys as list.
+      def registry(ctx, args)
+        json = args.delete("--json")
+        routes = ctx.store.load_routes
+        port = ctx.proxy_port
+        tls = ctx.proxy_tls
+        entries = routes.map do |r|
+          { hostname: r["hostname"],
+            url: Hostname.url(r["hostname"], port: port, tls: tls),
+            agent: r["agent"], alive: alive_state(ctx, r) }
+        end
+        if json
+          require "json"
+          puts JSON.generate({ routes: entries })
+          return
+        end
+        if entries.empty?
+          puts "No active routes."
+          return
+        end
+        entries.each do |e|
+          owner = e[:agent] ? " (#{e[:agent]})" : ""
+          puts "  #{e[:url]}#{owner}"
+        end
+      end
+
       def alive_state(ctx, route)
         if route["pid"] == 0
           ctx.backend_alive?(route) ? "reachable" : "unreachable"
@@ -69,10 +102,11 @@ module Yamine
       end
 
       def label_for(entry)
+        owner = entry[:agent] ? " #{entry[:agent]}" : ""
         if entry[:pid] == 0
-          "(alias, #{entry[:alive]})"
+          "(alias, #{entry[:alive]}#{owner})"
         else
-          "(pid #{entry[:pid]}, #{entry[:alive]})"
+          "(pid #{entry[:pid]}, #{entry[:alive]}#{owner})"
         end
       end
 
@@ -84,7 +118,19 @@ module Yamine
         label_for(entry)
       end
 
-      def prune(ctx, _args)
+      def prune(ctx, args)
+        if (i = args.index("--agent"))
+          agent = args.fetch(i + 1, nil)
+          raise Error, "Usage: yamine prune --agent NAME" if agent.nil? || agent.empty?
+
+          stale = ctx.store.prune_stale(agent: agent)
+          if stale.empty?
+            puts "No stale routes for agent #{agent.inspect}."
+          else
+            stale.each { |r| puts "Removed stale route #{r["hostname"]}." }
+          end
+          return
+        end
         stale = ctx.store.prune_stale
         if stale.empty?
           puts "No stale routes."
@@ -124,15 +170,31 @@ module Yamine
       # Stop the app in the current directory (route + backend).
       # Exit codes are machine-readable for agents: 0 stopped something,
       # 2 no route here, 3 route existed but the backend was already gone.
-      def stop(ctx, _args, out: $stdout)
+      # Only our own agent's routes are touched: a foreign-owned live
+      # route is reported, never killed (shared backends survive one
+      # agent's cleanup). --force overrides and names the previous owner.
+      def stop(ctx, args, out: $stdout)
+        force = args.delete("--force")
         resolved = Resolver.resolve(Dir.pwd)
         hostnames = Resolver.hostnames(resolved)
+        mine = Agent.name
         stopped = []
         gone = []
+        foreign = []
         hostnames.each do |hostname|
           entry = ctx.store.find(hostname)
           next unless entry
 
+          if entry["pid"] != 0 && entry["agent"] && entry["agent"] != mine &&
+              ProxyControl.pid_alive?(entry["pid"])
+            unless force
+              owner = entry["agent"].empty? ? "PID #{entry["pid"]}" : "agent #{entry["agent"].inspect}"
+              foreign << "#{hostname} (owned by #{owner})"
+              next
+            end
+            out.puts "Taking over #{hostname} from #{entry["agent"].inspect} (--force)."
+          end
+
           backend_pid = ctx.backend_pid_for(entry)
           if backend_pid && ProxyControl.pid_alive?(backend_pid)
             begin
@@ -155,6 +217,11 @@ module Yamine
           stopped.each { |s| out.puts "Stopped #{s}." }
           return 0
         end
+        if foreign.any?
+          out.puts "Skipped live routes owned by other agents: #{foreign.join(", ")}."
+          out.puts "Take over explicitly with `yamine stop --force`."
+          return 4
+        end
         if gone.any?
           out.puts "Route existed but the backend was already gone: #{gone.join(", ")}."
           return 3

data/lib/yamine/errors.rb

@@ -4,13 +4,32 @@ module Yamine
   class Error < StandardError; end
   class ConfigError < Error; end
   class RouteConflictError < Error
-    attr_reader :hostname, :existing_pid
+    attr_reader :hostname, :existing_pid, :existing_agent, :existing_dir
 
-    def initialize(hostname, existing_pid)
+    def initialize(hostname, existing_pid, existing_agent: nil, existing_dir: nil)
       @hostname = hostname
       @existing_pid = existing_pid
-      super("\"#{hostname}\" is already registered by a running process " \
-            "(PID #{existing_pid}). Use --force to override.")
+      @existing_agent = existing_agent
+      @existing_dir = existing_dir
+      owner = if existing_agent && !existing_agent.empty?
+                "agent #{existing_agent.inspect}#{existing_dir ? " (#{existing_dir})" : ""}"
+              else
+                "PID #{existing_pid}"
+              end
+      super("\"#{hostname}\" is already registered by a running #{owner}. " \
+            "Use --force to override.")
+    end
+  end
+  class QuotaExceededError < Error
+    attr_reader :agent, :limit, :count
+
+    def initialize(agent, limit, count)
+      @agent = agent
+      @limit = limit
+      @count = count
+      super("Agent #{agent.inspect} already owns #{count} routes (limit #{limit}). " \
+            "Stop something first: `yamine stop`, or prune one agent's orphans " \
+            "with `yamine prune --agent NAME`.")
     end
   end
   class ProxyNotRunningError < Error; end

data/lib/yamine/proxy_control.rb

@@ -16,11 +16,11 @@ module Yamine
     module_function
 
     # Path to the yamine executable relative to this file
-    # (lib/ask/local -> gem root/bin). Used for daemon spawn and
+    # (lib/yamine -> gem root/bin). Used for daemon spawn and
     # service install; both must resolve identically in dev checkouts
     # and installed gems.
     def bin_path
-      File.expand_path("../../../bin/yamine", __dir__)
+      File.expand_path("../../bin/yamine", __dir__)
     end
 
     def root?

data/lib/yamine/route_store.rb

@@ -4,12 +4,14 @@ require "fileutils"
 require "json"
 
 module Yamine
-  # Persistent hostname -> backend mapping in ~/.yamine/routes.json.
-  #
-  # Entries: {hostname, target, kind, pid} where target is a unix socket
-  # path (kind "socket") or "127.0.0.1:PORT" (kind "tcp"), and pid 0
-  # marks a static alias. Guarded by flock; stale PIDs pruned on read.
-  # Modeled on portless RouteStore and puma-dev's AppPool registry.
+    # Persistent hostname -> backend mapping in ~/.yamine/routes.json.
+    #
+    # Entries: {hostname, target, kind, pid, agent} where target is a unix
+    # socket path (kind "socket") or "127.0.0.1:PORT" (kind "tcp"), pid 0
+    # marks a static alias, and agent names the owner (YAMINE_AGENT or
+    # USER@HOST fallback) so concurrent agents can coexist. Guarded by
+    # flock; stale PIDs pruned on read.
+    # Modeled on portless RouteStore and puma-dev's AppPool registry.
   class RouteStore
     FILE_MODE = 0o644
     DIR_MODE = 0o755
@@ -71,13 +73,22 @@ module Yamine
     # Returns killed pid when force takes over a live route.
     # `spec` marks daemon-supervised managed apps ({dir: ...}); the
     # proxy supervisor may idle-kill and boot-on-request those backends.
-    def add_route(hostname, target, pid, kind:, force: false, spec: nil)
+    # `agent` records the owner (defaults to Agent.name); foreign-owned
+    # live routes can only be taken with force: true, and the conflict
+    # error names the other agent plus its worktree dir.
+    def add_route(hostname, target, pid, kind:, force: false, spec: nil, agent: nil)
+      agent ||= Agent.name
       killed = nil
       with_lock do
         routes = load_routes(prune: true)
+        enforce_quota!(routes, agent, hostname)
         existing = routes.find { |r| r["hostname"] == hostname }
         if existing && existing["pid"] != pid && alive?(existing["pid"])
-          raise RouteConflictError.new(hostname, existing["pid"]) unless force
+          unless force
+            raise RouteConflictError.new(hostname, existing["pid"],
+              existing_agent: existing["agent"],
+              existing_dir: existing.dig("spec", "dir"))
+          end
 
           begin
             Process.kill("TERM", existing["pid"])
@@ -87,7 +98,8 @@ module Yamine
           end
         end
         routes.reject! { |r| r["hostname"] == hostname }
-        entry = { "hostname" => hostname, "target" => target, "kind" => kind, "pid" => pid }
+        entry = { "hostname" => hostname, "target" => target, "kind" => kind,
+                  "pid" => pid, "agent" => agent }
         entry["spec"] = spec if spec
         routes << entry
         save_routes(routes)
@@ -95,33 +107,52 @@ module Yamine
       killed
     end
 
-    def remove_route(hostname, owner_pid: nil)
-      with_lock do
-        routes = load_routes(prune: true)
-        routes.reject! do |r|
-          r["hostname"] == hostname && (owner_pid.nil? || r["pid"] == owner_pid)
-        end
-        save_routes(routes)
-      end
+    # Live routes owned by one agent (for quotas, targeted prune/stop).
+    def routes_for(agent)
+      load_routes.select { |r| r["agent"] == agent }
     end
 
-    def prune_stale
+    # Remove stale entries belonging to one agent only; other agents'
+    # routes are untouched even when their owners are dead.
+    def prune_stale(agent: nil)
       stale = []
       with_lock do
         all = load_routes_raw
         alive, dead = all.partition { |r| r["pid"] == 0 || alive?(r["pid"]) }
-        stale = dead
-        save_routes(alive) unless dead.empty?
+        stale = agent ? dead.select { |r| r["agent"] == agent } : dead
+        save_routes(alive + (dead - stale)) unless stale.empty?
       end
       stale
     end
 
+    def remove_route(hostname, owner_pid: nil)
+      with_lock do
+        routes = load_routes(prune: true)
+        routes.reject! do |r|
+          r["hostname"] == hostname && (owner_pid.nil? || r["pid"] == owner_pid)
+        end
+        save_routes(routes)
+      end
+    end
+
     def find(hostname)
       load_routes.find { |r| r["hostname"] == hostname }
     end
 
     private
 
+    # Per-agent route cap. Counts the agent's live routes (excluding the
+    # hostname being (re)registered, so restarts never trip the quota).
+    # Limit 0 disables the cap. Raises QuotaExceededError naming the
+    # agent, the count, and the fix.
+    def enforce_quota!(routes, agent, hostname)
+      limit = Agent.max_routes
+      return if limit.zero?
+
+      count = routes.count { |r| r["agent"] == agent && r["hostname"] != hostname }
+      raise QuotaExceededError.new(agent, limit, count) if count >= limit
+    end
+
     def valid_route?(value)
       value.is_a?(Hash) &&
         value["hostname"].is_a?(String) &&

data/lib/yamine/runner.rb

@@ -90,15 +90,18 @@ module Yamine
     end
 
     # Run an arbitrary command with PORT + YAMINE_URL. Returns App.
+    # register: false spawns without a route (background processes).
     def boot_run(name:, hostname:, url:, dir:, command:, port: nil, force: false,
-      rails_dev_host: nil)
+      rails_dev_host: nil, register: true)
       port ||= Ports.find_free
       env = child_env(dir, url: url, port: port, rails_dev_host: rails_dev_host)
       pid = with_clean_env { spawn(env, *command, chdir: dir) }
       Process.detach(pid)
       target = "127.0.0.1:#{port}"
-      @store.add_route(hostname, target, Process.pid, kind: "tcp", force: force)
-      write_backend_pid(hostname, pid)
+      if register
+        @store.add_route(hostname, target, Process.pid, kind: "tcp", force: force)
+        write_backend_pid(hostname, pid)
+      end
       App.new(name: name, hostname: hostname, url: url, pid: pid,
         target: target, kind: "tcp", command: command)
     end

data/lib/yamine/version.rb

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

data/lib/yamine.rb

@@ -2,6 +2,7 @@
 
 require_relative "yamine/version"
 require_relative "yamine/errors"
+require_relative "yamine/agent"
 require_relative "yamine/sanitize"
 require_relative "yamine/hostname"
 require_relative "yamine/inference"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yamine
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Kaka Ruto
@@ -82,6 +82,7 @@ files:
 - bin/yamine
 - lib/ask/skills/yamine/SKILL.md
 - lib/yamine.rb
+- lib/yamine/agent.rb
 - lib/yamine/certs.rb
 - lib/yamine/cli.rb
 - lib/yamine/cli/boot.rb