yamine 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de59fb684553be7e33ba1a9ea4688bb075a3147ae6225cdc634818c869900163
-  data.tar.gz: 920ac5409e8e0803ed3e3d8ba01663ea03f1543db30e4921585ef6bfdf0d33be
+  metadata.gz: 0c28579a9f53f3078412006a6f697d366cd7f0b2f897e7cf52025b742b2d5ba2
+  data.tar.gz: e7c826ffece34cf08ac88fcb31d1613418a9f3f5713badb08f6725937d906409
 SHA512:
-  metadata.gz: 8f0cb59209724dd41946c4e0e82c6e2aa01ac9e49575bf461610ed525d98d50fb1566260cf83f7a0b50e19cffd4ab9d6658e372d1c094529e12276e256541161
-  data.tar.gz: 8bb784a546f91a27c5a9b00584fbe14560022d655acd861d5bfdba13db8f187b70913fd129b46b73948068d17c1affca556fd0eb4a67690074d74dbcfdb96214
+  metadata.gz: e1a77d9dad1424f4cdbd0fa351224f626a858e986c6300063a70650dc7c02007f8ea8cbb83e2658a5f06e1a3ff8ba091986ce1480c28e510d9a096c287cc596d
+  data.tar.gz: 9194bc35c52acdb669a177bb758af0539c2983056c8e7e4dbd700d937ea850a2947708fef0315d8e2d6281b33850bb96a2de4f26abb0878a2b1b8d3db91cd777

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [0.5.0] — Unreleased
+
+Per-worktree databases: every worktree directory gets its own database
+so concurrent agents never share tables.
+
+### Added
+
+- `Yamine::Database`: `<sanitized-dir-basename>_<env>` naming
+  (`/code/myapp-fix` → `myapp_fix_development`; main keeps the bare
+  name), 63-byte Postgres cap with hash-suffix truncation, collision
+  guard via state map (silent sharing would be the bug this kills).
+- Boot resolves the DB once, creates it (`createdb`/`mysqladmin`,
+  never raises — warns and shares template on failure), runs the app's
+  schema-load (`db.schema_load` in config, Rails default, else nothing),
+  and injects `DATABASE_URL` into every process. SQLite left alone.
+- `yamine db list|create|drop` and `yamine worktree list|clean`
+  (orphan reaping for deleted worktrees). Branch plays no part —
+  directories are stable, branches hop.
+
 ## [0.3.0] — Unreleased
 
 Renamed from `ask-local` to **`yamine`** (يمين, "right hand" — the local

data/lib/yamine/cli/boot.rb

@@ -62,10 +62,21 @@ module Yamine
         puts "yamine (#{service})"
         puts "--"
 
+        # Per-worktree database: one database per directory so concurrent
+        # agents never share tables. Resolved once, injected into every
+        # process as DATABASE_URL, created on demand with the app's own
+        # schema-load command. SQLite needs nothing (relative paths
+        # already isolate); the branch plays no part (dirs are stable,
+        # branches hop).
+        db_name = Database.name_for(Dir.pwd, env: rails_env,
+          state_dir: ctx.store.dir)
+        db_url = setup_database(ctx, resolved, db_name)
+        puts "  [db] #{db_name}" if db_url
+
         processes.each do |proc_name, entry|
           hostname = Resolver.hostname_for(resolved, proc_name)
           if entry["proxy"] == false
-            boot_background(ctx, runner, resolved, proc_name, entry, opts, children)
+            boot_background(ctx, runner, resolved, proc_name, entry, opts, children, db_url)
             next
           end
           next unless hostname
@@ -87,9 +98,11 @@ module Yamine
           shell_cmd = ["sh", "-c", cmd]
           # Always allow the proxied hostname in Rails dev (Rails ignores
           # this env var when not a Rails app — safe for every framework).
+          # DATABASE_URL points at this worktree's own database; non-Ruby
+          # frameworks that honor it get isolation for free, others ignore it.
           app = runner.boot_run(name: proc_name, hostname: hostname, url: url,
             dir: Dir.pwd, command: shell_cmd, port: port, force: opts[:force],
-            rails_dev_host: hostname)
+            rails_dev_host: hostname, database_url: db_url)
           register_all(ctx, hostnames, app, force: opts[:force],
             spec: { "dir" => File.expand_path(Dir.pwd), "proc" => proc_name })
           routes_registered << { hostnames: hostnames, app: app }
