foruiman 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 726795acd4c4991d3a924364ec484ca7ec1e7051b8c9a660a53e6b8ecd1759f8
-  data.tar.gz: 0c24bdd2fded37d051b8bb0e771991b0284893888a89b3a461662d2cc483dee4
+  metadata.gz: 906d36f65025e56552898118d3a3e5fec8b81c6046f32a7df9c627f048a89aa6
+  data.tar.gz: af7c8f777be7302aca9bd3e5cb50a17cc9acd9e2c6036e5d5b8033779d0a492f
 SHA512:
-  metadata.gz: 68b7fa94a095c09fc3ed636165ee88db37640d24aa2ede0b4d2c417680cf2655910b881ad2180116babc701949c91cc9f751f2e0b67f222d081f71ca9153a178
-  data.tar.gz: 22ec4c35cd32fd23d897ca2de19d72d5c219b53d0b86019f3fc3f562b3436371bd353ca5119aac2d4e1c559c68ddca37984c53b68e5e036cc12538e04f71321e
+  metadata.gz: b24d2f3e374331fe3c054c7930f5f1e5cd1e9bcc12e85befa8aeaf7bf8c367b70ab67942c19ac8a3fed56930ce9236a3cf422121a84bc2043584356450035ae0
+  data.tar.gz: 2b78d3244f014e4cf2e4959a8bedb62b308fb04c38fc8326d151d015983feeb8373a346852f2e730360b4e31a10a591dc63e410990e861571351646201ac9026

data/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## Unreleased
 
+## 0.3.0
+
+- Add `.foreman` YAML defaults with explicit CLI overrides and validated options.
+- Add `run` for one-off commands and named Procfile entries, preserving terminal
+  input, argument boundaries, signals, and exit status.
+- Match Foreman's explicit environment-file replacement, comma-separated loading,
+  environment `PORT` fallback, and Procfile/root path handling. See the migration
+  notes for changes from 0.2.
+- Add `-t` / `--timeout` and `--exit-on all|any|failure`. Automatic group shutdown
+  preserves the triggering exit code and cleans up descendants and pending restarts.
+
 ## 0.2.0
 
 - Keep child stdin open so default watcher modes continue running.

data/README.md

@@ -38,6 +38,8 @@ Useful commands:
 foruiman start -f Procfile.dev  # use another Procfile
 foruiman start web              # run one process
 foruiman start --no-tui         # stream plain logs
