echoes 0.2.0 → 0.3.0

data/lib/echoes/pane.rb

@@ -17,7 +17,7 @@ module Echoes
                   :scroll_offset, :scroll_accum, :title, :copy_mode
     attr_reader :embedded_shell
 
-    def initialize(command:, rows:, cols:, cwd: nil, embedded: false, no_rc: false, editor_file: nil)
+    def initialize(command:, rows:, cols:, cwd: nil, embedded: false, no_rc: false, editor_file: nil, env: nil)
       @screen = Screen.new(rows: rows, cols: cols)
       if editor_file
         require_relative 'editor'
@@ -27,7 +27,13 @@ module Echoes
       elsif embedded
         require_relative 'embedded_shell'
         @embedded_shell = EmbeddedShell.new(no_rc: no_rc)
-        @parser = Parser.new(@screen, writer: ->(_s) { })
+        # Writer routes OSC replies (display-info, OSC 52 paste-back,
+        # color queries, terminfo replies, …) to the helper's pty
+        # master so the foreground program reads them on its stdin.
+        # While rubish is at the prompt, anything we write here lands
+        # in Reline; in practice query OSCs only come from a running
+        # foreground program (e.g. przn) so the routing is safe.
+        @parser = Parser.new(@screen, writer: ->(s) { @embedded_shell.forward_input(s) })
         @title = 'rubish'
         @input_buffer = +''
         @input_cursor = 0     # offset within @input_buffer (0..length)
@@ -47,14 +53,27 @@ module Echoes
       else
         start_dir = (cwd && Dir.exist?(cwd)) ? cwd : Dir.home
         Dir.chdir(start_dir) do
+          # When env: is nil (the default), we just normalize a few
+          # vars on our own process — the child then inherits the
+          # whole env from us, same as before. When env: is given,
+          # it's an explicit env Hash that fully replaces what the
+          # child sees, with our normalizations applied on top. The
+          # explicit form is used by the OSC 7772 ;open-window path
+          # so a child program (e.g. przn) reliably gets PATH /
+          # HOME / USER / LANG even when Echoes.app was launched by
+          # launchd with a minimal env.
           ENV['TERM'] = Echoes.config.term
           ENV['LANG'] ||= 'en_US.UTF-8'
           ENV['LC_CTYPE'] = 'UTF-8'
-          @pty_read, @pty_write, @pty_pid = PTY.spawn(command)
-          @pty_read.winsize = [rows, cols]
+          # `command` may be a String (shell-parsed by /bin/sh) or an
+          # Array of [argv0, *args] (execve directly, no shell). The
+          # array form is what the OSC 7772 ;open-window handler
+          # uses so user-supplied argv isn't subject to shell quoting.
+          spawn_args = command.is_a?(Array) ? command : [command]
+          @pty_read, @pty_write, @pty_pid = spawn_with_pty(spawn_args, env, rows, cols)
         end
         @parser = Parser.new(@screen, writer: ->(s) { @pty_write.write(s) rescue nil })
-        @title = File.basename(command)
+        @title = File.basename(command.is_a?(Array) ? command.first : command)
       end
       @scroll_offset = 0
       @scroll_accum = 0.0
@@ -89,7 +108,10 @@ module Echoes
     # embedded mode hands the line directly to the in-process REPL.
     def submit_line(line)
       if embedded?
-        @embedded_shell.submit_line(line)
+        @embedded_shell.submit_line(line,
+                                     rows: @screen.rows, cols: @screen.cols,
+                                     px_width:  pty_pixel_width(@screen.cols),
+                                     px_height: pty_pixel_height(@screen.rows))
       else
         @pty_write.write("#{line}\r") rescue nil
       end
@@ -145,9 +167,30 @@ module Echoes
         @editor.resize(rows: rows, cols: cols)
         render_editor
       elsif embedded?
-        @embedded_shell.resize(rows: rows, cols: cols)
+        @embedded_shell.resize(rows: rows, cols: cols,
+                                px_width:  pty_pixel_width(cols),
+                                px_height: pty_pixel_height(rows))
       else