@@ -114,7 +127,7 @@ module Yamine
 
       # 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)
+      def boot_background(ctx, runner, resolved, proc_name, entry, opts, children, db_url)
         cmd = entry["cmd"].to_s
         if cmd.match?(Yamine::Procfile::COMPOUND)
           $stderr.puts "  [#{proc_name}] ERROR: compound line (&&, ||, |, ;) — run explicitly: yamine run -- #{cmd}"
@@ -124,7 +137,8 @@ module Yamine
         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)
+          force: opts[:force], rails_dev_host: nil, register: false,
+          database_url: db_url)
         children << { name: proc_name, pid: app.pid }
         puts "  [#{proc_name}] background (pid #{app.pid})"
       end
@@ -166,6 +180,64 @@ module Yamine
         env
       end
 
+      # Rails env for database naming: RAILS_ENV when set, else development.
+      # Non-Rails apps ignore it (their DATABASE_URL template decides).
+      def rails_env
+        ENV.fetch("RAILS_ENV", "development")
+      end
+
+      # Resolve this worktree's database, create it if missing, and run
+      # the app's schema-load command on first creation. Returns the
+      # DATABASE_URL for injection, or nil when there's nothing to do
+      # (no template URL, sqlite, or the app opted out via db: false).
+      def setup_database(ctx, resolved, db_name)
+        return nil if resolved.processes["db"] == false
+
+        template = ENV["DATABASE_URL"] || database_template_from_config(resolved)
+        return nil if template.nil? || template.strip.empty?
+
+        url = Database.url_for(db_name, template)
+        return nil unless url
+
+        if Database.ensure_exists(db_name, template)
+          puts "  [db] created #{db_name}" unless database_exists?(db_name, template)
+          run_schema_load(resolved, url)
+        else
+          $stderr.puts "  [db] WARNING: could not create #{db_name} — processes share the template database."
+          return nil
+        end
+        url
+      end
+
+      def database_exists?(name, template)
+        # ensure_exists is idempotent; this second call is cheap (psql -lqt)
+        # and tells us whether to print "created" vs nothing.
+        Database.ensure_exists(name, template)
+      end
+
+      def database_template_from_config(resolved)
+        env = resolved.processes.values.map { |e| e["env"] || {} }
+        clear = env.map { |e| e["clear"] || {} }.reduce({}, :merge)
+        clear["DATABASE_URL"]
+      end
+
+      # Schema-load on first boot uses the app's own command when declared
+      # (db.schema_load in config/local.yml), else a Rails default when a
+      # Rails app is detected, else nothing (frameworks without a
+      # schema concept need no step).
+      def run_schema_load(resolved, url)
+        cmd = resolved.processes.dig("db", "schema_load") ||
+          ("bin/rails db:schema:load" if rails_app?)
+        return unless cmd
+
+        system({ "DATABASE_URL" => url, "RAILS_ENV" => rails_env },
+          "sh", "-c", cmd, chdir: Dir.pwd, out: File::NULL, err: File::NULL)
+      end
+
+      def rails_app?
+        File.file?(File.join(Dir.pwd, "config", "application.rb"))
+      end
+
       def supervise_tree(ctx, hostnames, pids)
         loop do
           sleep 0.5

data/lib/yamine/cli/system.rb

@@ -763,6 +763,134 @@ module Yamine
         puts "    - #{app}-#{slug}.#{domain}"
         puts "  # Prefer Kamal multi-host for production; single-host preview above is fine for ephemeral branches."
       end
