canopus 0.1.0 → 0.2.0

data/lib/canopus/controller.rb

@@ -5,7 +5,8 @@ require_relative "workspace/view"
 module Canopus
   class Controller
     SHORTCUTS = {"cmd-s" => "file.save", "ctrl-s" => "file.save", "cmd-n" => "file.new", "ctrl-n" => "file.new",
-      "cmd-w" => "file.close", "ctrl-w" => "file.close", "cmd-p" => "file.find", "ctrl-p" => "file.find",
+      "cmd-w" => "tab.close", "ctrl-w" => "tab.close", "cmd-alt-w" => "tab.close_all", "ctrl-alt-w" => "tab.close_all",
+      "cmd-shift-t" => "tab.reopen_closed", "ctrl-shift-t" => "tab.reopen_closed", "cmd-p" => "file.find", "ctrl-p" => "file.find",
       "cmd-shift-p" => "command.palette", "ctrl-shift-p" => "command.palette", "cmd-z" => "edit.undo", "ctrl-z" => "edit.undo",
       "cmd-shift-z" => "edit.redo", "ctrl-shift-z" => "edit.redo", "cmd-a" => "edit.select_all", "ctrl-a" => "edit.select_all",
       "cmd-d" => "edit.select_next", "ctrl-d" => "edit.select_next", "cmd-f" => "search.buffer", "ctrl-f" => "search.buffer",
@@ -13,10 +14,15 @@ module Canopus
       "alt-up" => "edit.move_line_up", "alt-down" => "edit.move_line_down",
       "cmd-shift-f" => "search.project", "ctrl-shift-f" => "search.project", "cmd-alt-f" => "search.replace", "ctrl-h" => "search.replace",
       "cmd-/" => "edit.toggle_comment", "ctrl-/" => "edit.toggle_comment", "cmd-b" => "view.project", "ctrl-b" => "view.project",
-      "ctrl-`" => "view.terminal", "cmd-\\" => "pane.split_right", "ctrl-\\" => "pane.split_right",
+      "ctrl-`" => "view.terminal", "ctrl-shift-`" => "terminal.new", "cmd-\\" => "pane.split_right", "ctrl-\\" => "pane.split_right",
       "ctrl-space" => "language.completion", "f12" => "language.definition", "shift-f12" => "language.references",
       "f2" => "language.rename", "alt-enter" => "language.codeAction", "cmd-shift-o" => "language.outline",
       "ctrl-shift-o" => "language.outline", "cmd-k" => "language.hover", "ctrl-k" => "language.hover"}.freeze
+    TERMINAL_SHORTCUTS = {"ctrl-`" => "terminal.toggle", "ctrl-shift-`" => "terminal.new", "cmd-w" => "terminal.close",
+      "ctrl-w" => "terminal.close", "cmd-c" => "terminal.copy", "ctrl-shift-c" => "terminal.copy",
+      "cmd-v" => "terminal.paste", "ctrl-shift-v" => "terminal.paste", "cmd-shift-p" => "command.palette",
+      "ctrl-shift-p" => "command.palette", "ctrl-shift-]" => "terminal.next", "ctrl-shift-[" => "terminal.prev",
+      "cmd-k" => "terminal.clear"}.merge((1..9).to_h { |index| ["cmd-#{index}", "terminal.select_#{index}"] }).freeze
     attr_reader :workspace, :view, :window, :keymap
     def initialize(workspace, window)
       @workspace, @window, @view = workspace, window, Workspace::View.new(workspace)
@@ -27,8 +33,7 @@ module Canopus
       window.on_close { close_requested }
       window.on_appearance { |_| workspace.apply_settings if workspace.settings["theme"] == "auto" } if window.respond_to?(:on_appearance)
       window.on_tick do
-        data = workspace.terminal&.read
-        window.request_frame if data && !data.empty?
+        workspace.drain_terminals
         workspace.drain
         workspace.poll_changes
         workspace.poll_settings
@@ -65,7 +70,12 @@ module Canopus
       when Zaniah::Input::TextInput
         input_text(event.text)
       when Zaniah::Input::Composition
-        @workspace.editor.composition = event
+        if @terminal_focus && @workspace.terminal_visible
+          @workspace.terminal_composition = event
+        else
+          @workspace.new_buffer unless @workspace.editor
+          @workspace.editor.composition = event
+        end
       when Zaniah::Input::KeyDown
         key(event.keystroke)
       when Zaniah::Input::MouseDown