-        @pty_read.winsize = [rows, cols]
+        @pty_read.winsize = pty_winsize_quad(rows, cols)
+      end
+    rescue Errno::EIO, IOError
+    end
+
+    # Re-send winsize with the current cell pixel metrics. Called
+    # by the GUI after `wire_screen_handlers` updates the Screen's
+    # cell_pixel_width / cell_pixel_height (font load, font size
+    # change, …), so TIOCGWINSZ on the slave side carries the
+    # right pixel dims — kitten icat and other image protocols
+    # read those instead of querying CSI 14 t.
+    def refresh_pty_pixel_size
+      rows = @screen.rows
+      cols = @screen.cols
+      if embedded?
+        @embedded_shell.resize(rows: rows, cols: cols,
+                                px_width:  pty_pixel_width(cols),
+                                px_height: pty_pixel_height(rows))
+      elsif @pty_read && !@pty_read.closed?
+        @pty_read.winsize = pty_winsize_quad(rows, cols)
       end
     rescue Errno::EIO, IOError
     end
@@ -484,7 +527,9 @@ module Echoes
         # Stash the command text on the OSC 133 mark so click-to-rerun
         # can recover it later.
         @screen.set_current_command_text(line)
-        @embedded_shell.submit_line(line, rows: @screen.rows, cols: @screen.cols)
+        @embedded_shell.submit_line(line, rows: @screen.rows, cols: @screen.cols,
+                                          px_width:  pty_pixel_width(@screen.cols),
+                                          px_height: pty_pixel_height(@screen.rows))
         @embedded_running = true
       end
     end
@@ -828,6 +873,60 @@ module Echoes
 
     private
 
+    # macOS ioctl numbers used by the manual pty setup below.
+    # PTY.spawn does setsid + TIOCSCTTY, but skips tcsetpgrp —
+    # leaving the slave's foreground process group unset (the
+    # macOS kernel doesn't fill it in automatically the way Linux
+    # does on TIOCSCTTY). The user's shell rc files then run
+    # things like `stty -ixon`, zsh fork+setpgid's stty into its
+    # own group for job control, that group has no parent in
+    # the slave's session, and tcsetattr returns
+    #   stty: tcsetattr: Input/output error
+    # because the calling group is "orphaned and not foreground".
+    # Pre-seeding the foreground pgrp to the shell's pid in the
+    # child — same way embedded_shell_helper does — makes the
+    # whole startup path tcsetattr-safe.
+    DARWIN_TIOCSCTTY = 0x20007461
+    DARWIN_TIOCSPGRP = 0x80047476
+
+    def spawn_with_pty(spawn_args, env, rows, cols)
+      master, slave = PTY.open
+      slave.winsize = pty_winsize_quad(rows, cols)
+      pid = fork do
+        master.close
+        Process.setsid rescue nil
+        slave.ioctl(DARWIN_TIOCSCTTY, 0) rescue nil
+        slave.ioctl(DARWIN_TIOCSPGRP, [Process.getpgrp].pack('i!')) rescue nil
+        STDIN.reopen(slave)
+        STDOUT.reopen(slave)
+        STDERR.reopen(slave)
+        slave.close rescue nil
+        if env
+          exec(env, *spawn_args)
+        else
+          exec(*spawn_args)
+        end
+      end
+      slave.close
+      [master, master, pid]
+    end
+
+    # 4-element winsize tuple [rows, cols, xpixel, ypixel] for
+    # TIOCSWINSZ. The pixel fields seed the slave's TIOCGWINSZ so
+    # processes that prefer ioctl over CSI 14 t (kitten icat,
+    # tput, …) see real screen pixel dims.
+    def pty_winsize_quad(rows, cols)
+      [rows, cols, pty_pixel_width(cols), pty_pixel_height(rows)]
+    end
+
+    def pty_pixel_width(cols)
+      (cols * @screen.cell_pixel_width).to_i
+    end
+
+    def pty_pixel_height(rows)
+      (rows * @screen.cell_pixel_height).to_i
+    end
+
     def complete_input
       req = completion_request
       return unless req

data/lib/echoes/parser.rb

@@ -30,8 +30,12 @@ module Echoes
 
     REPLACEMENT_CHAR = "\u{FFFD}"
     CSI_PARAM_LIMIT = 32
-    OSC_BUFFER_LIMIT = 4096
+    # 16 MB to accommodate OSC 1337 ;File= base64-encoded image
+    # payloads (iTerm2 inline images). Non-image OSCs are short
+    # and don't notice the higher cap.
+    OSC_BUFFER_LIMIT = 16 * 1024 * 1024
     DCS_BUFFER_LIMIT = 1024 * 1024  # 1 MB (sixel images can be large)