+
+      # Per-worktree databases: list/create/drop, plus orphan cleanup.
+      # `db list` shows every claimed database with its worktree dir.
+      # `db create` resolves this worktree's name and creates it.
+      # `db drop <name>` drops one database (refuses without --force
+      # when its worktree still exists).
+      def db(ctx, args)
+        sub = args.first
+        case sub
+        when "list", nil then db_list(ctx)
+        when "create" then db_create(ctx)
+        when "drop" then db_drop(ctx, args[1..] || [])
+        else raise Error, "Usage: yamine db [list|create|drop <name> [--force]]"
+        end
+      end
+
+      def db_list(ctx)
+        map = Database.load_map(ctx.store.dir)
+        if map.empty?
+          puts "No worktree databases claimed yet."
+          puts "Boot an app with a DATABASE_URL template to create one."
+          return
+        end
+        map.each do |name, info|
+          alive = File.directory?(info["dir"]) ? "" : " (worktree gone)"
+          puts "  #{name}  ->  #{info["dir"]}#{alive}"
+        end
+      end
+
+      def db_create(ctx)
+        resolved = Resolver.resolve(Dir.pwd)
+        name = Database.name_for(Dir.pwd, env: boot_env_name,
+          state_dir: ctx.store.dir)
+        template = ENV["DATABASE_URL"]
+        unless template && !template.strip.empty?
+          $stderr.puts "Error: set DATABASE_URL (template with host/user; database segment is replaced)."
+          exit 1
+        end
+        if Database.ensure_exists(name, template)
+          puts "Database #{name} ready."
+        else
+          $stderr.puts "Error: could not create #{name}. Check the database server is running."
+          exit 1
+        end
+      end
+
+      def db_drop(ctx, args)
+        force = args.delete("--force")
+        name = args.first
+        raise Error, "Usage: yamine db drop <name> [--force]" unless name
+
+        map = Database.load_map(ctx.store.dir)
+        info = map[name]
+        if info && File.directory?(info["dir"]) && !force
+          $stderr.puts "Error: worktree #{info["dir"]} still exists. Use --force to drop #{name} anyway."
+          exit 1
+        end
+        if drop_database(ctx, name)
+          map.delete(name)
+          Database.save_map(ctx.store.dir, map)
+          puts "Dropped #{name}."
+        else
+          $stderr.puts "Error: could not drop #{name}."
+          exit 1
+        end
+      end
+
+      def drop_database(_ctx, name)
+        template = ENV["DATABASE_URL"]
+        return false unless template && !template.strip.empty?
+
+        case Database.adapter_for(template)
+        when :postgres
+          uri = URI.parse(template)
+          _out, status = Open3.capture2("dropdb", name, env: Database.pg_env(uri))
+          status.success?
+        when :mysql
+          uri = URI.parse(template)
+          args = ["-h", uri.host || "127.0.0.1", "-u",
+                  URI.decode_www_form_component(uri.user || "root")]
+          _out, status = Open3.capture2("mysqladmin", *args, "drop", name, "-f")
+          status.success?
+        else
+          false
+        end
+      rescue SystemCallError
+        false
+      end
+
+      def boot_env_name
+        ENV.fetch("RAILS_ENV", "development")
+      end
+
+      # Worktree helpers: list claimed databases with liveness, clean
+      # drops databases whose worktree dirs are gone.
+      def worktree(ctx, args)
+        sub = args.first
+        case sub
+        when "list", nil
+          map = Database.load_map(ctx.store.dir)
+          if map.empty?
+            puts "No worktree databases claimed yet."
+            return
+          end
+          map.each do |name, info|
+            alive = File.directory?(info["dir"]) ? "alive" : "gone"
+            puts "  #{name}  #{info["dir"]}  (#{alive})"
+          end
+        when "clean"
+          orphaned = Database.orphaned(ctx.store.dir)
+          if orphaned.empty?
+            puts "No orphaned worktree databases."
+            return
+          end
+          orphaned.each do |name, _info|
+            if drop_database(ctx, name)
+              puts "Dropped orphaned #{name}."
+            else
+              $stderr.puts "Could not drop #{name} — remove manually."
+            end
+          end
+          map = Database.load_map(ctx.store.dir)
+          orphaned.each_key { |name| map.delete(name) }
+          Database.save_map(ctx.store.dir, map)
+        else
+          raise Error, "Usage: yamine worktree [list|clean]"
+        end
+      end
     end
   end
 end