@@ -81,6 +91,7 @@ module Canopus
           terminal_mouse(event, :move)
         end
       when Zaniah::Input::MouseUp
+        @workspace.flush_terminal_resize if @resize_drag&.first == :dock_resize
         @resize_drag = nil
         @scroll_drag = nil
         if @drag_file
@@ -92,6 +103,10 @@ module Canopus
           @drag_file = nil
         end
         terminal_mouse(event, :release) if @terminal_drag && @terminal_drag != :selection
+        if @terminal_drag == :selection && @workspace.settings["terminal"]["copy_on_select"]
+          @clipboard = @view.terminal_selected_text
+          @window.clipboard = @clipboard if @window.respond_to?(:clipboard=)
+        end
         @terminal_drag = nil
         if @drag_tab
           from, editor, origin = @drag_tab
@@ -103,6 +118,14 @@ module Canopus
           end
           @drag_tab = nil
         end
+        if @drag_terminal_tab
+          from, origin = @drag_terminal_tab
+          target = @view.hit(event.position)
+          if target&.first == :terminal_tab && (event.position.x - origin.x).abs + (event.position.y - origin.y).abs > 10
+            @workspace.move_terminal(from, target[1])
+          end
+          @drag_terminal_tab = nil
+        end
         @drag = nil
       when Zaniah::Input::ScrollWheel
         scroll(event)
@@ -114,16 +137,20 @@ module Canopus
     end
     def input_text(text)
       if @workspace.palette
-        return if [:workspace_edit, :confirm_close, :trash_file].include?(@workspace.palette[:kind])
+        return if [:workspace_edit, :confirm_close, :confirm_tab_close, :confirm_terminal_close, :confirm_terminal_paste, :trash_file].include?(@workspace.palette[:kind])
         @workspace.palette[:query] << text
         @workspace.update_palette
       elsif @terminal_focus && @workspace.terminal_visible
+        @workspace.terminal_composition = nil
         @workspace.terminal.write(text)
-      elsif @workspace.settings["vim_mode"]
-        text.each_grapheme_cluster { |character| @workspace.vim.feed(character) }
       else
-        @workspace.editor.composition = nil
-        @workspace.editor.insert_text(text)
+        @workspace.new_buffer unless @workspace.editor
+        if @workspace.settings["vim_mode"]
+          text.each_grapheme_cluster { |character| @workspace.vim.feed(character) }
+        else
+          @workspace.editor.composition = nil
+          @workspace.editor.insert_text(text)
+        end
       end
     end
     def key(stroke)
@@ -132,13 +159,27 @@ module Canopus
       stroke = Zaniah::Input::Keystroke.normalize(stroke)
       return palette_key(stroke) if @workspace.palette
       return if @composing && (stroke.split("-") & %w[ctrl cmd]).empty?
-      return @workspace.settings_completions if stroke == "ctrl-space" && @workspace.settings_document?(@workspace.editor.buffer)
-      if ["cmd-q", "ctrl-q"].include?(stroke)
+      if stroke == "cmd-q" || stroke == "ctrl-q" && !(@terminal_focus && @workspace.terminal_visible)
         return @window.close
       end
-      if @terminal_focus && @workspace.terminal_visible && stroke != "ctrl-`"
-        if ["cmd-v", "ctrl-shift-v"].include?(stroke)
-          return @workspace.terminal.paste(@window.respond_to?(:clipboard) ? @window.clipboard.to_s : @clipboard)
+      if @terminal_focus && @workspace.terminal_visible && @workspace.terminal
+        if stroke == "enter" && @workspace.terminal.respond_to?(:alive?) && !@workspace.terminal.alive?
+          return @workspace.restart_terminal
+        end
+        mode = @workspace.settings["vim_mode"] && @workspace.editor ? @workspace.vim.mode.to_s : false
+        action = @keymap.dispatch(stroke, context: {"Terminal" => true, "Editor" => false, "vim_mode" => mode})
+        if action && action != :pending
+          if action == "terminal.paste"
+            return terminal_paste(@window.respond_to?(:clipboard) ? @window.clipboard.to_s : @clipboard)
+          elsif action == "terminal.copy"
+            @clipboard = @view.terminal_selected_text
+            @window.clipboard = @clipboard if @window.respond_to?(:clipboard=)
+            return
+          end
+          @drag_terminal_tab = nil if action == "terminal.close"
+          return @workspace.call(action)
+        elsif action == :pending
+          return
         elsif ["cmd-c", "ctrl-shift-c"].include?(stroke)
           @clipboard = @view.terminal_selected_text
           @window.clipboard = @clipboard if @window.respond_to?(:clipboard=)
