foruiman 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0de0b215283d2c3dc89422aa9e6f6da235acf10f5ede3907afcf8e7c88dd9290
-  data.tar.gz: 81dfcdcfbc8d7ab445242fd5c07419192b6445e9caa3107fcdce5a2a027d914e
+  metadata.gz: 726795acd4c4991d3a924364ec484ca7ec1e7051b8c9a660a53e6b8ecd1759f8
+  data.tar.gz: 0c24bdd2fded37d051b8bb0e771991b0284893888a89b3a461662d2cc483dee4
 SHA512:
-  metadata.gz: bb3cbdd6d6c38335bd5d6d4b467bbedec757cb2e534896b24d471c8b4275203d22cb22ec642fafe63410df21c1616322ae2e4616b0b26dce277959308f0092c5
-  data.tar.gz: 03db66ce62f3e21723aac3808791b2a027bb2ab497d415de11730661ff90b5150b82a0d7351ea2c156abc93be670e93a5b575933d06bf6a0fdcdcece35f7b517
+  metadata.gz: 68b7fa94a095c09fc3ed636165ee88db37640d24aa2ede0b4d2c417680cf2655910b881ad2180116babc701949c91cc9f751f2e0b67f222d081f71ca9153a178
+  data.tar.gz: 22ec4c35cd32fd23d897ca2de19d72d5c219b53d0b86019f3fc3f562b3436371bd353ca5119aac2d4e1c559c68ddca37984c53b68e5e036cc12538e04f71321e

data/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## Unreleased
 
+## 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

@@ -46,6 +46,14 @@ 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 |
@@ -69,9 +77,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,7 +2,7 @@
 
 `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.
 
 `Engine` owns registration, PID/group tracking, nonblocking pipes, child reaping,
@@ -35,6 +35,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
@@ -50,6 +51,18 @@ process cleanup. `term_timeout:` exists for deterministic embedded tests; CLI
 shutdown always uses five seconds. `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 +87,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

@@ -4,7 +4,7 @@ Foruiman is a fork-derived MVP, not a drop-in replacement for every Foreman feat
 
 | Area | Foruiman behavior |
 | --- | --- |
-| Identity | `foruiman` gem/executable, `Foruiman` namespace, version 0.1.2 |
+| Identity | `foruiman` gem/executable, `Foruiman` namespace, version 0.2.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 |
@@ -18,10 +18,10 @@ Foruiman is a fork-derived MVP, not a drop-in replacement for every Foreman feat
 | 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 |
 | Output | Separate stdout/stderr metadata; bounded logs and live partial records |
-| Terminal | Tabs, independent scroll/follow, restart and stop controls; no child stdin |
+| 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 |
 
-Commands needing a PTY, interactive child input, or background daemonization are
-outside this release. Remote process control, persistence across Foruiman sessions,
+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

@@ -46,7 +46,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/engine.rb

@@ -11,14 +11,16 @@ class Foruiman::Engine
   TERM_TIMEOUT = 5.0
   READ_CHUNK = 4096
   READ_BUDGET = 64 * 1024
+  INPUT_BUDGET = 64 * 1024
   State = Struct.new(:name, :process, :port, :pid, :pgid, :status, :exit_status,
                      :generation, :restart_pending, :deadline, :reaped, :group_gone,
+                     :input, :input_buffer,
                      keyword_init: true)
   Event = Data.define(:type, :name, :pid, :status, :record, :message)
 
   attr_reader :logs, :env, :processes, :root, :procfile_path
 
-  def initialize(procfile: nil, root: Dir.pwd, env: ENV.to_h, port: 5000, log_lines: 10_000,
+  def initialize(procfile: nil, root: Dir.pwd, env: ENV.to_h, input: $stdin, port: 5000, log_lines: 10_000,
                  term_timeout: TERM_TIMEOUT)
     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?
@@ -27,6 +29,8 @@ class Foruiman::Engine
     raise Foruiman::Error, "working directory does not exist: #{@root}" unless File.directory?(@root)
 
     @env = env.dup.freeze
+    @input = input
+    @managed_input = false
     @base_port = port
     @log_lines = log_lines
     @term_timeout = term_timeout
@@ -34,6 +38,7 @@ class Foruiman::Engine
     @names = {}
     @running = {}
     @readers = {}
+    @inputs = {}
     @listeners = []
     @shutdown = false
     @explicit_shutdown = false
@@ -57,7 +62,8 @@ class Foruiman::Engine
     Foruiman::Procfile.new[name] = command
     process = Foruiman::Process.new(command, cwd: root, env: env)
     state = State.new(name: name.freeze, process: process, port: @base_port + (processes.size * 100),
-                      status: :pending, generation: 0, restart_pending: false, reaped: true, group_gone: true)
+                      status: :pending, generation: 0, restart_pending: false, reaped: true, group_gone: true,
+                      input_buffer: +"".b)
     @names[name] = state
     processes << state
     state