data/lib/yamine/cli.rb

@@ -10,7 +10,7 @@ module Yamine
   # In non-interactive environments (no TTY or CI=1) we fail early with
   # a clear message instead of prompting (portless lesson).
   class CLI
-    SUBCOMMANDS = %w[run get alias hosts list doctor trust clean prune proxy service sudoers kamal stop restart log status open setup start init].freeze
+    SUBCOMMANDS = %w[run get alias hosts list doctor trust clean prune proxy service sudoers kamal stop restart log status open setup start init db worktree].freeze
 
     def self.run(argv)
       new.run(argv)
@@ -47,6 +47,8 @@ module Yamine
       when "setup" then SystemCommand.setup(ctx, args)
       when "init" then SystemCommand.init(ctx, args)
       when "start" then SystemCommand.start(ctx, args)
+      when "db" then SystemCommand.db(ctx, args)
+      when "worktree" then SystemCommand.worktree(ctx, args)
       when "kamal" then SystemCommand.kamal(ctx, args)
       when "stop"
         exit RoutesCommand.stop(ctx, args)
@@ -81,6 +83,8 @@ module Yamine
           yamine trust                  Add local CA to trust store
           yamine clean                  Remove state and hosts entries
           yamine prune                  Remove stale routes
+          yamine db list|create|drop      Per-worktree databases
+          yamine worktree list|clean     Worktree databases + orphan cleanup
           yamine proxy start|stop       Control the proxy
           yamine service install|status|uninstall   OS startup service
           yamine sudoers                Print scoped passwordless-sudo rules for port 443