@@ -150,23 +191,26 @@ module Canopus
         name = {"esc" => "escape", "pageup" => "page_up", "pagedown" => "page_down", "space" => " "}.fetch(name, name)
         return @workspace.terminal.key(name, control: parts.include?("ctrl"), alt: parts.include?("alt"), shift: parts.include?("shift"))
       end
-      mode = @workspace.settings["vim_mode"] ? @workspace.vim.mode.to_s : false
-      action = @keymap.dispatch(stroke, context: {"Editor" => true, "vim_mode" => mode})
+      return @workspace.settings_completions if stroke == "ctrl-space" && @workspace.editor && @workspace.settings_document?(@workspace.editor.buffer)
+      mode = @workspace.settings["vim_mode"] && @workspace.editor ? @workspace.vim.mode.to_s : false
+      action = @keymap.dispatch(stroke, context: {"Editor" => !!@workspace.editor, "vim_mode" => mode})
       if action
         # Native adapters deliver text separately after printable key down.
         # Cocoa also sends an empty Composition before that ordinary commit.
         @suppress_key_text = stroke.match?(/\A(?:(?:alt|shift)-)*(?:space|[^\x00-\x1f\x7f])\z/)
+        @drag_tab = nil if action.to_s.start_with?("tab.close") || action == "pane.close"
         return action == :pending ? nil : @workspace.call(action)
       end
       if ["cmd-c", "ctrl-c", "cmd-x", "ctrl-x", "cmd-v", "ctrl-v"].include?(stroke) && !(@workspace.settings["vim_mode"] && stroke == "ctrl-v")
         return clipboard(stroke.split("-").last)
       end
-      if ["tab", "shift-tab"].include?(stroke) && @workspace.editor.snippet_active?
+      if ["tab", "shift-tab"].include?(stroke) && @workspace.editor&.snippet_active?
         stroke == "tab" ? @workspace.editor.next_snippet : @workspace.editor.previous_snippet
         return @workspace.show_snippet_choices
       end
       parts = stroke.split("-")
       name = parts.pop
+      @workspace.new_buffer unless @workspace.editor
       if @workspace.settings["vim_mode"]
         @workspace.vim.feed(stroke) if name.length > 1 || parts.include?("ctrl")
         return
@@ -285,6 +329,7 @@ module Canopus
       unless @keymap_groups == groups
         replacement = Zaniah::Input::Keymap.new
         SHORTCUTS.each { |keys, action| replacement.bind(keys, action) }
+        TERMINAL_SHORTCUTS.each { |keys, action| replacement.bind(keys, action, context: "Terminal") }
         groups.each do |group|
           group.fetch("bindings").each { |keys, action| replacement.bind(keys, action, context: group.fetch("context")) }
         end
@@ -295,7 +340,7 @@ module Canopus
     end
     def palette_input(event)
       return false unless @workspace.palette
-      @drag = @resize_drag = @scroll_drag = @terminal_drag = @drag_file = @drag_tab = nil
+      @drag = @resize_drag = @scroll_drag = @terminal_drag = @drag_file = @drag_tab = @drag_terminal_tab = nil
       case event
       when Zaniah::Input::KeyDown then key(event.keystroke)
       when Zaniah::Input::TextInput then input_text(event.text)
@@ -341,7 +386,7 @@ module Canopus
           palette[:details_scroll] = (palette.fetch(:details_scroll, 0) + (stroke == "pageup" ? -step : step)).clamp(0, maximum)
         end
       when "backspace"
-        return if [:workspace_edit, :confirm_close, :trash_file].include?(palette[:kind])
+        return if [:workspace_edit, :confirm_close, :confirm_tab_close, :confirm_terminal_close, :confirm_terminal_paste, :trash_file].include?(palette[:kind])
         palette[:query] = palette[:query].grapheme_clusters[0...-1].join
         @workspace.update_palette
       when "enter"
@@ -373,6 +418,19 @@ module Canopus
           when 1 then @discard_close = true; @window.close
           else @workspace.palette = nil
           end