+    APC_BUFFER_LIMIT = 16 * 1024 * 1024  # 16 MB (kitty graphics can be big)
 
     def process_byte(byte)
       # UTF-8 continuation bytes
@@ -72,6 +76,8 @@ module Echoes
         csi_param(byte)
       when :osc_string
         osc_string(byte)
+      when :apc_string
+        apc_string(byte)
       when :dcs_entry
         dcs_entry(byte)
       when :dcs_param
@@ -137,6 +143,9 @@ module Echoes
       when 0x5D # ]
         @state = :osc_string
         @osc_string = "".b
+      when 0x5F # _ (APC — Application Program Command)
+        @state = :apc_string
+        @apc_string = "".b
       when 0x37 # 7
         @screen.save_cursor
         @state = :ground
@@ -289,6 +298,27 @@ module Echoes
       end
     end
 
+    # APC (Application Program Command) accumulator. Mirrors the
+    # OSC state shape: bytes accumulate until BEL or ST (`ESC \`),
+    # then `dispatch_apc` routes by namespace prefix. Currently
+    # only the kitty graphics protocol (`G…`) lives in here.
+    def apc_string(byte)
+      case byte
+      when 0x07 # BEL terminates APC
+        dispatch_apc
+        @state = :ground
+      when 0x1B # ESC — dispatch, enter escape state for ST (\)
+        dispatch_apc
+        @state = :escape
+      else
+        if @apc_string.bytesize < APC_BUFFER_LIMIT
+          @apc_string << byte
+        else
+          @state = :ground
+        end
+      end
+    end
+
     def dcs_entry(byte)
       case byte
       when 0x30..0x39
@@ -380,6 +410,23 @@ module Echoes
       end
     end
 
+    # APC body shape:  G<comma-separated-options>;<base64-payload>
+    # Anything not starting with `G` is some other private APC
+    # subprotocol we don't handle; ignore silently.
+    def dispatch_apc
+      body = @apc_string
+      return if body.empty?
+      return unless body.getbyte(0) == 0x47  # 'G'
+      meta_and_payload = body.byteslice(1..) || ''.b
+      meta, payload = meta_and_payload.split(';'.b, 2)
+      meta    = (meta || '').force_encoding('UTF-8')
+      payload = (payload || ''.b)
+      require_relative 'kitty_graphics'
+      @kitty_state ||= {chunks: {}, cache: {}}
+      KittyGraphics.handle_chunk(@kitty_state, meta, payload,
+                                 screen: @screen, writer: @writer)
+    end
+
     def dispatch_osc
       code, rest = @osc_string.split(';'.b, 2)
       return unless rest
@@ -413,12 +460,25 @@ module Echoes
       when '52'
         dispatch_osc52(rest)
         return
+      when '9'
+        # OSC 9 (iTerm2): everything after `9;` is the message body.
+        # Use the pane title as the notification title; the host
+        # decides how to render it.
+        deliver_notification(nil, rest)
+        return
+      when '777'
+        dispatch_osc777(rest)
+        return
       when '133'
         dispatch_osc133(rest)
         return
       when '7772'
         dispatch_osc7772(rest)
         return
+      when '1337'
+        require_relative 'iterm2_images'
+        Iterm2Images.handle(rest, screen: @screen, writer: @writer)
+        return
       when '66'
         # fall through to multicell handling below
       else
@@ -428,12 +488,20 @@ module Echoes
       return unless text
 
       text.force_encoding('UTF-8')
