foruiman 0.1.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0de0b215283d2c3dc89422aa9e6f6da235acf10f5ede3907afcf8e7c88dd9290
-  data.tar.gz: 81dfcdcfbc8d7ab445242fd5c07419192b6445e9caa3107fcdce5a2a027d914e
+  metadata.gz: 906d36f65025e56552898118d3a3e5fec8b81c6046f32a7df9c627f048a89aa6
+  data.tar.gz: af7c8f777be7302aca9bd3e5cb50a17cc9acd9e2c6036e5d5b8033779d0a492f
 SHA512:
-  metadata.gz: bb3cbdd6d6c38335bd5d6d4b467bbedec757cb2e534896b24d471c8b4275203d22cb22ec642fafe63410df21c1616322ae2e4616b0b26dce277959308f0092c5
-  data.tar.gz: 03db66ce62f3e21723aac3808791b2a027bb2ab497d415de11730661ff90b5150b82a0d7351ea2c156abc93be670e93a5b575933d06bf6a0fdcdcece35f7b517
+  metadata.gz: b24d2f3e374331fe3c054c7930f5f1e5cd1e9bcc12e85befa8aeaf7bf8c367b70ab67942c19ac8a3fed56930ce9236a3cf422121a84bc2043584356450035ae0
+  data.tar.gz: 2b78d3244f014e4cf2e4959a8bedb62b308fb04c38fc8326d151d015983feeb8373a346852f2e730360b4e31a10a591dc63e410990e861571351646201ac9026

data/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 ## 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.
+- Add per-process TTY input from the TUI: select a process, press `i`, and use
+  Ctrl-X to return to Foruiman. Ctrl-C interrupts the attached process group.
+- Add a command input bar with local backspace, cursor editing and per-process
+  history. Interpret debugger redraws instead of appending repeated prompts.
+- Make `s` stop a running selected process and start it again once stopped,
+  without affecting peers. Use clear `▶` running and `■` stopped glyphs.
+- Make `s` on the `all` tab stop every process, matching the scope of `r`.
+
 - Test Ruby 3.2, 3.3, 3.4, and 4.0 in a reusable CI workflow and keep the
   development dependency set compatible with Ruby 3.2.
 - Add a tag-driven RubyGems trusted-publishing workflow gated by the full CI suite.

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
 ```
@@ -46,18 +48,32 @@ The TUI opens when stdin and stdout are terminals. Otherwise, Foruiman streams
 plain logs and exits when the processes finish. Processes run independently, and
 restarting one process does not interrupt the others.
 
+Each TUI process gets its own open terminal input, so asset builders using their
+default `--watch` mode stay alive. Select a process and press `i` to type into a
+debugger such as Pry, Byebug or IRB. Edit in the input bar, press Enter to send,
+and Ctrl-X to return to Foruiman. Arrow keys edit and recall commands; Ctrl-C
+interrupts the selected process. Debugger tab completion is not forwarded.
+Press `s` to stop the selected process, or all processes from `all`; on a stopped
+process tab, `s` starts it again.
+
 ## Options
 
 | 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 |
@@ -69,9 +85,10 @@ restarting one process does not interrupt the others.
 | Home / `g` | Jump to oldest retained log |
 | End / `G` / `f` | Follow new output |
 | Space | Pause or resume following |
+| `i` / Ctrl-X | Open command input / return to Foruiman |
 | `r` | Restart the selected process, or all from `all` |
 | `R` | Restart all processes |
-| `s` / `S` | Stop selected / stop all |
+| `s` / `S` | Start/stop selected (`s` on `all` stops all) / stop all |
 | `?` / Escape | Toggle help / close help |
 | `q` / Ctrl-C | Stop processes and quit |
 

data/docs/ARCHITECTURE.md

@@ -2,8 +2,11 @@
 
 `Procfile` retains Foreman's ordered parser/writer API with strict file validation.
 `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 null stdin.
+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
@@ -35,6 +38,7 @@ begin
   engine.tick(timeout: 0.03)
   engine.restart("web")            # asynchronous; peers keep running
   engine.stop("worker")            # asynchronous
+  engine.start("worker")           # start it again once stopped
   engine.shutdown                  # cancels replacements and requests group cleanup
   engine.tick until engine.finished?
 ensure