+        elsif palette[:kind] == :confirm_tab_close
+          @workspace.resolve_tab_close([:save, :discard, :cancel].fetch(palette[:index]))
+        elsif palette[:kind] == :confirm_terminal_close
+          index = @workspace.terminals.index(palette[:terminal])
+          @workspace.palette = nil
+          @workspace.close_terminal(index) if palette[:index].zero? && index
+        elsif palette[:kind] == :confirm_terminal_paste
+          value = palette[:text]
+          @workspace.palette = nil
+          @workspace.terminal&.paste(value) if palette[:index].zero?
+        elsif palette[:kind] == :terminal_rename
+          @workspace.rename_terminal(palette[:query])
+          @workspace.palette = nil
         else
           @workspace.palette_accept
         end
@@ -391,7 +449,7 @@ module Canopus
           return
         end
       end
-      @terminal_focus = kind == :terminal
+      @terminal_focus = [:terminal, :terminal_tab, :terminal_close].include?(kind)
       case kind
       when :git_hunk then @workspace.toggle_git_hunk(args[0], row: args[1]) if event.button == :left
       when :hover_link
@@ -419,12 +477,23 @@ module Canopus
           @terminal_drag = :selection
           @view.terminal_select(event.position)
         end
+      when :terminal_tab
+        @workspace.activate_terminal(args.first)
+        @drag_terminal_tab = [args.first, event.position] if event.button == :left
+      when :terminal_close
+        @workspace.request_terminal_close(args.first) if event.button == :left
       when :file then @workspace.open(args.first)
       when :directory then @workspace.project_tree.toggle(args.first)
       when :tab
         pane, editor = args
-        @workspace.activate_tab(pane, editor)
-        @drag_tab = [pane, editor, event.position]
+        if event.button == :middle && @workspace.settings["tabs"]["close_on_middle_click"]
+          @workspace.request_close([editor])
+        elsif event.button == :left
+          @workspace.activate_tab(pane, editor)
+          @drag_tab = [pane, editor, event.position]
+        end
+      when :tab_close
+        @workspace.request_close([args.last]) if event.button == :left
       when :editor
         pane, editor = args
         @workspace.focus(pane)
@@ -489,6 +558,15 @@ module Canopus
       @workspace.terminal.mouse(button: @terminal_drag, column: column, row: row, action: action,
         shift: modifiers.include?("shift"), alt: modifiers.include?("alt"), control: modifiers.include?("ctrl"))
     end
+
+    def terminal_paste(text)
+      if @workspace.settings["terminal"]["confirm_multiline_paste"] && text.match?(/[\r\n].*[\r\n]?/m)
+        @workspace.palette = {kind: :confirm_terminal_paste, query: "Paste multiple lines into the terminal?", index: 1,
+          matches: ["Paste", "Cancel"], text: text}
+      else
+        @workspace.terminal.paste(text)
+      end
+    end
     def resize_drag(point)
       kind, target, bounds = @resize_drag
       if kind == :split_resize

data/lib/canopus/language/syntax_worker.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "antares"
 require_relative "../../canopus"
 
 module Canopus

data/lib/canopus/pane.rb

@@ -27,13 +27,29 @@ module Canopus
     def pin(editor = active)
       @pinned << editor unless @pinned.include?(editor)
     end
-    def close(editor = active, discard: false)
+    def close(editor = active, discard: false, activate: :history)
       raise Error, "buffer has unsaved changes" if editor.buffer.dirty? && !discard
+      index = @editors.index(editor)
+      raise Error, "tab is not in pane" unless index
+      current = active
+      historical = @past.reverse.find { |item| !item.equal?(editor) && @editors.include?(item) }
       @pinned.delete(editor)
       @editors.delete(editor)
       @past.delete(editor)
       @future.delete(editor)
-      @active_index = [@active_index, @editors.length - 1].min.clamp(0, @editors.length)
+      @future.clear if current.equal?(editor)
+      @active_index = if @editors.empty?
+        0
+      elsif !current.equal?(editor)
+        @editors.index(current)
+      elsif activate == :history && historical
+        @past.delete(historical)
+        @editors.index(historical)
+      elsif activate == :left
+        [index - 1, 0].max
+      else
+        [index, @editors.length - 1].min
+      end
       editor.dispose
     end
     def detach(editor)

data/lib/canopus/settings.rb