-      # `f=` is an Echoes extension that other terminals ignore.
-      # Family names containing `:` aren't representable here because
-      # `:` is the meta-field separator — use `,` or omit the colon
-      # in the family name (e.g. "Helvetica Neue", not "Foo:Italic").
-      params = {scale: 1, width: 0, frac_n: 0, frac_d: 0, valign: 0, halign: 0, family: nil}
-      meta_str.split(':').each do |pair|
+      @screen.put_multicell(text, **parse_multicell_meta(meta_str, allow_extensions: false))
+    end
+
+    # Parse the `key=value:key=value:...` meta block that lives in
+    # the second field of OSC 66 (and of OSC 7772 ;multicell).
+    # `allow_extensions: false` accepts only the kitty spec keys
+    # (s/w/n/d/v/h) so OSC 66 stays strictly compatible with other
+    # terminals — Echoes-private knobs (f=family, flip=h|v|hv) are
+    # routed through OSC 7772 ;multicell, where collisions with a
+    # future kitty spec extension can't surprise emitters.
+    def parse_multicell_meta(meta_str, allow_extensions:)
+      params = {scale: 1, width: 0, frac_n: 0, frac_d: 0, valign: 0, halign: 0,
+                 family: nil, flip_h: false, flip_v: false}
+      meta_str.to_s.split(':').each do |pair|
         k, v = pair.split('=', 2)
         next unless v
         case k
@@ -443,11 +511,24 @@ module Echoes
         when 'd' then params[:frac_d] = v.to_i.clamp(0, 15)
         when 'v' then params[:valign] = v.to_i.clamp(0, 2)
         when 'h' then params[:halign] = v.to_i.clamp(0, 2)
-        when 'f' then params[:family] = v unless v.empty?
+        when 'f'
+          # Family name. Names with ':' aren't representable here
+          # because ':' is the meta-field separator — use ',' or
+          # omit the colon (e.g. "Helvetica Neue", not "Foo:Italic").
+          params[:family] = v if allow_extensions && !v.empty?
+        when 'flip'
+          # Mirror the rendered glyph(s). `flip=h` horizontal,
+          # `flip=v` vertical, `flip=hv` / `flip=vh` both. Handy
+          # for direction-having emojis (e.g. flipping 🐇 to face
+          # the other way).
+          if allow_extensions
+            flip = v.downcase
+            params[:flip_h] = flip.include?('h')
+            params[:flip_v] = flip.include?('v')
+          end
         end
       end
-
-      @screen.put_multicell(text, **params)
+      params
     end
 
     def dispatch_osc_default_color(key, osc_code, spec)
@@ -521,9 +602,26 @@ module Echoes
     #   bg-gradient ; type=linear:angle=N:colors=#rrggbb,#rrggbb[,...]
     #   bg-fill     ; color=#rrggbb:rect=row1,col1,row2,col2
     #   bg-clear                           (revert to default_bg)
+    #   capture     ; <absolute-path-to.png>
+    #   display-info                        (sync query — host writes
+    #                                        \e]7772;display-info;<json>\a
+    #                                        back to the pty)
+    #   open-window ; display=N:program=<base64-argv>:fullscreen=yes|no
+    #   multicell   ; <params> ; <text>    (OSC-66-shaped multicell + the
+    #                                        Echoes-only knobs `f=family`
+    #                                        and `flip=h|v|hv`. Use this
+    #                                        instead of putting extensions
+    #                                        on OSC 66 so portable emitters
+    #                                        can keep OSC 66 strictly
+    #                                        kitty-compatible.)
     def dispatch_osc7772(rest)
       command, args = rest.split(';', 2)
       case command
+      when 'multicell'
+        meta_str, text = (args || '').split(';', 2)
+        return unless text
+        text.force_encoding('UTF-8')
+        @screen.put_multicell(text, **parse_multicell_meta(meta_str, allow_extensions: true))
       when 'bg-color'
         rgba = parse_hex_color((args || '').strip)
         if rgba
@@ -546,6 +644,20 @@ module Echoes
         @screen.background = nil
         @screen.bg_fills.clear if @screen.respond_to?(:bg_fills) && @screen.bg_fills
         @screen.mark_all_dirty if @screen.respond_to?(:mark_all_dirty)
+      when 'capture'
+        path = (args || '').strip
+        if !path.empty? && @screen.respond_to?(:capture_handler) && @screen.capture_handler
+          @screen.capture_handler.call(path)
+        end
+      when 'display-info'
+        if @screen.respond_to?(:display_info_handler) && @screen.display_info_handler
+          json = @screen.display_info_handler.call.to_s
+          @writer.call("\e]7772;display-info;#{json}\a") if @writer
+        end
+      when 'open-window'
+        if @screen.respond_to?(:open_window_handler) && @screen.open_window_handler
+          @screen.open_window_handler.call(args || '')
+        end
       end
     end
 
@@ -611,6 +723,27 @@ module Echoes
       end
     end
 