data/lib/yamine/database.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require "digest"
+require "fileutils"
+require "json"
+require "open3"
+
+module Yamine
+  # Per-worktree databases. Every worktree directory gets its own database
+  # so concurrent agents never share tables: no migration races, no seed
+  # pollution, no schema drift between branches.
+  #
+  # Naming: <sanitized-dir-basename>_<env> — e.g. /Users/kaka/code/myapp-fix
+  # becomes myapp_fix_development. The branch a worktree has checked out is
+  # irrelevant and mutable, so it plays no part; the directory is stable.
+  # The main checkout keeps the bare <basename>_<env> name. Postgres
+  # identifiers cap at 63 bytes; overlong names truncate with a hash
+  # suffix (same rule as hostname labels).
+  #
+  # Collision guard: two directories can sanitize identically
+  # (myapp-fix vs myapp_fix). A state file records which directory
+  # claimed which name first; on collision the newcomer gets a short
+  # hash suffix. Silent sharing would be exactly the bug this exists to
+  # kill, so the check is mandatory, not best-effort.
+  #
+  # Framework-agnostic: yamine injects DATABASE_URL and never touches
+  # framework files. SQLite needs nothing (relative paths already isolate
+  # per worktree). Creation runs the app's own schema-load command from
+  # config/local.yml — never assumed.
+  module Database
+    module_function
+
+    MAX_IDENTIFIER_BYTES = 63
+    STATE_FILE = "databases.json"
+
+    # Database name for a worktree dir + env (development/test).
+    # Main checkout (no worktree marker) keeps the bare name.
+    def name_for(dir, env: "development", state_dir: nil)
+      base = sanitize(File.basename(File.expand_path(dir)))
+      name = "#{base}_#{env}"
+      name = truncate(name)
+      claimed = claim(name, dir, state_dir: state_dir)
+      claimed || "#{truncate("#{base}_#{short_hash(dir)}")}_#{env}"
+    end
+
+    # The main checkout is the one whose .git is a directory (linked
+    # worktrees have a .git FILE pointing into /worktrees/). Main keeps
+    # the bare name; only linked worktrees get suffixed names... in
+    # practice every dir gets the mapping, but main's mapping is itself.
+    def main_checkout?(dir)
+      File.directory?(File.join(File.expand_path(dir), ".git"))
+    end
+
+    def sanitize(name)
+      name.downcase.gsub(/[^a-z0-9_]/, "_").gsub(/_+/, "_").gsub(/\A_+|_+\z/, "")
+    end
+
+    def truncate(name)
+      return name if name.bytesize <= MAX_IDENTIFIER_BYTES
+
+      hash = Digest::SHA256.hexdigest(name)[0, 6]
+      prefix = name.byteslice(0, MAX_IDENTIFIER_BYTES - 7).gsub(/_+\z/, "")
+      "#{prefix}_#{hash}"
+    end
+
+    def short_hash(dir)
+      Digest::SHA256.hexdigest(File.expand_path(dir))[0, 6]
+    end
+
+    # Record dir -> name claim; returns the name if ours (or unclaimed),
+    # nil if another dir claimed it first (caller must suffix).
+    def claim(name, dir, state_dir: nil)
+      return name unless state_dir
+
+      dir = File.expand_path(dir)
+      map = load_map(state_dir)
+      if map.key?(name) && map[name]["dir"] != dir
+        return nil
+      end
+      map[name] = { "dir" => dir, "claimed_at" => Time.now.utc.iso8601 }
+      save_map(state_dir, map)
+      name
+    rescue SystemCallError
+      name
+    end
+
+    def load_map(state_dir)
+      path = File.join(state_dir, STATE_FILE)
+      return {} unless File.file?(path)
+
+      JSON.parse(File.read(path))
+    rescue JSON::ParserError, SystemCallError
+      {}
+    end
+
+    def save_map(state_dir, map)
+      FileUtils.mkdir_p(state_dir)
+      File.write(File.join(state_dir, STATE_FILE), JSON.pretty_generate(map))
+    rescue SystemCallError
+      nil
+    end
+
+    # Databases whose worktree dirs no longer exist (for `worktree clean`).
+    def orphaned(state_dir)
+      load_map(state_dir).select { |_, v| !File.directory?(v["dir"]) }
+    end
+
+    # Adapter detection from DATABASE_URL scheme. Returns :postgres,
+    # :mysql, :sqlite, or :unknown. Only postgres/mysql get create +
+    # DATABASE_URL treatment; sqlite is left alone (relative paths
+    # already isolate per worktree).
+    def adapter_for(database_url)
+      str = database_url.to_s.strip
+      return :sqlite if str.empty?
+
+      scheme = str[/\A[a-z0-9+]+/i].to_s.downcase
+      case scheme
+      when "postgres", "postgresql" then :postgres
+      when "mysql", "mysql2" then :mysql
+      when "sqlite", "sqlite3" then :sqlite
+      else :unknown
+      end
+    end
+
+    # Build a DATABASE_URL for name from a template URL (host, port, user
+    # preserved; database segment replaced). Returns nil when the template
+    # is absent or sqlite.
+    def url_for(name, template_url)
+      return nil if template_url.nil? || template_url.strip.empty?
+      return nil if adapter_for(template_url) == :sqlite
+
+      uri = URI.parse(template_url)
+      uri.path = "/#{name}"
+      uri.to_s
+    rescue URI::InvalidURIError
+      nil
+    end
+
+    # Create the database if missing. Uses createdb/mysqladmin when
+    # available; returns true/false, never raises (boot reports, not dies).
+    def ensure_exists(name, database_url)
+      case adapter_for(database_url)
+      when :postgres then ensure_postgres(name, database_url)
+      when :mysql then ensure_mysql(name, database_url)
+      else false
+      end
+    end
+
+    def ensure_postgres(name, database_url)
+      uri = URI.parse(database_url)
+      env = pg_env(uri)
+      _out, status = Open3.capture2(env, "psql", "-lqt")
+      return false unless status.success?
+
+      exists = Open3.capture2(env, "psql", "-lqt")[0].split("\n").any? do |line|
+        line.split("|").first.to_s.strip == name
+      end
+      return true if exists
+
+      _out, status = Open3.capture2(env, "createdb", name)
+      status.success?
+    rescue SystemCallError
+      false
+    end
+
+    def ensure_mysql(name, database_url)
+      uri = URI.parse(database_url)
+      args = ["-h", uri.host || "127.0.0.1", "-P", (uri.port || 3306).to_s,
+              "-u", URI.decode_www_form_component(uri.user || "root")]
+      args += ["-p#{URI.decode_www_form_component(uri.password)}"] if uri.password
+      _out, status = Open3.capture2("mysqladmin", *args, "create", name)
+      status.success? || already_exists_mysql(args, name)
+    rescue SystemCallError
+      false
+    end
+
+    def already_exists_mysql(args, name)
+      out, status = Open3.capture2("mysql", *args, "-e", "SHOW DATABASES;")
+      status.success? && out.split("\n").include?(name)
+    rescue SystemCallError
+      false
+    end
+
+    def pg_env(uri)
+      {
+        "PGHOST" => uri.host || "127.0.0.1",
+        "PGPORT" => (uri.port || 5432).to_s,
+        "PGUSER" => URI.decode_www_form_component(uri.user || ENV["USER"].to_s),
+        "PGPASSWORD" => uri.password ? URI.decode_www_form_component(uri.password) : nil
+      }.compact
+    end
+  end
+end