@@ -7,7 +7,15 @@ module Canopus
   class Settings
     DEFAULTS = {"font_size" => 14, "tab_size" => 4, "use_tabs" => false, "soft_wrap" => false, "vim_mode" => false, "keymap" => [].freeze,
       "scroll_friction" => 12,
-      "theme" => "Canopus Dark", "font_family" => nil, "icon_theme" => nil, "languages" => {}, "language_servers" => {}}.freeze
+      "theme" => "Canopus Dark", "font_family" => nil, "icon_theme" => nil, "languages" => {}, "language_servers" => {},
+      "tabs" => {"activate_on_close" => "history", "close_on_middle_click" => true, "close_empty_pane" => true,
+        "reopen_history_limit" => 20, "confirm_on_close_dirty" => true}.freeze,
+      "dock" => {"bottom" => {"size" => 280, "visible" => false}.freeze}.freeze,
+      "terminal" => {"shell" => nil, "working_directory" => "project", "env" => {}.freeze, "scrollback_lines" => 10_000,
+        "font_size" => nil, "line_height" => 1.2, "copy_on_select" => false, "blinking" => "terminal_controlled", "cursor_shape" => "block",
+        "close_on_exit" => "clean", "confirm_close_running" => true, "confirm_multiline_paste" => true,
+        "restore_on_startup" => false, "hide_when_empty" => false, "max_bytes_per_frame" => 262_144,
+        "queue_limit_bytes" => 8_388_608, "resize_debounce_ms" => 100, "min_rows" => 4, "min_cols" => 20}.freeze}.freeze
     SCHEMA = {"$schema" => "https://json-schema.org/draft/2020-12/schema", "type" => "object", "properties" => {
       "font_size" => {"type" => "number", "minimum" => 6, "maximum" => 96},
       "tab_size" => {"type" => "integer", "minimum" => 1, "maximum" => 16},
@@ -19,6 +27,7 @@ module Canopus
         "bindings" => {"type" => "object", "maxProperties" => 1024, "additionalProperties" => {"type" => ["string", "null"]}}}}},
       "theme" => {"type" => "string"}, "font_family" => {"type" => ["string", "null"]},
       "icon_theme" => {"type" => ["string", "null"]},
+      "tabs" => {"type" => "object"}, "terminal" => {"type" => "object"}, "dock" => {"type" => "object"},
       "languages" => {"type" => "object", "additionalProperties" => {"$ref" => "#"}},
       "language_servers" => {"type" => "object"}}}.freeze
     attr_reader :values, :errors, :layers
@@ -85,6 +94,9 @@ module Canopus
       raise Error, "theme must be a string" unless @values["theme"].is_a?(String)
       raise Error, "font_family must be a string or null" unless @values["font_family"].nil? || @values["font_family"].is_a?(String)
       raise Error, "icon_theme must be a string or null" unless @values["icon_theme"].nil? || @values["icon_theme"].is_a?(String)
+      validate_tabs!
+      validate_terminal!
+      validate_dock!
       @values["languages"] = @values["languages"].to_h do |name, layer|
         raise Error, "language settings must be objects" unless name.is_a?(String) && layer.is_a?(Hash)
         raise Error, "language settings cannot contain nested languages" if layer.key?("languages")
@@ -114,5 +126,45 @@ module Canopus
     rescue ArgumentError => error
       raise Error, "invalid keymap: #{error.message}"
     end