+foruiman run bin/rails console  # one-off command with the app environment
+foruiman start --exit-on any    # stop the group when a process exits
 foruiman check                  # validate without starting
 foruiman --version
 ```
@@ -59,13 +61,19 @@ process tab, `s` starts it again.
 | Option | Default | Purpose |
 | --- | --- | --- |
 | `-f`, `--procfile FILE` | `Procfile` | Procfile to run |
-| `-d`, `--root DIR` | Current directory | Working directory |
-| `-e`, `--env FILE` | None | Additional environment file |
+| `-d`, `--root DIR` | Procfile directory | Working directory |
+| `-e`, `--env FILES` | `.env` | Comma-separated files, loaded in order instead of `.env` |
 | `--no-dotenv` | `.env` enabled | Skip `.env` |
-| `-p`, `--port PORT` | `5000` | Base port; entries increment by 100 |
+| `-p`, `--port PORT` | Environment `PORT`, then `5000` | Base port; entries increment by 100 |
+| `-t`, `--timeout SECONDS` | `5` | Grace period before forced shutdown |
+| `--exit-on all\|any\|failure` | `all` | Keep peers running, stop on any exit, or stop on failure |
 | `--log-lines N` | `10000` | Retained records per process and in `all` |
 | `--no-tui` | TUI when interactive | Force plain output |
 
+Set defaults in a `.foreman` YAML file in the invocation directory; CLI flags
+override them. See [compatibility and migration notes](docs/COMPATIBILITY.md) for
+path rules, supported settings, and changes from 0.2.
+
 ## Keyboard
 
 | Key | Action |

data/docs/ARCHITECTURE.md

@@ -4,6 +4,9 @@
 `Env` retains its quoting rules and adds a non-mutating precedence merge. `Process`
 wraps `/bin/sh -c` with a new process group, two output streams, and configurable stdin.
 `CLI < Thor` validates the full configuration before starting the engine.
+`Configuration` safely loads `.foreman` defaults, merges explicit CLI values,
+resolves Foreman-compatible paths and environments, and validates numeric options.
+`run` uses `exec` for one-off commands with direct terminal IO and exact exit status.
 
 `Engine` owns registration, PID/group tracking, nonblocking pipes, child reaping,
 and lifecycle transitions. A single caller thread drives all mutations. Signal
@@ -47,8 +50,10 @@ Call engine methods and event listeners on the driving thread; this is not a
 cross-thread messaging API. `run` handles INT/TERM/HUP and restores existing
 handlers. An embedding loop that drives `tick` directly owns its signal handling.
 `close` disconnects observers so a failed renderer/output consumer cannot prevent
-process cleanup. `term_timeout:` exists for deterministic embedded tests; CLI
-shutdown always uses five seconds. `state(name)` exposes lifecycle state for
+process cleanup. `term_timeout:` controls the shutdown grace period (CLI `-t`,
+default five seconds). `exit_on: :all` retains independent processes; `:any` or
+`:failure` requests group shutdown after a qualifying natural exit and preserves
+its exit code. Intentional stops/restarts do not trigger the policy. `state(name)` exposes lifecycle state for
 rendering; callers should not mutate it.
 
 Children inherit the configured input stream in plain and embedded use. Before

data/docs/COMPATIBILITY.md

@@ -1,26 +1,74 @@
 # Intentional differences from Foreman
 
-Foruiman is a fork-derived MVP, not a drop-in replacement for every Foreman feature.
+Foruiman supports common Foreman development workflows. It is not a drop-in
+replacement for every Foreman feature.
 
 | Area | Foruiman behavior |
 | --- | --- |
-| Identity | `foruiman` gem/executable, `Foruiman` namespace, version 0.2.0 |
+| Identity | `foruiman` gem/executable, `Foruiman` namespace, version 0.3.0 |
 | Runtime | Ruby 3.2+, POSIX process groups; Linux CI |
-| CLI | Thor-based `start [PROCESS]`, `check`, `version`, and `help` |
-| Excluded features | No export, scaling/formation, `run`, `.foreman` YAML, custom shutdown timeout, forced color, or timestamp toggle |
+| CLI | Thor-based `start [PROCESS]`, `run COMMAND [ARGS...]`, `check`, `version`, and `help` |
+| Excluded features | No export, scaling/formation, forced color, or timestamp toggle |
 | Procfile validation | Reject malformed lines, duplicates, empty commands, and reserved `all`; report line numbers |
-| Working directory | Invocation directory unless `-d`; moving a Procfile does not change child cwd |
-| Environment | Optional `.env` then explicit env file; parent `ENV` stays untouched |
-| Ports | 5000 or `-p`, plus 100 per original entry; `PORT` in the environment is overridden |
+| Working directory | Procfile directory unless `-d`; explicit `-f` and `-e` paths resolve from invocation |
+| Environment | Explicit `-e file1,file2` replaces default `.env` loading; later files win; parent `ENV` stays untouched |
+| Ports | `-p` or `.foreman` port, then loaded `PORT`, then 5000; plus 100 per original entry |
 | Expansion | `/bin/sh -c` performs shell expansion; no Ruby string substitution |
 | Instances | Exactly one instance per entry; `PS=name.1` |
-| Failures | Independent process failures; peers keep running |
+| Failures | Independent by default; `--exit-on any` stops on any natural exit, `failure` only on an unsuccessful exit |
 | Restart | Stop only the affected group, wait for descendants and output, then replace |
-| Shutdown | TERM, five-second grace, KILL; track groups after leader exit; restore prior signal handlers |
+| Shutdown | TERM, configurable `-t` grace (default five seconds), KILL; track groups after leader exit; restore prior signal handlers |
 | Output | Separate stdout/stderr metadata; bounded logs and live partial records |
 | Terminal | Tabs, independent scroll/follow, restart, start/stop, and selected-process input controls |
-| Plain exit | Wait for all processes; status 0/1; explicit orderly shutdown returns 0 |
-| Interactive exit | Remain open after all processes exit; quit explicitly |
+| Plain exit | Default status 0/1; automatic group shutdown preserves its triggering exit code (128 + signal for a signal exit); explicit orderly shutdown returns 0 |
+| Interactive exit | Remain open after all processes exit by default; automatic shutdown policies close the TUI after cleanup |
+
+## Configuration and paths
+
+Like Foreman, `.foreman` is read from the invocation directory. Use long option
+names; CLI flags override YAML values. Supported keys are `procfile`, `root`, `env`,
+`port`, `timeout`, `dotenv`, `tui`, `log-lines`, and `exit-on` (underscores also work).
+Unsupported keys, including `formation`, produce an error instead of being ignored.
+YAML object tags and aliases are not supported.
+
+```yaml
+procfile: Procfile.dev
+port: 3000
+timeout: 10
+exit-on: any
+```
+
+An explicit `-f` path is relative to invocation, even when `-d` is supplied. Without
+`-f`, the Procfile is `<root>/Procfile`. Without `-d`, child commands run in the
+Procfile's directory. Default `.env` loading follows Foreman's CLI: use the explicit
+`-d` directory when supplied, otherwise the invocation directory. An inferred root
+from `-f` does not move the default `.env` lookup. Explicit `-e` paths always resolve
+from invocation. `--no-dotenv` disables only default `.env` loading.
+
+## One-off commands
+
+`foruiman run bin/rails console` uses the same environment-file rules and passes
+stdin, stdout, and stderr directly to the command. No Procfile is required. A
+single argument matching a Procfile entry runs that entry's shell command.
+Other commands retain their exact argument boundaries. For shell operators, use
+`foruiman run sh -c 'command1 && command2'`. Put Foruiman options before the command;
+options after the command belong to that command.
+
+`run` replaces Foruiman with the command, preserving signals and exit status. It
+does not generate per-process `PORT` or `PS` values or open the TUI.
+
+## Migrating from 0.2
+
+- `-e custom.env` now replaces `.env`. Use `-e .env,custom.env` to retain layering.
+- Environment `PORT` now selects the base port. Use `-p 5000` to retain the old default.
+- A nested `-f` changes the default child working directory. Add `-d .` to keep
+  invocation as the working directory. With `-d app`, an old `-f config/Procfile.dev`
+  becomes `-f app/config/Procfile.dev` when that file lives inside `app`.
+- A `.foreman` file now supplies defaults. Remove unsupported keys before using it.
+
+Use `--exit-on any` for Foreman's stop-on-first-exit behavior. Intentional TUI
+stops and restarts do not trigger that policy. Exact Foreman log formatting,
+USR1/USR2 forwarding, and its Ruby embedding API remain outside compatibility.
 
 Full-screen child terminal applications and background daemonization are outside
 this release. Remote process control, persistence across Foruiman sessions,

data/docs/RAILS.md

@@ -35,7 +35,18 @@ foruiman start -f Procfile.dev -p 3000
 
 The second example assigns 3000 to `web`, 3100 to `worker`, and 3200 to `css`.
 Only programs that consume their generated `PORT` use those values. The base port
-is set with `-p`; a `PORT` assignment in `.env` does not set it.
+comes from `-p` or `.foreman`, then `PORT` in the loaded environment, then 5000.
+
+Run a Rails command using the same environment without starting the Procfile:
+
+```sh
+foruiman run bin/rails console
+foruiman run -e .env,.env.local bin/rails db:migrate
+```
+
+Explicit `-e` files replace default `.env` loading, so include `.env` in the list
+when layering local overrides. For Foreman-style group shutdown and a longer grace
+period, use `foruiman start -f Procfile.dev --exit-on any -t 10`.
 
 An optional `bin/dev`:
 

data/lib/foruiman/cli.rb

@@ -4,31 +4,38 @@ require "thor"
 require "foruiman"
 require_relative "plain"
 require_relative "diagnostics"
+require_relative "configuration"
 
-# Foreman's Thor command structure, reduced to the MVP surface.
+# Foreman's Thor command structure with an interactive supervisor.
 class Foruiman::CLI < Thor
   map ["-v", "--version"] => :version
   default_task :start
   check_unknown_options!
   remove_command :tree
 
-  class_option :procfile, type: :string, aliases: "-f", default: "Procfile", desc: "Procfile to read"
-  class_option :root, type: :string, aliases: "-d", desc: "Working directory (default: invocation directory)"
-  class_option :env, type: :string, aliases: "-e", desc: "Environment file layered after .env"
-  class_option :dotenv, type: :boolean, default: true, desc: "Load optional .env from working directory"
-  class_option :port, type: :string, aliases: "-p", default: "5000", desc: "Base port (increments by 100)"
-  class_option :log_lines, type: :string, default: "10000", desc: "Maximum records per process and in all"
+  class_option :procfile, type: :string, aliases: "-f", desc: "Procfile to read (default: Procfile)"
+  class_option :root, type: :string, aliases: "-d", desc: "Working directory (default: Procfile directory)"
+  class_option :env, type: :string, aliases: "-e", desc: "Comma-separated environment files instead of .env"
+  class_option :dotenv, type: :boolean, desc: "Load default .env when -e is absent (default: true)"
+  class_option :port, type: :string, aliases: "-p", desc: "Base port (default: PORT or 5000)"
+  class_option :log_lines, type: :string, desc: "Maximum records per process and in all (default: 10000)"
+  class_option :timeout, type: :string, aliases: "-t", desc: "Seconds before escalating TERM to KILL (default: 5)"
+  class_option :exit_on, type: :string, desc: "Shutdown policy: all, any, failure (default: all)"
+
+  def self.is_thor_reserved_word?(word, type) # rubocop:disable Naming/PredicatePrefix -- Thor's extension API
+    word == "run" ? false : super
+  end
 
   def self.exit_on_failure?
     true
   end
 
   desc "start [PROCESS]", "Run the Procfile with process tabs, or stream logs without a TTY"
-  method_option :tui, type: :boolean, default: true, desc: "Use the terminal interface when stdin and stdout are TTYs"
+  method_option :tui, type: :boolean, desc: "Use the terminal interface when stdin and stdout are TTYs (default: true)"
   def start(process = nil)
     engine = build_engine
     engine.select(process) if process
-    interactive = options[:tui] && $stdin.tty? && $stdout.tty?
+    interactive = configuration.tui? && $stdin.tty? && $stdout.tty?
     diagnostics = Foruiman::Diagnostics.new(interactive: interactive)
     code = if interactive
              require_relative "tui/application"
@@ -48,6 +55,24 @@ class Foruiman::CLI < Thor
     diagnostics&.close
   end
 
+  desc "run COMMAND [ARGS...]", "Run a command or Procfile entry with the application's environment"
+  stop_on_unknown_option! :run
+  def run(*args)
+    raise Foruiman::Error, "run requires a command" if args.empty?
+
+    config = configuration
+    env = config.environment
+    command = Foruiman::Procfile.new(config.procfile)[args.first] if args.size == 1 && File.file?(config.procfile)
+    if command
+      exec(env, "/bin/sh", "-c", command, chdir: config.root, unsetenv_others: true)
+    else
+      # Preserve argv, terminal input, signals and the command's exact exit code.
+      exec(env, [args.first, args.first], *args.drop(1), chdir: config.root, unsetenv_others: true)
+    end
+  rescue Foruiman::Error, SystemCallError => e
+    raise Thor::Error, e.message
+  end
+
   desc "check", "Validate the Procfile, environment files, ports, and log capacity without starting processes"
   def check
     engine = build_engine
@@ -65,19 +90,15 @@ class Foruiman::CLI < Thor
 
   private
 
-  def integer_option(name)
-    text = options.fetch(name).to_s
-    raise Foruiman::Error, "#{name.to_s.tr('_', '-')} must be a positive integer" unless text.match?(/\A[0-9]+\z/)
-
-    text.to_i
+  def configuration
+    @configuration ||= Foruiman::Configuration.new(options)
   end
 
   def build_engine
-    root = File.expand_path(options[:root] || Dir.pwd)
-    procfile = File.expand_path(options[:procfile], root)
-    file = File.expand_path(options[:env], root) if options[:env]
-    env = Foruiman::Env.load(root: root, file: file, dotenv: options[:dotenv])
-    Foruiman::Engine.new(procfile: procfile, root: root, env: env,
-                         port: integer_option(:port), log_lines: integer_option(:log_lines))
+    config = configuration
+    env = config.environment
+    Foruiman::Engine.new(procfile: config.procfile, root: config.root, env: env,
+                         port: config.port(env), log_lines: config.log_lines,
+                         term_timeout: config.timeout, exit_on: config.exit_on)
   end
 end

data/lib/foruiman/configuration.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+class Foruiman::Configuration
+  OPTIONS = %w[procfile root env dotenv port log_lines timeout exit_on tui].freeze
+  BOOLEAN_OPTIONS = %w[dotenv tui].freeze
+  PATH_OPTIONS = %w[procfile root env].freeze
+
+  def initialize(options, directory: Dir.pwd)
+    @directory = directory
+    @options = defaults.merge(options.to_h.transform_keys { |key| key.to_s.tr("-", "_") })
+    BOOLEAN_OPTIONS.each do |key|
+      next unless @options.key?(key)
+      next if [true, false].include?(@options[key])
+
+      raise Foruiman::Error, "#{key}: expected true or false"
+    end
+    PATH_OPTIONS.each do |key|
+      next unless @options.key?(key)
+      next if @options[key].is_a?(String) && !@options[key].empty?
+
+      raise Foruiman::Error, "#{key}: expected a nonempty path"
+    end
+  end
+
+  def procfile
+    # Foreman's explicit -f is relative to invocation, independently of -d.
+    File.expand_path(@options.fetch("procfile", File.join(@options.fetch("root", "."), "Procfile")), @directory)
+  end
+
+  def root
+    File.expand_path(@options.fetch("root", File.dirname(procfile)), @directory)
+  end
+
+  def environment
+    # Foreman loads the default environment before inferring a root from -f.
+    env_root = File.expand_path(@options.fetch("root", "."), @directory)
+    files = @options["env"]&.split(",", -1)&.map do |file|
+      raise Foruiman::Error, "env: expected comma-separated file paths" if file.empty?
+
+      File.expand_path(file, @directory)
+    end
+    Foruiman::Env.load(root: env_root, file: files, dotenv: @options.fetch("dotenv", true))
+  end
+
+  def port(env)
+    integer("port", @options.fetch("port") { env.fetch("PORT", "5000") })
+  end
+
+  def log_lines
+    integer("log_lines", @options.fetch("log_lines", "10000"))
+  end
+
+  def timeout
+    value = Float(@options.fetch("timeout", 5), exception: false)
+    return value if value&.finite? && value >= 0
+
+    raise Foruiman::Error, "timeout must be a finite nonnegative number"
+  end
+
+  def exit_on
+    value = @options.fetch("exit_on", "all")
+    return value.to_sym if %w[all any failure].include?(value)
+
+    raise Foruiman::Error, "exit-on must be all, any, or failure"
+  end
+
+  def tui?
+    @options.fetch("tui", true)
+  end
+
+  private
+
+  def integer(name, value)
+    text = value.to_s
+    unless text.match?(/\A[0-9]+\z/) && text.to_i.positive?
+      raise Foruiman::Error, "#{name.tr('_', '-')} must be a positive integer"
+    end
+
+    text.to_i
+  end
+
+  def defaults
+    path = File.join(@directory, ".foreman")
+    return {} unless File.file?(path)
+
+    values = YAML.safe_load_file(path, permitted_classes: [], permitted_symbols: [], aliases: false)
+    return {} if values.nil?
+    raise Foruiman::Error, "#{path}: expected a YAML mapping of option names to values" unless values.is_a?(Hash)
+
+    values.each_with_object({}) do |(key, value), result|
+      name = key.to_s.tr("-", "_")
+      raise Foruiman::Error, "#{path}: unsupported option #{key.inspect}" unless OPTIONS.include?(name)
+
+      result[name] = value
+    end
+  rescue Psych::Exception => e
+    raise Foruiman::Error, "#{path}: #{e.message}"
+  end
+end

data/lib/foruiman/engine.rb

@@ -18,12 +18,16 @@ class Foruiman::Engine
                      keyword_init: true)
   Event = Data.define(:type, :name, :pid, :status, :record, :message)
 
-  attr_reader :logs, :env, :processes, :root, :procfile_path
+  attr_reader :logs, :env, :processes, :root, :procfile_path, :term_timeout, :exit_on
 
   def initialize(procfile: nil, root: Dir.pwd, env: ENV.to_h, input: $stdin, port: 5000, log_lines: 10_000,
-                 term_timeout: TERM_TIMEOUT)
+                 term_timeout: TERM_TIMEOUT, exit_on: :all)
     raise Foruiman::Error, "port must be an integer in 1..65535" unless port.is_a?(Integer) && (1..65_535).cover?(port)
     raise Foruiman::Error, "log-lines must be a positive integer" unless log_lines.is_a?(Integer) && log_lines.positive?
+    unless term_timeout.is_a?(Numeric) && term_timeout.real? && term_timeout.finite? && term_timeout >= 0
+      raise Foruiman::Error, "timeout must be a finite nonnegative number"
+    end
+    raise Foruiman::Error, "exit-on must be all, any, or failure" unless %i[all any failure].include?(exit_on)
 
     @root = File.expand_path(root)
     raise Foruiman::Error, "working directory does not exist: #{@root}" unless File.directory?(@root)
@@ -34,6 +38,7 @@ class Foruiman::Engine
     @base_port = port
     @log_lines = log_lines
     @term_timeout = term_timeout
+    @exit_on = exit_on
     @processes = []
     @names = {}
     @running = {}
@@ -208,7 +213,9 @@ class Foruiman::Engine
   end
 
   def exit_code
-    @explicit_shutdown || !@failed ? 0 : 1
+    return 0 if @explicit_shutdown
+
+    @policy_exit_code || (@failed ? 1 : 0)
   end
 
   def run(keep_open: false)
@@ -282,6 +289,7 @@ class Foruiman::Engine
       entry.restart_pending = false
       @failed = true
       lifecycle(entry, :failed, "failed to start: #{e.message}")
+      apply_exit_policy(1)
       return
     end
     entry.pid = entry.pgid = pid
@@ -337,10 +345,18 @@ class Foruiman::Engine
       @failed ||= !success && !transitioning
       entry.status = success ? :exited : :failed unless transitioning
       lifecycle(entry, :exited, termination_message_for(entry.exit_status))
+      apply_exit_policy(entry.exit_status.exitstatus || (128 + entry.exit_status.termsig)) unless transitioning
       terminate(entry)
     end
   end
 
+  def apply_exit_policy(code)
+    return if @shutdown || exit_on == :all || (exit_on == :failure && code.zero?)
+
+    @policy_exit_code = code
+    shutdown(explicit: false)
+  end
+
   def advance_groups
     processes.each do |entry|
       next unless entry.pgid

data/lib/foruiman/env.rb

@@ -28,8 +28,11 @@ class Foruiman::Env
   def self.load(root: Dir.pwd, file: nil, dotenv: true, inherited: ENV.to_h)
     env = inherited.dup
     default = File.join(root, ".env")
-    env.merge!(new(default).to_h) if dotenv && File.file?(default)
-    env.merge!(new(file).to_h) if file
+    if file
+      Array(file).each { |filename| env.merge!(new(filename).to_h) }
+    elsif dotenv && File.file?(default)
+      env.merge!(new(default).to_h)
+    end
     env.transform_values { |value| value.dup.freeze }.freeze
   end
 end

data/lib/foruiman/tui/renderer.rb

@@ -256,7 +256,8 @@ module Foruiman::TUI
 
       quit = @theme.paint(" q ", :accent, bold: true) + @theme.paint(" × quit ", :muted)
       left = if engine.shutting_down?
-               @theme.paint(" ◌ Stopping process groups · TERM → KILL after 5s", :amber)
+               seconds = format("%g", engine.term_timeout)
+               @theme.paint(" ◌ Stopping process groups · TERM → KILL after #{seconds}s", :amber)
              elsif state.feedback
                @theme.paint(" #{state.feedback}", :amber)
              elsif state.help

data/lib/foruiman/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foruiman
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Foruiman contributors
@@ -70,6 +70,7 @@ files:
 - lib/foruiman.rb
 - lib/foruiman/ansi.rb
 - lib/foruiman/cli.rb
+- lib/foruiman/configuration.rb
 - lib/foruiman/diagnostics.rb
 - lib/foruiman/engine.rb
 - lib/foruiman/env.rb
@@ -112,7 +113,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 4.0.20
 specification_version: 4
 summary: A Procfile supervisor with process tabs, bounded logs, and isolated restarts
 test_files: []