@@ -46,10 +50,24 @@ 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
+startup, `manage_input!` gives each child a dedicated pseudo-terminal while the
+caller retains the real terminal; `write_input(name, bytes)` forwards input,
+`interrupt_process(name)` sends SIGINT to that process group, and `resize_inputs` keeps
+the pseudo-terminals sized with the UI. The TUI uses this mode so watch commands
+do not see EOF and only the selected process receives interactive input.
+
+The TUI edits commands locally in a bounded `InputLine`, with independent history
+for each process, then sends a complete line on Enter. Ctrl-X leaves input mode.
+`OutputLine` interprets carriage returns, backspaces, horizontal cursor moves and
+line erasure before recording child output; screen controls remain suppressed.
+
 `LogStore` uses per-process `Ring` instances and an aggregate `Ring`, each with O(1)
 append, eviction, record replacement, and identity lookup. Immutable `Data` records
 are shared. A partial record has one sequence identity; completing it replaces
@@ -74,9 +92,9 @@ clips rows safely. `Theme` uses the terminal's ANSI palette, default foreground
 background, and reverse-video selection, with a monochrome fallback. It does not
 read OS theme files or override palette entries; child SGR resets restore terminal
 defaults. The header uses the engine's `procfile_path` to identify the loaded file.
-`LogFormatter` aligns timestamps,
-process names, stream markers, and content. Complete frames reset styles at each row. `Application` connects input and lifecycle
-commands to the engine and limits drawing to 30 FPS. Resize handling reads current
+`LogFormatter` aligns timestamps, process names, stream markers, and content.
+Complete frames reset styles at each row. `Application` connects navigation,
+start/stop controls, and selected-child input to the engine and limits drawing to 30 FPS. Resize handling reads current
 terminal dimensions each loop; it does not replace an application's WINCH handler.
 
 `Plain` prints completed records and runs to natural completion. `Diagnostics`

data/docs/COMPATIBILITY.md

@@ -1,27 +1,75 @@
 # 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.1.2 |
+| 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 and stop controls; no child stdin |
-| Plain exit | Wait for all processes; status 0/1; explicit orderly shutdown returns 0 |
-| Interactive exit | Remain open after all processes exit; quit explicitly |
+| Terminal | Tabs, independent scroll/follow, restart, start/stop, and selected-process input controls |
+| 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 |
 
-Commands needing a PTY, interactive child input, or background daemonization are
-outside this release. Remote process control, persistence across Foruiman sessions,
+## 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,
 search, horizontal scrolling, and log export are not provided.

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`:
 
@@ -46,7 +57,13 @@ exec foruiman start -f Procfile.dev "$@"
 
 Select the web tab and press `r` to restart Rails without interrupting the worker
 or asset watcher. On the `all` tab, `r` restarts all entries; `R` does so from any
-tab. The header shows the active Procfile. `q` or Ctrl-C stops all owned process
+tab. Default watch modes stay running because their stdin remains open. When Rails
+stops in Pry, Byebug or IRB, select `web` and press `i`. Edit commands in the input
+bar and press Enter to send them. Up/Down recall history, Left/Right move the
+cursor, and Ctrl-X returns to Foruiman. Ctrl-C interrupts the selected process;
+debugger tab completion is not forwarded. Press `s` to stop the selected entry
+and press it again to start it; `s` on `all` stops every entry. The header shows the
+active Procfile. `q` or Ctrl-C stops all owned process
 groups, including grandchildren, before returning to the shell.
 
 Redirect output with `foruiman start -f Procfile.dev > development.log` to use plain

data/lib/foruiman/ansi.rb

@@ -63,10 +63,11 @@ module Foruiman::ANSI
     end
   end
 
-  # Incremental byte parser: only text, newlines, and SGR can leave this class.
-  # OSC (including clipboard), DCS, cursor controls, and other escapes are dropped.
+  # Screen controls are discarded. Output may opt into horizontal line editing
+  # controls, which it interprets before storing or displaying any records.
   class Decoder
-    def initialize
+    def initialize(line_controls: false)
+      @line_controls = line_controls
       @state = :text
       @escape = +""
       @pending = +"".b
@@ -92,6 +93,7 @@ module Foruiman::ANSI
         case byte
         when 27 then @state = :escape
         when 9 then output << "    "
+        when 8, 13 then output << byte if @line_controls
         when 10, 32..126, 128..255 then output << byte
         end
       when :escape
@@ -108,6 +110,9 @@ module Foruiman::ANSI
       when :csi
         if byte.between?(64, 126)
           output << "\e[#{@escape}m" if byte == 109 && @escape.match?(/\A[0-9;:]*\z/)
+          if @line_controls && [67, 68, 71, 75].include?(byte) && @escape.match?(/\A[0-9]*\z/)
+            output << "\e[#{@escape}#{byte.chr}"
+          end
           @state = :text
         elsif @escape.bytesize < 96
           @escape << byte

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