+
+    def validate_tabs!
+      tabs = @values["tabs"]
+      raise Error, "tabs must be an object" unless tabs.is_a?(Hash)
+      raise Error, "invalid tabs.activate_on_close" unless %w[history neighbour left right].include?(tabs["activate_on_close"])
+      %w[close_on_middle_click close_empty_pane confirm_on_close_dirty].each do |key|
+        raise Error, "tabs.#{key} must be true or false" unless [true, false].include?(tabs[key])
+      end
+      limit = tabs["reopen_history_limit"]
+      raise Error, "invalid tabs.reopen_history_limit" unless limit.is_a?(Integer) && limit.between?(0, 1000)
+    end
+
+    def validate_terminal!
+      terminal = @values["terminal"]
+      raise Error, "terminal must be an object" unless terminal.is_a?(Hash)
+      raise Error, "invalid terminal.shell" unless terminal["shell"].nil? || terminal["shell"].is_a?(String) ||
+        (terminal["shell"].is_a?(Array) && terminal["shell"].all? { |value| value.is_a?(String) })
+      raise Error, "invalid terminal.working_directory" unless terminal["working_directory"].is_a?(String)
+      raise Error, "invalid terminal.env" unless terminal["env"].is_a?(Hash) && terminal["env"].all? { |key, value| key.is_a?(String) && (value.nil? || value.is_a?(String)) }
+      raise Error, "invalid terminal.font_size" unless terminal["font_size"].nil? || terminal["font_size"].is_a?(Numeric) && terminal["font_size"].between?(6, 96)
+      raise Error, "invalid terminal.line_height" unless terminal["line_height"].is_a?(Numeric) && terminal["line_height"].between?(0.5, 4)
+      %w[confirm_close_running confirm_multiline_paste copy_on_select restore_on_startup hide_when_empty].each do |key|
+        raise Error, "terminal.#{key} must be true or false" unless [true, false].include?(terminal[key])
+      end
+      raise Error, "invalid terminal.close_on_exit" unless %w[never clean always].include?(terminal["close_on_exit"])
+      raise Error, "invalid terminal.blinking" unless %w[off on terminal_controlled].include?(terminal["blinking"])
+      raise Error, "invalid terminal.cursor_shape" unless %w[block bar underline].include?(terminal["cursor_shape"])
+      {"scrollback_lines" => 0..1_000_000, "max_bytes_per_frame" => 1..16_777_216,
+       "queue_limit_bytes" => 65_536..268_435_456, "resize_debounce_ms" => 0..10_000,
+       "min_rows" => 1..1000, "min_cols" => 1..1000}.each do |key, range|
+        value = terminal[key]
+        raise Error, "invalid terminal.#{key}" unless value.is_a?(Integer) && range.cover?(value)
+      end
+    end
+
+    def validate_dock!
+      dock = @values["dock"]
+      bottom = dock["bottom"] if dock.is_a?(Hash)
+      raise Error, "invalid dock.bottom" unless bottom.is_a?(Hash) && bottom["size"].is_a?(Numeric) && bottom["size"].positive? && [true, false].include?(bottom["visible"])
+    end
   end
 end

data/lib/canopus/terminal/pty.rb

@@ -6,9 +6,13 @@ require "shellwords"
 module Canopus
   module Terminal
     class PTY
-      attr_reader :reader, :writer, :pid, :grid, :vt, :status
+      attr_reader :reader, :writer, :pid, :grid, :vt, :status, :initial_cwd, :command_name
 
-      def initialize(command: ENV.fetch("SHELL", "/bin/sh"), cwd: Dir.pwd, columns: 80, rows: 24, env: {}, scrollback: 10_000)
+      def initialize(command: ENV.fetch("SHELL", "/bin/sh"), cwd: Dir.pwd, columns: 80, rows: 24, env: {}, scrollback: 10_000,
+        queue_limit_bytes: 8_388_608)
+        raise ArgumentError, "terminal queue limit must be a positive integer" unless queue_limit_bytes.is_a?(Integer) && queue_limit_bytes.positive?
+        @initial_cwd = File.expand_path(cwd)
+        @command_name = File.basename(Array(command).first.to_s)
         @grid = Grid.new(columns: columns, rows: rows, scrollback: scrollback)
         if RUBY_PLATFORM.match?(/mswin|mingw/)
           require "zaniah/platform/windows/terminal"
@@ -27,38 +31,82 @@ module Canopus
         @writer.sync = true
         @vt = VT.new(grid) { |bytes| write(bytes) }
         resize(columns: columns, rows: rows)
+        @queue, @queue_bytes, @queue_limit_bytes = [], 0, queue_limit_bytes
+        @queue_lock, @queue_ready = Mutex.new, ConditionVariable.new
+        start_reader
       end
 
       # nil means EOF; an empty String means that no data was ready yet.
-      def read(timeout: 0, max_bytes: 65_536)
+      def read(timeout: 0, max_bytes: 65_536, max_seconds: nil)
+        raise ArgumentError, "terminal read limit must be a positive integer" unless max_bytes.is_a?(Integer) && max_bytes.positive?
+        raise ArgumentError, "terminal read timeout must be nonnegative" unless timeout.is_a?(Numeric) && timeout >= 0
+        raise ArgumentError, "terminal parse budget must be nonnegative" unless max_seconds.nil? || max_seconds.is_a?(Numeric) && max_seconds >= 0
         return nil if @eof
         if @native
           data = @native.read_available(limit: max_bytes)
           data ? vt.feed(data) : @eof = true
           return data
         end