data/lib/yamine/runner.rb

@@ -92,9 +92,10 @@ module Yamine
     # 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, register: true)
+      rails_dev_host: nil, register: true, database_url: nil)
       port ||= Ports.find_free
-      env = child_env(dir, url: url, port: port, rails_dev_host: rails_dev_host)
+      env = child_env(dir, url: url, port: port, rails_dev_host: rails_dev_host,
+        database_url: database_url)
       pid = with_clean_env { spawn(env, *command, chdir: dir) }
       Process.detach(pid)
       target = "127.0.0.1:#{port}"
@@ -106,7 +107,7 @@ module Yamine
         target: target, kind: "tcp", command: command)
     end
 
-    def child_env(dir, url:, port:, rails_dev_host: nil)
+    def child_env(dir, url:, port:, rails_dev_host: nil, database_url: nil)
       env = { "YAMINE_URL" => url }
       env["PORT"] = port.to_s if port
       env["HOST"] = "127.0.0.1"
@@ -116,6 +117,10 @@ module Yamine
       # proxied hostname so Rails apps boot behind yamine with zero
       # config — this replaces the yamine-rails hosts patch.
       env["RAILS_DEVELOPMENT_HOSTS"] = rails_dev_host if rails_dev_host
+      # Per-worktree database: every process in this worktree shares one
+      # isolated database. Frameworks that honor DATABASE_URL (Rails,
+      # Django, most Node) get isolation for free; others ignore it.
+      env["DATABASE_URL"] = database_url if database_url
       env
     end
 

data/lib/yamine/version.rb

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

data/lib/yamine.rb

@@ -3,6 +3,7 @@
 require_relative "yamine/version"
 require_relative "yamine/errors"
 require_relative "yamine/agent"
+require_relative "yamine/database"
 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.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Kaka Ruto
@@ -91,6 +91,7 @@ files:
 - lib/yamine/cli/system.rb
 - lib/yamine/command.rb
 - lib/yamine/config.rb
+- lib/yamine/database.rb
 - lib/yamine/doctor.rb
 - lib/yamine/errors.rb
 - lib/yamine/framework.rb