+    # OSC 777 — VTE-style notifications:
+    #   \e]777;notify;<title>;<message>\a
+    # Some emitters omit the body, sending only a title.
+    def dispatch_osc777(rest)
+      parts = rest.split(';', 3)
+      return unless parts[0] == 'notify'
+      title   = parts[1] || ''
+      message = parts[2] || ''
+      deliver_notification(title.empty? ? nil : title, message)
+    end
+
+    # Hand off to whatever the host wired into `screen.notification_handler`.
+    # Title is nil when the emitter (OSC 9) didn't supply one — the
+    # host typically falls back to the pane title or "Echoes". A
+    # missing handler is a no-op so the parser never raises on
+    # non-GUI tests.
+    def deliver_notification(title, message)
+      return unless @screen.respond_to?(:notification_handler) && @screen.notification_handler
+      @screen.notification_handler.call(title, message)
+    end
+
     def dispatch_osc133(rest)
       return unless @screen.respond_to?(:osc133_mark)
       parts = rest.split(';')
@@ -712,6 +845,7 @@ module Echoes
         when 1006 then @screen.mouse_encoding = :sgr
         when 1004 then @screen.focus_reporting = true
         when 2004 then @screen.bracketed_paste_mode = true
+        when 2026 then @screen.sync_active = true
         when 1049
           @screen.save_cursor
           @screen.switch_to_alt_screen
@@ -741,6 +875,7 @@ module Echoes
         when 1006 then @screen.mouse_encoding = :default
         when 1004 then @screen.focus_reporting = false
         when 2004 then @screen.bracketed_paste_mode = false
+        when 2026 then @screen.sync_active = false
         when 1049
           @screen.switch_to_main_screen
           @screen.restore_cursor

data/lib/echoes/profile.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Echoes
+  # A named color theme — foreground / background / cursor / selection
+  # plus the 16-entry ANSI palette that drives the 256-color table.
+  # Defined in `~/.config/echoes/echoes.conf` via the `profile` DSL:
+  #
+  #   profile "Solarized Dark" do
+  #     foreground "#93a1a1"
+  #     background "#002b36"
+  #     cursor_color "#93a1a1", 0.7
+  #     selection_color "#586e75"
+  #     color_palette %w[#073642 #dc322f #859900 #b58900 #268bd2
+  #                      #d33682 #2aa198 #eee8d5 #002b36 #cb4b16
+  #                      #586e75 #657b83 #839496 #6c71c4 #93a1a1 #fdf6e3]
+  #   end
+  #
+  # Attributes left unset inherit from `Echoes.config` so a profile
+  # can be a partial override.
+  class Profile
+    attr_reader :name
+
+    def initialize(name)
+      @name = name.to_s
+      @foreground = nil
+      @background = nil
+      @cursor_color = nil
+      @selection_color = nil
+      @color_palette = nil
+    end
+
+    def foreground(*args)
+      args.empty? ? (@foreground || Echoes.config.foreground) : @foreground = parse_color(args)
+    end
+
+    def background(*args)
+      args.empty? ? (@background || Echoes.config.background) : @background = parse_color(args)
+    end
+
+    def cursor_color(*args)
+      args.empty? ? (@cursor_color || Echoes.config.cursor_color) : @cursor_color = parse_color(args)
+    end
+
+    def selection_color(*args)
+      args.empty? ? (@selection_color || Echoes.config.selection_color) : @selection_color = parse_color(args)
+    end
+
+    def color_palette(val = nil)
+      if val
+        @color_palette = val.map { |c| c.is_a?(String) ? parse_color([c]) : c.map(&:to_f) }
+      else
+        @color_palette || Echoes.config.color_palette
+      end
+    end
+
+    private
+
+    def parse_color(args)
+      if args.size == 1 && args[0].is_a?(String)
+        hex = args[0].delete_prefix('#')
+        r = hex[0, 2].to_i(16) / 255.0
+        g = hex[2, 2].to_i(16) / 255.0
+        b = hex[4, 2].to_i(16) / 255.0
+        if hex.size == 8
+          a = hex[6, 2].to_i(16) / 255.0
+          [r, g, b, a]
+        else
+          [r, g, b]
+        end
+      else
+        args.map(&:to_f)
+      end
+    end
+  end
+end