@@ -100,6 +106,16 @@ class Foruiman::Engine
     self
   end
 
+  # Give every child a dedicated pseudo-terminal for stdin. The TUI remains the
+  # sole reader of the real terminal and explicitly forwards input to one child.
+  def manage_input!
+    raise Foruiman::Error, "cannot change input mode after startup" if @started
+
+    require "pty"
+    @managed_input = true
+    self
+  end
+
   def start(name = nil)
     raise Foruiman::Error, "supervisor is closed" if @closed
     return if @shutdown
@@ -145,6 +161,33 @@ class Foruiman::Engine
     terminate(entry)
   end
 
+  def write_input(name, bytes)
+    entry = state(name)
+    return false unless entry.status == :running && entry.input && !entry.input.closed?
+    return false if entry.input_buffer.bytesize + bytes.bytesize > INPUT_BUDGET
+
+    entry.input_buffer << bytes.b
+    flush_input(entry)
+  rescue IOError, SystemCallError
+    false
+  end
+
+  def interrupt_process(name)
+    entry = state(name)
+    return unless entry.pgid
+
+    signal_group(entry, :INT)
+    self
+  end
+
+  def resize_inputs(rows, columns)
+    processes.each do |entry|
+      entry.input&.winsize = [rows, columns]
+    rescue IOError, SystemCallError
+      nil
+    end
+  end
+
   def shutdown(explicit: true)
     @explicit_shutdown ||= explicit
     return if @shutdown
@@ -189,9 +232,11 @@ class Foruiman::Engine
     shutdown if @signal_requested
     reap_children
     advance_groups
-    ready = IO.select([@self_reader, *@readers.keys], nil, nil, timeout)&.first || []
+    writable = processes.filter_map { |entry| entry.input unless entry.input_buffer.empty? }
+    ready, writable = IO.select([@self_reader, *@readers.keys], writable, nil, timeout) || [[], []]
     drain_signal_pipe if ready.delete(@self_reader)
     shutdown if @signal_requested
+    writable.each { |input| flush_input(@inputs.fetch(input)) if @inputs.key?(input) }
     read_output(ready)
     reap_children
     advance_groups
@@ -224,12 +269,15 @@ class Foruiman::Engine
 
     stdout_reader, stdout_writer = create_pipe
     stderr_reader, stderr_writer = create_pipe
+    input_master, input_slave = create_managed_input if @managed_input
     begin
       pid = entry.process.run(output: stdout_writer, error: stderr_writer,
+                              input: input_slave || @input,
                               env: { "PORT" => entry.port.to_s, "PS" => "#{entry.name}.1" })
     rescue SystemCallError => e
       stdout_reader.close
       stderr_reader.close
+      input_master&.close
       entry.status = :failed
       entry.restart_pending = false
       @failed = true
@@ -243,12 +291,19 @@ class Foruiman::Engine
     entry.restart_pending = false
     entry.deadline = nil
     entry.reaped = entry.group_gone = false
+    entry.input = input_master
+    entry.input_buffer.clear
     @running[pid] = entry
     [[stdout_reader, :stdout], [stderr_reader, :stderr]].each do |reader, stream|
       @readers[reader] = [entry, Foruiman::Output.new(logs, name: entry.name, stream: stream, pid: pid)]
     end
+    if input_master
+      @inputs[input_master] = entry
+      @readers[input_master] = [entry, Foruiman::Output.new(logs, name: entry.name, stream: :stdin, pid: pid)]
+    end
     lifecycle(entry, :started, "started with pid #{pid} (generation #{entry.generation})")
   ensure
+    input_slave&.close
     stdout_writer&.close
     stderr_writer&.close
     [stdout_reader, stderr_reader].compact.each do |reader|
@@ -278,8 +333,9 @@ class Foruiman::Engine
       entry.reaped = true
       entry.exit_status = result.last
       success = entry.exit_status.success?
-      @failed ||= !success && !%i[stopping restarting].include?(entry.status)
-      entry.status = success ? :exited : :failed unless %i[stopping restarting].include?(entry.status)
+      transitioning = %i[stopping restarting].include?(entry.status)
+      @failed ||= !success && !transitioning
+      entry.status = success ? :exited : :failed unless transitioning
       lifecycle(entry, :exited, termination_message_for(entry.exit_status))
       terminate(entry)
     end
@@ -299,6 +355,7 @@ class Foruiman::Engine
       next unless entry.reaped && entry.group_gone
       next if @readers.any? { |_reader, (owner, _output)| owner.equal?(entry) }
 