-        return "" unless IO.select([reader], nil, nil, timeout)
-        data = reader.read_nonblock(max_bytes, exception: false)
-        return "" if data == :wait_readable
-        if data.nil?
-          @eof = true
-        else
-          vt.feed(data)
+        deadline = max_seconds && Process.clock_gettime(Process::CLOCK_MONOTONIC) + [max_seconds, 0].max
+        data = +"".b
+        loop do
+          break if data.bytesize >= max_bytes || deadline && Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+          piece = @queue_lock.synchronize do
+            @queue_ready.wait(@queue_lock, timeout) if data.empty? && @queue.empty? && !@reader_eof && timeout.positive?
+            if @queue.empty?
+              @eof = true if @reader_eof
+              nil
+            else
+              chunk = @queue.shift
+              take = [max_bytes - data.bytesize, chunk.bytesize, 16_384].min
+              result = chunk.byteslice(0, take)
+              @queue.unshift(chunk.byteslice(take..)) if take < chunk.bytesize
+              @queue_bytes -= take
+              @queue_ready.broadcast
+              result
+            end
+          end
+          break unless piece
+          vt.feed(piece)
+          data << piece
         end
-        data
-      rescue Errno::EIO, EOFError
-        @eof = true
-        nil
+        @eof && data.empty? ? nil : data
       end
 
+      def pending? = @native ? false : @queue_lock.synchronize { !@queue.empty? }
+
       def write(bytes) = @native ? @native.write(bytes) : writer.write(bytes)
       def paste(text) = write(vt.paste(text))
       def key(name, **modifiers) = write(vt.key(name, **modifiers))
       def mouse(**event) = write(vt.mouse(**event))
 
       def resize(columns:, rows:)
-        grid.resize(columns: columns, rows: rows)
+        dimensions = [columns, rows]
+        return self if @pty_size == dimensions
+        grid.resize(columns: columns, rows: rows) unless grid.columns == columns && grid.rows == rows
         @native ? @native.resize(columns, rows) : reader.winsize = [rows, columns]
+        @pty_size = dimensions
+        self
+      end
+
+      def busy?
+        !@native && alive? && reader.tcgetpgrp != pid
+      rescue IOError, SystemCallError, NoMethodError
+        false
+      end
+
+      def foreground_process_name(now: Process.clock_gettime(Process::CLOCK_MONOTONIC))
+        return @foreground_name if @foreground_checked && now - @foreground_checked < 1
+        @foreground_checked = now
+        group = reader.tcgetpgrp unless @native
+        value = if group && group != pid && File.file?("/proc/#{group}/comm")
+          File.read("/proc/#{group}/comm")
+        elsif group && group != pid
+          IO.popen(["ps", "-o", "comm=", "-p", group.to_s], &:read)
+        end
+        @foreground_name = value&.strip&.then { |name| File.basename(name) unless name.empty? }
+      rescue IOError, SystemCallError, NoMethodError
+        @foreground_name = nil
       end
 
       def signal(name = "INT")
@@ -81,11 +129,13 @@ module Canopus
 
       def close
         return @native.close if @native
+        @closing = true
+        @queue_lock.synchronize { @queue_ready.broadcast }
         signal("HUP") if alive?
         reader.close unless reader.closed?
         writer.close unless writer.closed?
         # A shell may trap HUP: reap it after a short grace period.
-        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 0.5
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 2
         while alive? && Process.clock_gettime(Process::CLOCK_MONOTONIC) < deadline
           sleep 0.01
         end
@@ -93,11 +143,36 @@ module Canopus
           signal("KILL")
           _, @status = Process.waitpid2(pid)
         end
+        @reader_thread&.join(0.2)
         @eof = true
         self
-      rescue Errno::ECHILD
+      rescue Errno::ECHILD, IOError
         self
       end
+
+      private
+
+      def start_reader
+        @reader_thread = Thread.new do
+          loop do
+            data = reader.readpartial(65_536)
+            @queue_lock.synchronize do
+              @queue_ready.wait(@queue_lock) while !@closing && @queue_bytes >= @queue_limit_bytes
+              break if @closing
+              @queue << data
+              @queue_bytes += data.bytesize
+              @queue_ready.broadcast
+            end
+          end
+        rescue Errno::EIO, EOFError, IOError
+          nil
+        ensure
+          @queue_lock.synchronize do
+            @reader_eof = true
+            @queue_ready.broadcast
+          end
+        end
+      end
     end
   end
 end

data/lib/canopus/version.rb

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