+      close_input(entry)
       entry.pgid = nil
       entry.deadline = nil
       entry.status = :stopped if entry.status == :stopping
@@ -328,16 +385,19 @@ class Foruiman::Engine
       break if budget <= 0
 
       entry, output = @readers.fetch(reader)
-      bytes = reader.read_nonblock(READ_CHUNK, exception: false)
-      if bytes.nil? || (bytes == :wait_readable && entry.group_gone)
-        @readers.delete(reader)
-        reader.close
-        output.feed("", eof: true)
-      elsif bytes != :wait_readable
-        budget -= bytes.bytesize
-        output.feed(bytes)
-        # Rotate serviced readers to the back for the next select.
-        @readers[reader] = @readers.delete(reader)
+      begin
+        bytes = reader.read_nonblock(READ_CHUNK, exception: false)
+        if bytes.nil? || (bytes == :wait_readable && entry.group_gone)
+          finish_reader(reader, entry, output)
+        elsif bytes != :wait_readable
+          budget -= bytes.bytesize
+          output.feed(bytes)
+          # Rotate serviced readers to the back for the next select.
+          @readers[reader] = @readers.delete(reader)
+        end
+      rescue Errno::EIO
+        # PTY masters report EIO when the child closes the slave side.
+        finish_reader(reader, entry, output)
       end
     end
     # A daemon that escaped the group may still hold a pipe open. Drain available
@@ -346,12 +406,50 @@ class Foruiman::Engine
       entry, output = @readers.fetch(reader)
       next unless entry.group_gone && !ready.include?(reader)
 
-      @readers.delete(reader)
-      reader.close
-      output.feed("", eof: true)
+      finish_reader(reader, entry, output)
     end
   end
 
+  def create_managed_input
+    master, slave = PTY.open
+    [master, slave].each do |io|
+      io.binmode
+      io.close_on_exec = true
+    end
+    [master, slave]
+  end
+
+  def flush_input(entry)
+    return if entry.input_buffer.empty? || !entry.input
+
+    written = entry.input.write_nonblock(entry.input_buffer, exception: false)
+    entry.input_buffer.slice!(0, written) if written.is_a?(Integer)
+    true
+  rescue IOError, SystemCallError
+    reader = entry.input
+    finish_reader(reader, entry, @readers.fetch(reader).last) if reader && @readers.key?(reader)
+    false
+  end
+
+  def finish_reader(reader, entry, output)
+    @readers.delete(reader)
+    @inputs.delete(reader)
+    entry.input = nil if entry.input.equal?(reader)
+    reader.close unless reader.closed?
+    output.feed("", eof: true)
+  end
+
+  def close_input(entry)
+    input = entry.input
+    return unless input
+
+    @inputs.delete(input)
+    @readers.delete(input)
+    input.close unless input.closed?
+    entry.input = nil
+    entry.input_buffer.clear
+  end
+
   def lifecycle(entry, type, message)
     logs&.write(name: entry.name, stream: :lifecycle, pid: entry.pid,
                 text: "--- #{message} ---", complete: true)

data/lib/foruiman/output.rb

@@ -8,7 +8,7 @@ class Foruiman::Output
   def initialize(logs, name:, stream:, pid:)
     @logs = logs
     @metadata = { name: name, stream: stream, pid: pid }
-    @decoder = Foruiman::ANSI::Decoder.new
+    @decoder = Foruiman::ANSI::Decoder.new(line_controls: true)
     @styles = Foruiman::ANSI::Styles.new
     @text = +""
     @previous = nil
@@ -18,20 +18,25 @@ class Foruiman::Output
 
   def feed(bytes, eof: false)
     decoded = @decoder.feed(bytes, eof: eof)
-    decoded.scan(/\e\[[0-9;:]*m|\n|[^\e\n]+/).each do |token|
+    decoded.scan(/\e\[[0-9;:]*[mGCDK]|[\n\r\b]|[^\e\n\r\b]+/).each do |token|
       if token == "\n"
         if @split_boundary && !@dirty && !@previous
           @split_boundary = false
         else
           publish(true)
         end
+      elsif token == "\r" || token == "\b" || token.match?(/\A\e\[\d*[GCDK]\z/)
+        require_relative "output_line"
+        @line ||= Foruiman::OutputLine.new(@text)
+        @line.control(token, limit: MAX_BYTES / 2)
+        @dirty = true
       elsif token.start_with?("\e[")
         split_record if @text.bytesize + token.bytesize > MAX_BYTES
-        @text << token
+        @text << token unless @line
         @styles.apply(token)
         @dirty = true
       else
-        append_text(token)
+        @line ? edit_text(token) : append_text(token)
       end
     end
     if eof
@@ -43,6 +48,17 @@ class Foruiman::Output
 
   private
 
+  def edit_text(text)
+    text.scan(/\X/).each do |character|
+      if @line.cost + character.bytesize + @styles.prefix.bytesize + 4 > MAX_BYTES / 2
+        split_record
+        @line = Foruiman::OutputLine.new(@text)
+      end
+      @line.write(character, @styles.prefix)
+      @dirty = true
+    end
+  end
+
   def append_text(text)
     until text.empty?
       available = MAX_BYTES - @text.bytesize
@@ -66,11 +82,13 @@ class Foruiman::Output
 
   def publish(complete)
     @split_boundary = false
+    @text = @line.to_s if @line
     @previous = @logs.write(**@metadata, text: @text, complete: complete, previous: @previous)
     @dirty = false
     return unless complete
 
     @text = +@styles.prefix
+    @line = nil
     @previous = nil
   end
 end

data/lib/foruiman/output_line.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "unicode/display_width"
+require_relative "ansi"
+
+# A single editable terminal row. Used only after a child emits a horizontal
+# cursor control; ordinary append-only logs keep their fast streaming path.
+class Foruiman::OutputLine
+  attr_reader :cost
+
+  def initialize(text)
+    @cells = []
+    @cursor = 0
+    @cost = 0
+    styles = Foruiman::ANSI::Styles.new
+    text.scan(/\e\[[0-9;:]*m|\X/).each do |token|
+      if token.match?(Foruiman::ANSI::SGR)
+        styles.apply(token)
+      else
+        write(token, styles.prefix)
+      end
+    end
+  end
+
+  def write(character, style)
+    width = Unicode::DisplayWidth.of(character, emoji: :all)
+    if width.zero? && @cursor.positive?
+      index = @cursor - 1
+      index -= 1 while index.positive? && @cells[index] == :continuation
+      @cells[index][0] += character if @cells[index].is_a?(Array)
+    else
+      width.times { |offset| clear_cell(@cursor + offset) }
+      @cells[@cursor] = [character, style]
+      (1...width).each { |offset| @cells[@cursor + offset] = :continuation }
+      @cursor += width
+    end
+    # Conservative, constant-time bound including style transitions.
+    @cost += character.bytesize + style.bytesize + Foruiman::ANSI::RESET.bytesize
+  end
+
+  def control(token, limit:)
+    @cost = to_s.bytesize
+    number = token[/\d+/].to_i
+    amount = [number, 1].max
+    case token
+    when "\r" then @cursor = 0
+    when "\b" then @cursor = [@cursor - 1, 0].max
+    else
+      case token[-1]
+      when "G" then @cursor = (amount - 1).clamp(0, limit)
+      when "C" then @cursor = (@cursor + amount).clamp(0, limit)
+      when "D" then @cursor = [@cursor - amount, 0].max
+      when "K" then erase(number)
+      end
+    end
+  end
+
+  def to_s
+    style = ""
+    @cells.each_with_object(+"") do |cell, text|
+      next if cell == :continuation
+
+      character, next_style = cell || [" ", ""]
+      if next_style != style
+        text << Foruiman::ANSI::RESET unless style.empty?
+        text << next_style
+        style = next_style
+      end
+      text << character
+    end
+  end
+
+  private
+
+  def clear_cell(index)
+    if @cells[index] == :continuation
+      start = index - 1
+      start -= 1 while start.positive? && @cells[start] == :continuation
+      @cells[start] = nil
+    end
+    following = index + 1
+    while @cells[following] == :continuation
+      @cells[following] = nil
+      following += 1
+    end
+    @cells[index] = nil
+  end
+
+  def erase(mode)
+    case mode
+    when 0
+      clear_cell(@cursor) if @cursor < @cells.size
+      @cells.slice!(@cursor..) if @cursor < @cells.size
+    when 1
+      [@cursor + 1, @cells.size].min.times { |index| clear_cell(index) }
+    when 2 then @cells.clear
+    end
+    @cost = to_s.bytesize
+  end
+end

data/lib/foruiman/process.rb

@@ -12,7 +12,7 @@ class Foruiman::Process
 
   def run(options = {})
     ::Process.spawn(env.merge(options.fetch(:env, {})), "/bin/sh", "-c", command,
-                    chdir: cwd, in: File::NULL, out: options.fetch(:output, $stdout),
+                    chdir: cwd, in: options.fetch(:input, $stdin), out: options.fetch(:output, $stdout),
                     err: options.fetch(:error, $stderr), pgroup: true, unsetenv_others: true,
                     close_others: true)
   end

data/lib/foruiman/tui/application.rb

@@ -22,13 +22,16 @@ module Foruiman::TUI
     end
 
     def run
+      @engine.manage_input!
       @terminal.session do
         @engine.run(keep_open: true) do
           rows, columns = @terminal.size
+          @engine.resize_inputs(rows, columns)
+          detach_unavailable_input
           input = @terminal.read
           @engine.shutdown if input.nil?
-          height = [Renderer.log_height(rows: rows, columns: columns), 1].max
-          @keyboard.feed(input.is_a?(String) ? input : "").each { |key| handle(key, height) }
+          height = [Renderer.log_height(rows: rows, columns: columns, input: state.input?), 1].max
+          read_keys(input.is_a?(String) ? input : "", height)
           state.feedback = nil if monotonic >= @feedback_until
           next if monotonic < @next_frame_at && @was_shutting_down == @engine.shutting_down?
 
@@ -66,7 +69,9 @@ module Foruiman::TUI
       when :toggle_follow then state.viewport.toggle(buffer, height)
       when :help then state.help = !state.help
       when :escape then state.help = false
-      when :restart, :stop then control(key)
+      when :restart then control(key)
+      when :stop then toggle_process
+      when :input then begin_input
       when :restart_all, :stop_all
         control_all(key == :restart_all ? :restart : :stop)
       when :quit then @engine.shutdown
@@ -75,6 +80,76 @@ module Foruiman::TUI
 
     private
 
+    def read_keys(bytes, height)
+      @keyboard.feed("").each { |key| handle(key, height) } unless state.input?
+      bytes.bytes.each_with_index do |byte, index|
+        if state.input?
+          forward_input(bytes.byteslice(index..))
+          break
+        end
+        @keyboard.feed(byte.chr).each { |key| handle(key, height) }
+      end
+    end
+
+    def begin_input
+      if state.name == "all"
+        feedback("Select a process before entering input mode")
+      elsif @engine.state(state.name).status != :running
+        feedback("#{state.name} is not running")
+      else
+        state.help = false
+        state.viewport.follow
+        state.input_target = state.name
+        state.feedback = nil
+      end
+    end
+
+    def forward_input(bytes)
+      name = state.input_target
+      state.input_line.feed(bytes).each do |event|
+        case event
+        when :detach
+          state.input_target = nil
+          feedback("Returned from #{name}")
+        when :interrupt then @engine.interrupt_process(name)
+        when :eof then send_input(name, "\x04")
+        when Array then send_input(name, "#{event.last}\n")
+        end
+      end
+    end
+
+    def send_input(name, bytes)
+      return if @engine.write_input(name, bytes)
+
+      state.input_target = nil
+      feedback("Input unavailable for #{name}")
+    end
+
+    def detach_unavailable_input
+      return unless state.input?
+      return if @engine.state(state.input_target).status == :running
+
+      name = state.input_target
+      state.input_target = nil
+      feedback("Input closed for #{name}")
+    end
+
+    def toggle_process
+      if state.name == "all"
+        control_all(:stop)
+        return
+      end
+
+      entry = @engine.state(state.name)
+      if entry.pgid
+        @engine.stop(state.name)
+        feedback("Stopping #{state.name}")
+      else
+        @engine.start(state.name)
+        feedback("Starting #{state.name}")
+      end
+    end
+
     def control(action)
       if state.name == "all"
         if action == :restart

data/lib/foruiman/tui/input_line.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+module Foruiman::TUI
+  class InputLine
+    # Leave room for the newline in the child's canonical terminal buffer.
+    MAX_BYTES = 4095
+    HISTORY_SIZE = 100
+    SEQUENCES = {
+      "\e[A" => :history_previous, "\e[B" => :history_next,
+      "\e[C" => :right, "\e[D" => :left,
+      "\e[H" => :home, "\e[F" => :end,
+      "\e[1~" => :home, "\e[4~" => :end, "\e[3~" => :delete
+    }.freeze
+    CONTROLS = {
+      1 => :home, 3 => :interrupt, 4 => :eof, 5 => :end, 8 => :backspace,
+      10 => :submit, 13 => :submit, 18 => :history_previous, 21 => :clear, 23 => :delete_word,
+      24 => :detach, 127 => :backspace
+    }.freeze
+
+    attr_reader :text, :cursor
+
+    def initialize
+      @text = +""
+      @cursor = 0
+      @bytes = +"".b
+      @history = []
+      @history_index = nil
+      @draft = nil
+    end
+
+    def feed(bytes)
+      bytes, detach, = bytes.b.partition("\x18")
+      @bytes << bytes
+      events = []
+      until @bytes.empty?
+        if @bytes.start_with?("\e")
+          if @bytes.bytesize > 64 && incomplete_escape?
+            @bytes.clear
+            break
+          end
+          break if incomplete_escape?
+
+          sequence = SEQUENCES.keys.find { |candidate| @bytes.start_with?(candidate) }
+          if sequence
+            edit(SEQUENCES.fetch(sequence))
+            @bytes.slice!(0, sequence.bytesize)
+          else
+            match = @bytes.match(%r{\A\e(?:\[[0-?]*[ -/]*[@-~]|O.|.)}m)
+            @bytes.slice!(0, match ? match[0].bytesize : 1)
+          end
+          next
+        end
+
+        byte = @bytes.getbyte(0)
+        if @after_cr && byte == 10
+          @bytes.slice!(0, 1)
+          @after_cr = false
+          next
+        end
+        @after_cr = byte == 13
+        if CONTROLS.key?(byte)
+          @bytes.slice!(0, 1)
+          event = edit(CONTROLS.fetch(byte))
+          events << event if event
+        elsif byte < 32
+          @bytes.slice!(0, 1)
+        else
+          character = next_character
+          break unless character
+
+          insert(character)
+        end
+      end
+      unless detach.empty?
+        @bytes.clear
+        clear
+        events << :detach
+      end
+      events
+    end
+
+    def clear
+      replace("")
+      @history_index = nil
+      @draft = nil
+    end
+
+    private
+
+    def edit(action)
+      case action
+      when :left then @cursor -= 1 if cursor.positive?
+      when :right then @cursor += 1 if cursor < graphemes.size
+      when :home then @cursor = 0
+      when :end then @cursor = graphemes.size
+      when :backspace then remove(cursor - 1) if cursor.positive?
+      when :delete then remove(cursor) if cursor < graphemes.size
+      when :delete_word then delete_word
+      when :clear then clear
+      when :history_previous then history_previous
+      when :history_next then history_next
+      when :submit then return submit
+      when :interrupt
+        clear
+        return :interrupt
+      when :eof
+        return :eof if text.empty?
+
+        remove(cursor) if cursor < graphemes.size
+      when :detach
+        clear
+        return :detach
+      end
+      nil
+    end
+
+    def submit
+      line = text.dup
+      @history << line.freeze unless line.empty? || @history.last == line
+      @history.shift if @history.size > HISTORY_SIZE
+      clear
+      [:submit, line]
+    end
+
+    def insert(character)
+      return if text.bytesize + character.bytesize > MAX_BYTES
+      return if character.match?(/[\u0080-\u009f]/)
+
+      if character.ascii_only? && cursor == text.length
+        @text << character
+        @cursor += 1
+        @history_index = nil
+        return
+      end
+
+      parts = graphemes
+      parts.insert(cursor, character)
+      @text = parts.join
+      @cursor = [cursor + 1, graphemes.size].min
+      @history_index = nil
+    end
+
+    def remove(index)
+      parts = graphemes
+      parts.delete_at(index)
+      @text = parts.join
+      @cursor -= 1 if index < cursor
+      @history_index = nil
+    end
+
+    def delete_word
+      parts = graphemes
+      index = cursor
+      index -= 1 while index.positive? && parts[index - 1].match?(/\s/)
+      index -= 1 while index.positive? && !parts[index - 1].match?(/\s/)
+      parts.slice!(index...cursor)
+      @text = parts.join
+      @cursor = index
+      @history_index = nil
+    end
+
+    def history_previous
+      return if @history.empty?
+
+      @draft = text.dup unless @history_index
+      @history_index = [(@history_index || @history.size) - 1, 0].max
+      replace(@history.fetch(@history_index))
+    end
+
+    def history_next
+      return unless @history_index
+
+      @history_index += 1
+      if @history_index >= @history.size
+        @history_index = nil
+        replace(@draft.to_s)
+        @draft = nil
+      else
+        replace(@history.fetch(@history_index))
+      end
+    end
+
+    def replace(value)
+      @text = +value
+      @cursor = graphemes.size
+    end
+
+    def graphemes
+      text.scan(/\X/)
+    end
+
+    def next_character
+      size = utf8_size(@bytes.getbyte(0))
+      return @bytes.slice!(0, 1).force_encoding(Encoding::UTF_8).scrub unless size
+      unless @bytes.byteslice(1, size - 1).bytes.all? { |byte| byte.between?(128, 191) }
+        return @bytes.slice!(0, 1).force_encoding(Encoding::UTF_8).scrub
+      end
+      return if @bytes.bytesize < size
+
+      @bytes.slice!(0, size).force_encoding(Encoding::UTF_8).scrub
+    end
+
+    def utf8_size(byte)
+      case byte
+      when 0..127 then 1
+      when 194..223 then 2
+      when 224..239 then 3
+      when 240..244 then 4
+      end
+    end
+
+    def incomplete_escape?
+      @bytes == "\e" || @bytes == "\e[" || @bytes == "\eO" ||
+        (@bytes.start_with?("\e[") && !@bytes.match?(%r{\A\e\[[0-?]*[ -/]*[@-~]}))
+    end
+  end
+end

data/lib/foruiman/tui/keyboard.rb

@@ -12,7 +12,7 @@ module Foruiman::TUI
       "\t" => :next, "h" => :previous, "l" => :next, "k" => :up, "j" => :down,
       "g" => :home, "G" => :end, "f" => :follow, " " => :toggle_follow,
       "r" => :restart, "R" => :restart_all, "s" => :stop, "S" => :stop_all,
-      "?" => :help, "q" => :quit, "\x03" => :quit,
+      "i" => :input, "?" => :help, "q" => :quit, "\x03" => :quit,
       "\x15" => :page_up, "\x04" => :page_down
     }.freeze
 

data/lib/foruiman/tui/log_formatter.rb

@@ -30,6 +30,7 @@ module Foruiman::TUI
 
     def stream_style(stream)
       case stream
+      when :stdin then ["in ", :cyan]
       when :stderr then ["err", :red]
       when :lifecycle then ["sys", :amber]
       else ["out", :faint]
@@ -38,6 +39,7 @@ module Foruiman::TUI
 
     def body_color(stream)
       case stream
+      when :stdin then :cyan
       when :stderr then :red
       when :lifecycle then :muted
       else :text

data/lib/foruiman/tui/renderer.rb

@@ -16,7 +16,8 @@ module Foruiman::TUI
       [nil, "f / G / End", "Follow newest output", nil],
       [nil, "Space", "Pause / resume following", nil],
       ["⚙ PROCESSES", "r / R", "Restart selected / all", "r on all restarts all"],
-      [nil, "s / S", "Stop selected / all", nil],
+      [nil, "s / S", "Start/stop selected / stop all", "s on all stops all"],
+      ["⌨ INPUT", "i", "Edit a command; Enter sends", "Ctrl-X returns to Foruiman"],
       ["◇ SESSION", "? / Escape", "Close help", nil],
       [nil, "q / Ctrl-C", "Stop processes and quit", nil]
     ].freeze
@@ -30,16 +31,16 @@ module Foruiman::TUI
       rows >= 14 && columns >= 60
     end
 
-    def self.log_height(rows:, columns:)
+    def self.log_height(rows:, columns:, input: false)
       return 0 if rows < 6 || columns < 24
 
-      rows - (expanded?(rows: rows, columns: columns) ? 7 : 5)
+      rows - (expanded?(rows: rows, columns: columns) ? 7 : 5) - (input && rows >= 8 ? 2 : 0)
     end
 
     def render(state, engine, rows:, columns:)
       @width = [columns - 1, 1].max
       @inside = [@width - 4, 0].max
-      @height = self.class.log_height(rows: rows, columns: columns)
+      @height = self.class.log_height(rows: rows, columns: columns, input: state.input?)
       return tiny_frame(state, engine, rows) if @height.zero?
 
       lines = [header(engine)]
@@ -54,6 +55,7 @@ module Foruiman::TUI
       lines << log_header(state, engine)
       lines.concat(state.help ? help_rows : log_rows(state, engine))
       lines << log_footer(state, engine)
+      lines.concat(input_rows(state)) if state.input? && rows >= 8
       lines << controls(state, engine)
       frame(lines, rows)
     end
@@ -157,7 +159,9 @@ module Foruiman::TUI
                else
                  engine.state(state.name).status == :running
                end
-      mode = if !state.viewport.following
+      mode = if state.input?
+               @theme.paint(" ▶ INPUT ", :cyan)
+             elsif !state.viewport.following
                @theme.paint(" Ⅱ PAUSED ", :amber)
              elsif active
                @theme.paint(" ● LIVE ", :green)
@@ -244,6 +248,12 @@ module Foruiman::TUI
     end
 
     def controls(state, engine)
+      if state.input?
+        left = @theme.paint(" Enter send · ↑↓ history · Ctrl-C interrupt", :muted)
+        right = @theme.paint(" Ctrl-X back ", :amber, bold: true)
+        return distribute(left, right, @width)
+      end
+
       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)
@@ -252,20 +262,46 @@ module Foruiman::TUI
              elsif state.help
                @theme.paint(" ? / Escape close help", :muted)
              else
-               shortcuts(state)
+               shortcuts(state, engine)
              end
       distribute(left, quit, @width)
     end
 
-    def shortcuts(state)
+    def shortcuts(state, engine)
       restart = ["r", state.name == "all" ? "↻ restart all" : "↻ restart"]
-      pairs = [%w[Tab switch], ["↑↓", "scroll"], %w[f follow], restart, ["?", "help"]]
-      pairs = [restart, ["?", "help"]] if @width < 65
+      toggle = if state.name == "all"
+                 ["s", "■ stop all"]
+               elsif process_active?(engine.state(state.name))
+                 ["s", "■ stop"]
+               else
+                 ["s", "▶ start"]
+               end
+      pairs = [%w[Tab switch], ["↑↓", "scroll"], %w[f follow], restart,
+               toggle, %w[i input], ["?", "help"]]
+      pairs = [restart, toggle, %w[i input], ["?", "help"]] if @width < 85
       pairs.map do |key, label|
         @theme.paint(" #{key} ", :accent, bold: true) + @theme.paint(" #{label}  ", :muted)
       end.join
     end
 
+    def process_active?(entry)
+      entry.pgid || %i[running restarting stopping].include?(entry.status)
+    end
+
+    def input_rows(state)
+      editor = state.input_line
+      parts = editor.text.scan(/\X/)
+      before = parts.take(editor.cursor)
+      current = parts[editor.cursor] || " "
+      after = parts.drop(editor.cursor + 1).join
+      available = [@inside - 5, 1].max
+      before.shift while !before.empty? && Text.width(before.join + current) > available
+      draft = @theme.paint("❯ ", :cyan, bold: true) + before.join +
+              @theme.paint(current,
+                           selected: true) + Text.clip(after, [available - Text.width(before.join + current), 0].max)
+      [border(@theme.paint(" ⌨ Input to #{state.input_target} ", :cyan, bold: true)), panel(draft)]
+    end
+
     def border(left, right = "", bottom: false)
       corners = bottom ? %w[╰ ╯] : %w[╭ ╮]
       middle = distribute(left, right, @inside, fill: "─")
@@ -290,7 +326,7 @@ module Foruiman::TUI
       title = @theme.paint(" FORUIMAN", :accent, bold: true)
       message = engine.shutting_down? ? " Stopping…" : " #{state.name} · enlarge terminal"
       lines = [title, @theme.paint(message, :muted)]
-      lines[rows - 1] = @theme.paint(" q quit", :accent) if rows > 2
+      lines[rows - 1] = @theme.paint(state.input? ? " Ctrl-X back" : " q quit", :accent) if rows > 2
       frame(lines, rows)
     end
 

data/lib/foruiman/tui/state.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
 require_relative "viewport"
+require_relative "input_line"
 
 module Foruiman::TUI
   class State
     attr_reader :tabs, :selected, :viewports
-    attr_accessor :help, :feedback
+    attr_accessor :help, :feedback, :input_target
 
     def initialize(names)
       @tabs = [*names, "all"].freeze
@@ -13,6 +14,8 @@ module Foruiman::TUI
       @viewports = tabs.to_h { |name| [name, Viewport.new] }
       @help = false
       @feedback = nil
+      @input_target = nil
+      @input_lines = names.to_h { |name| [name, InputLine.new] }
     end
 
     def name
@@ -23,6 +26,14 @@ module Foruiman::TUI
       viewports.fetch(name)
     end
 
+    def input?
+      !input_target.nil?
+    end
+
+    def input_line
+      @input_lines.fetch(input_target || name)
+    end
+
     def select(index)
       @selected = index if index.between?(0, tabs.size - 1)
     end

data/lib/foruiman/tui/theme.rb

@@ -16,8 +16,8 @@ module Foruiman::TUI
       stopped: :muted, exited: :muted, failed: :red
     }.freeze
     STATUS_MARKS = {
-      pending: "○", running: "●", restarting: "↻", stopping: "◌",
-      stopped: "■", exited: "✓", failed: "×"
+      pending: "○", running: "▶", restarting: "↻", stopping: "◼",
+      stopped: "■", exited: "✓", failed: "✕"
     }.freeze
 
     attr_reader :enabled

data/lib/foruiman/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foruiman
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Foruiman contributors
@@ -75,11 +75,13 @@ files:
 - lib/foruiman/env.rb
 - lib/foruiman/log_store.rb
 - lib/foruiman/output.rb
+- lib/foruiman/output_line.rb
 - lib/foruiman/plain.rb
 - lib/foruiman/process.rb
 - lib/foruiman/procfile.rb
 - lib/foruiman/ring.rb
 - lib/foruiman/tui/application.rb
+- lib/foruiman/tui/input_line.rb
 - lib/foruiman/tui/keyboard.rb
 - lib/foruiman/tui/log_formatter.rb
 - lib/foruiman/tui/renderer.rb