ory-client 1.22.66 → 1.22.78

data/vendor/bundle/ruby/3.2.0/gems/{io-console-0.8.2 → io-console-0.9.4}/lib/io/console/size.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: false
 # fallback to console window size
 def IO.default_console_size
+  lines = ENV["LINES"].to_i
+  columns = ENV["COLUMNS"].to_i
   [
-    ENV["LINES"].to_i.nonzero? || 25,
-    ENV["COLUMNS"].to_i.nonzero? || 80,
+    lines.positive? ? lines : 25,
+    columns.positive? ? columns : 80,
   ]
 end
 

data/vendor/bundle/ruby/3.2.0/gems/{reline-0.6.3 → reline-0.7.0}/lib/reline/io/ansi.rb

@@ -114,13 +114,15 @@ class Reline::ANSI < Reline::IO
   end
 
   def inner_getc(timeout_second)
-    unless @buf.empty?
-      return @buf.shift
-    end
-    until @input.wait_readable(0.01)
+    while true
+      # @buf may change while handling signal, so we need to check it in each loop iteration.
+      return @buf.shift unless @buf.empty?
+      break if @input.wait_readable(0.01)
+
       timeout_second -= 0.01
       return nil if timeout_second <= 0
 
+      # handle_signal may call cursor_pos which modifies @buf
       Reline.core.line_editor.handle_signal
     end
     c = @input.getbyte

data/vendor/bundle/ruby/3.2.0/gems/{reline-0.6.3 → reline-0.7.0}/lib/reline/io/windows.rb

@@ -31,6 +31,42 @@ class Reline::Windows < Reline::IO
     @SetConsoleMode = Win32API.new('kernel32', 'SetConsoleMode', ['L', 'L'], 'L')
     @WaitForSingleObject = Win32API.new('kernel32', 'WaitForSingleObject', ['L', 'L'], 'L')
 
+    # Win32API does not have pointer size integer.
+    # Current process pseudo handle (-1)LL seems to fail to be passed to DuplicateHandle.
+    # @GetCurrentProcess = Win32API.new('kernel32', 'GetCurrentProcess', [], 'L')
+    @GetCurrentProcessId = Win32API.new('kernel32', 'GetCurrentProcessId', [], 'L')
+    @OpenProcess = Win32API.new('kernel32', 'OpenProcess', ['L', 'L', 'L'], 'L')
+    @CloseHandle = Win32API.new('kernel32', 'CloseHandle', ['L'], 'L')
+    @DuplicateHandle = Win32API.new('kernel32', 'DuplicateHandle', ['L', 'L', 'L', 'P', 'I', 'I', 'I'], 'L')
+
+    current_process_handle = @OpenProcess.call(
+      0x0040,  # PROCESS_DUP_HANDLE
+      0,       # bInheritHandle
+      @GetCurrentProcessId.call()
+    )
+    duplicate_handle = proc { |handle|
+      dupHandle = "\0" * 8
+      @DuplicateHandle.call(
+        current_process_handle,
+        handle,
+        current_process_handle,
+        dupHandle,
+        0,  # dwDesiredAccess
+        0,  # bInheritHandle
+        2   # dwOptions = DUPLICATE_SAME_ACCESS
+      )
+      dupHandle.unpack1("J")
+    }
+    if (dup = duplicate_handle.call(@hConsoleHandle)) != 0
+      @hConsoleHandle = dup
+      at_exit { @CloseHandle.call(@hConsoleHandle) }
+    end
+    if (dup = duplicate_handle.call(@hConsoleInputHandle)) != 0
+      @hConsoleInputHandle = dup
+      at_exit { @CloseHandle.call(@hConsoleInputHandle) }
+    end
+    @CloseHandle.call(current_process_handle)
+
     @legacy_console = getconsolemode & ENABLE_VIRTUAL_TERMINAL_PROCESSING == 0
   end
 
@@ -162,24 +198,14 @@ class Reline::Windows < Reline::IO
   ENABLE_WRAP_AT_EOL_OUTPUT = 2
   ENABLE_VIRTUAL_TERMINAL_PROCESSING = 4
 
-  # Calling Win32API with console handle is reported to fail after executing some external command.
-  # We need to refresh console handle and retry the call again.
-  private def call_with_console_handle(win32func, *args)
-    val = win32func.call(@hConsoleHandle, *args)
-    return val if val != 0
-
-    @hConsoleHandle = @GetStdHandle.call(STD_OUTPUT_HANDLE)
-    win32func.call(@hConsoleHandle, *args)
-  end
-
   private def getconsolemode
     mode = +"\0\0\0\0"
-    call_with_console_handle(@GetConsoleMode, mode)
+    @GetConsoleMode.call(@hConsoleHandle, mode)
     mode.unpack1('L')
   end
 
   private def setconsolemode(mode)
-    call_with_console_handle(@SetConsoleMode, mode)
+    @SetConsoleMode.call(@hConsoleHandle, mode)
   end
 
   #if @legacy_console
@@ -355,7 +381,7 @@ class Reline::Windows < Reline::IO
     # [18,2] dwMaximumWindowSize.X
     # [20,2] dwMaximumWindowSize.Y
     csbi = 0.chr * 22
-    if call_with_console_handle(@GetConsoleScreenBufferInfo, csbi) != 0
+    if @GetConsoleScreenBufferInfo.call(@hConsoleHandle, csbi) != 0
       # returns [width, height, x, y, attributes, left, top, right, bottom]
       csbi.unpack("s9")
     else
@@ -377,7 +403,7 @@ class Reline::Windows < Reline::IO
 
   def move_cursor_column(val)
     _, _, _, y, = get_console_screen_buffer_info
-    call_with_console_handle(@SetConsoleCursorPosition, y * 65536 + val) if y
+    @SetConsoleCursorPosition.call(@hConsoleHandle, y * 65536 + val) if y
   end
 
   def move_cursor_up(val)
@@ -386,7 +412,7 @@ class Reline::Windows < Reline::IO
       return unless y
       y = (y - top) - val
       y = 0 if y < 0
-      call_with_console_handle(@SetConsoleCursorPosition, (y + top) * 65536 + x)
+      @SetConsoleCursorPosition.call(@hConsoleHandle, (y + top) * 65536 + x)
     elsif val < 0
       move_cursor_down(-val)
     end
@@ -399,7 +425,7 @@ class Reline::Windows < Reline::IO
       screen_height = bottom - top
       y = (y - top) + val
       y = screen_height if y > screen_height
-      call_with_console_handle(@SetConsoleCursorPosition, (y + top) * 65536 + x)
+      @SetConsoleCursorPosition.call(@hConsoleHandle, (y + top) * 65536 + x)
     elsif val < 0
       move_cursor_up(-val)
     end
@@ -409,8 +435,8 @@ class Reline::Windows < Reline::IO
     width, _, x, y, attributes, = get_console_screen_buffer_info
     return unless x
     written = 0.chr * 4
-    call_with_console_handle(@FillConsoleOutputCharacter, 0x20, width - x, y * 65536 + x, written)
-    call_with_console_handle(@FillConsoleOutputAttribute, attributes, width - x, y * 65536 + x, written)
+    @FillConsoleOutputCharacter.call(@hConsoleHandle, 0x20, width - x, y * 65536 + x, written)
+    @FillConsoleOutputAttribute.call(@hConsoleHandle, attributes, width - x, y * 65536 + x, written)
   end
 
   # This only works when the cursor is at the bottom of the scroll range
@@ -428,9 +454,9 @@ class Reline::Windows < Reline::IO
       fill_length = width * (bottom - top + 1)
       screen_topleft = top * 65536
       written = 0.chr * 4
-      call_with_console_handle(@FillConsoleOutputCharacter, 0x20, fill_length, screen_topleft, written)
-      call_with_console_handle(@FillConsoleOutputAttribute, attributes, fill_length, screen_topleft, written)
-      call_with_console_handle(@SetConsoleCursorPosition, screen_topleft)
+      @FillConsoleOutputCharacter.call(@hConsoleHandle, 0x20, fill_length, screen_topleft, written)
+      @FillConsoleOutputAttribute.call(@hConsoleHandle, attributes, fill_length, screen_topleft, written)
+      @SetConsoleCursorPosition.call(@hConsoleHandle, screen_topleft)
     else
       @output.write "\e[2J" "\e[H"
     end
@@ -444,14 +470,14 @@ class Reline::Windows < Reline::IO
     size = 100
     visible = 0 # 0 means false
     cursor_info = [size, visible].pack('Li')
-    call_with_console_handle(@SetConsoleCursorInfo, cursor_info)
+    @SetConsoleCursorInfo.call(@hConsoleHandle, cursor_info)
   end
 
   def show_cursor
     size = 100
     visible = 1 # 1 means true
     cursor_info = [size, visible].pack('Li')
-    call_with_console_handle(@SetConsoleCursorInfo, cursor_info)
+    @SetConsoleCursorInfo.call(@hConsoleHandle, cursor_info)
   end
 
   def set_winch_handler(&handler)

data/vendor/bundle/ruby/3.2.0/gems/{reline-0.6.3 → reline-0.7.0}/lib/reline/io.rb

@@ -10,15 +10,21 @@ module Reline
         require 'reline/io/ansi'
 
         case RbConfig::CONFIG['host_os']
-        when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+        when /mswin|mingw|bccwin|wince|emc/
           require 'reline/io/windows'
           io = Reline::Windows.new
-          if io.msys_tty?
+          if io.msys_tty? || !STDIN.tty?
+            # In either case stdin is not a console (a Cygwin/MSYS pty pipe such
+            # as mintty, or a redirect), so the Win32 console input API cannot
+            # read it.
             Reline::ANSI.new
           else
             io
           end
         else
+          # Ruby built with the msys/cygwin runtime also reaches here. Its tty layer
+          # speaks ANSI in any terminal (mintty pty or Windows console), so the
+          # Win32 console API must not be used. https://github.com/ruby/reline/issues/903
           Reline::ANSI.new
         end
       end

data/vendor/bundle/ruby/3.2.0/gems/{reline-0.6.3 → reline-0.7.0}/lib/reline/line_editor.rb

@@ -13,6 +13,7 @@ class Reline::LineEditor
   attr_accessor :prompt_proc
   attr_accessor :auto_indent_proc
   attr_accessor :dig_perfect_match_proc
+  attr_accessor :rprompt
 
   VI_MOTIONS = %i{
     ed_prev_char
@@ -43,7 +44,6 @@ class Reline::LineEditor
   RenderedScreen = Struct.new(:base_y, :lines, :cursor_y, keyword_init: true)
 
   CompletionJourneyState = Struct.new(:line_index, :pre, :target, :post, :list, :pointer)
-  NullActionState = [nil, nil].freeze
 
   class MenuInfo
     attr_reader :list
@@ -223,7 +223,7 @@ class Reline::LineEditor
 
   def reset_variables(prompt = '')
     @prompt = prompt.gsub("\n", "\\n")
-    @mark_pointer = nil
+    @mark_position = nil
     @is_multiline = false
     @finished = false
     @history_pointer = nil
@@ -253,8 +253,8 @@ class Reline::LineEditor
     @undo_redo_history = [[[""], 0, 0]]
     @undo_redo_index = 0
     @restoring = false
-    @prev_action_state = NullActionState
-    @next_action_state = NullActionState
+    @prev_action_state = {}
+    @next_action_state = {}
     reset_line
   end
 
@@ -476,6 +476,20 @@ class Reline::LineEditor
       prompt_width = Reline::Unicode.calculate_width(prompt, true)
       [[0, prompt_width, prompt], [prompt_width, Reline::Unicode.calculate_width(line, true), line]]
     end
+
+    # Add rprompt to the first visible line if set and there's room
+    if @rprompt && !@rprompt.empty? && new_lines[0]
+      rprompt_width = Reline::Unicode.calculate_width(@rprompt, true)
+      right_col = screen_width - rprompt_width
+      first_line = new_lines[0]
+      # Calculate the end of the current content (prompt + input)
+      content_end = first_line.sum { |_, width, _| width }
+      # Only show rprompt if there's at least 1 char gap between content and rprompt
+      if right_col > content_end
+        first_line << [right_col, rprompt_width, @rprompt]
+      end
+    end
+
     if @menu_info
       @menu_info.lines(screen_width).each do |item|
         new_lines << [[0, Reline::Unicode.calculate_width(item), item]]
@@ -491,8 +505,8 @@ class Reline::LineEditor
         next if row < 0 || row >= screen_height
 
         dialog_rows = new_lines[row] ||= []
-        # index 0 is for prompt, index 1 is for line, index 2.. is for dialog
-        dialog_rows[index + 2] = [x_range.begin, dialog.width, dialog.contents[row - y_range.begin]]
+        # index 0 is for prompt, index 1 is for line, index 2 is for rprompt, index 3.. is for dialog
+        dialog_rows[index + 3] = [x_range.begin, dialog.width, dialog.contents[row - y_range.begin]]
       end
     end
 
@@ -1022,7 +1036,7 @@ class Reline::LineEditor
       @byte_pointer -= byte_size
     end
 
-    @prev_action_state, @next_action_state = @next_action_state, NullActionState
+    @prev_action_state, @next_action_state = @next_action_state, {}
 
     unless @completion_occurs
       @completion_state = CompletionState::NORMAL
@@ -1779,17 +1793,24 @@ class Reline::LineEditor
 
   private def em_yank(key)
     yanked = @kill_ring.yank
-    insert_text(yanked) if yanked
+    return unless yanked
+
+    before_cursor = current_line.byteslice(0, @byte_pointer)
+    after_cursor = current_line.byteslice(@byte_pointer, current_line.bytesize)
+    set_current_line(before_cursor + yanked + after_cursor, before_cursor.bytesize + yanked.bytesize)
+    set_next_action_state(:em_yank_line, [before_cursor, after_cursor])
   end
   alias_method :yank, :em_yank
 
   private def em_yank_pop(key)
-    yanked, prev_yank = @kill_ring.yank_pop
-    if yanked
-      line, = byteslice!(current_line, @byte_pointer - prev_yank.bytesize, prev_yank.bytesize)
-      set_current_line(line, @byte_pointer - prev_yank.bytesize)
-      insert_text(yanked)
-    end
+    before_cursor, after_cursor = prev_action_state_value(:em_yank_line)
+    return unless before_cursor and after_cursor
+
+    yanked, = @kill_ring.yank_pop
+    return unless yanked
+
+    set_current_line(before_cursor + yanked + after_cursor, before_cursor.bytesize + yanked.bytesize)
+    set_next_action_state(:em_yank_line, [before_cursor, after_cursor])
   end
   alias_method :yank_pop, :em_yank_pop
 
@@ -2303,15 +2324,22 @@ class Reline::LineEditor
   end
 
   private def em_set_mark(key)
-    @mark_pointer = [@byte_pointer, @line_index]
+    cursor_column = Reline::Unicode.calculate_width(current_line.byteslice(0, @byte_pointer))
+    @mark_position = [@line_index, cursor_column]
   end
   alias_method :set_mark, :em_set_mark
 
   private def em_exchange_mark(key)
-    return unless @mark_pointer
-    new_pointer = [@byte_pointer, @line_index]
-    @byte_pointer, @line_index = @mark_pointer
-    @mark_pointer = new_pointer
+    return unless @mark_position
+    line_index, cursor_column = @mark_position
+    em_set_mark(key)
+    if @buffer_of_lines.size <= line_index
+      @line_index = @buffer_of_lines.size - 1
+      @byte_pointer = current_line.bytesize
+    else
+      @line_index = line_index
+      calculate_nearest_cursor(cursor_column)
+    end
   end
   alias_method :exchange_point_and_mark, :em_exchange_mark
 
@@ -2343,11 +2371,11 @@ class Reline::LineEditor
   end
 
   private def prev_action_state_value(type)
-    @prev_action_state[0] == type ? @prev_action_state[1] : nil
+    @prev_action_state[type]
   end
 
   private def set_next_action_state(type, value)
-    @next_action_state = [type, value]
+    @next_action_state[type] = value
   end
 
   private def re_read_init_file(_key)

data/vendor/bundle/ruby/3.2.0/gems/reline-0.7.0/lib/reline/version.rb

@@ -0,0 +1,3 @@
+module Reline
+  VERSION = '0.7.0'
+end

data/vendor/bundle/ruby/3.2.0/gems/{reline-0.6.3 → reline-0.7.0}/lib/reline.rb

@@ -247,19 +247,19 @@ module Reline
     } # :nodoc:
     Reline::DEFAULT_DIALOG_CONTEXT = Array.new # :nodoc:
 
-    def readmultiline(prompt = '', add_hist = false, &confirm_multiline_termination)
+    def readmultiline(_prompt = '', _add_history = false, prompt: _prompt, add_history: _add_history, rprompt: nil, &confirm_multiline_termination)
       @mutex.synchronize do
         unless confirm_multiline_termination
           raise ArgumentError.new('#readmultiline needs block to confirm multiline termination')
         end
 
         io_gate.with_raw_input do
-          inner_readline(prompt, add_hist, true, &confirm_multiline_termination)
+          inner_readline(prompt, add_history, true, rprompt: rprompt, &confirm_multiline_termination)
         end
 
         whole_buffer = line_editor.whole_buffer.dup
         whole_buffer.taint if RUBY_VERSION < '2.7'
-        if add_hist and whole_buffer and whole_buffer.chomp("\n").size > 0
+        if add_history and whole_buffer and whole_buffer.chomp("\n").size > 0
           Reline::HISTORY << whole_buffer
         end
 
@@ -273,15 +273,15 @@ module Reline
       end
     end
 
-    def readline(prompt = '', add_hist = false)
+    def readline(_prompt = '', _add_history = false, prompt: _prompt, add_history: _add_history, rprompt: nil)
       @mutex.synchronize do
         io_gate.with_raw_input do
-          inner_readline(prompt, add_hist, false)
+          inner_readline(prompt, add_history, false, rprompt: rprompt)
         end
 
         line = line_editor.line.dup
         line.taint if RUBY_VERSION < '2.7'
-        if add_hist and line and line.chomp("\n").size > 0
+        if add_history and line and line.chomp("\n").size > 0
           Reline::HISTORY << line.chomp("\n")
         end
 
@@ -290,7 +290,7 @@ module Reline
       end
     end
 
-    private def inner_readline(prompt, add_hist, multiline, &confirm_multiline_termination)
+    private def inner_readline(prompt, add_history, multiline, rprompt: nil, &confirm_multiline_termination)
       if ENV['RELINE_STDERR_TTY']
         if io_gate.win?
           $stderr = File.open(ENV['RELINE_STDERR_TTY'], 'a')
@@ -323,6 +323,7 @@ module Reline
       line_editor.prompt_proc = prompt_proc
       line_editor.auto_indent_proc = auto_indent_proc
       line_editor.dig_perfect_match_proc = dig_perfect_match_proc
+      line_editor.rprompt = rprompt&.encode(encoding)
 
       pre_input_hook&.call
 
@@ -442,13 +443,13 @@ module Reline
   ##
   # :singleton-method: readmultiline
   # :call-seq:
-  #   readmultiline(prompt = '', add_hist = false, &confirm_multiline_termination) -> string or nil
+  #   readmultiline(prompt = '', add_history = false, &confirm_multiline_termination) -> string or nil
   def_single_delegators :core, :readmultiline
 
   ##
   # :singleton-method: readline
   # :call-seq:
-  #   readline(prompt = '', add_hist = false) -> string or nil
+  #   readline(prompt = '', add_history = false) -> string or nil
   def_single_delegators :core, :readline
   def_single_delegators :core, :completion_case_fold, :completion_case_fold=
   def_single_delegators :core, :completion_quote_character

data/vendor/bundle/ruby/3.2.0/specifications/{io-console-0.8.2.gemspec → io-console-0.9.4.gemspec}

@@ -1,16 +1,16 @@
 # -*- encoding: utf-8 -*-
-# stub: io-console 0.8.2 ruby lib
+# stub: io-console 0.9.4 ruby lib
 # stub: ext/io/console/extconf.rb
 
 Gem::Specification.new do |s|
   s.name = "io-console".freeze
-  s.version = "0.8.2"
+  s.version = "0.9.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.metadata = { "changelog_uri" => "https://github.com/ruby/io-console/releases", "source_code_url" => "https://github.com/ruby/io-console" } if s.respond_to? :metadata=
   s.require_paths = ["lib".freeze]
   s.authors = ["Nobu Nakada".freeze]
-  s.date = "2025-12-14"
+  s.date = "2026-09-17"
   s.description = "add console capabilities to IO instances.".freeze
   s.email = "nobu@ruby-lang.org".freeze
   s.extensions = ["ext/io/console/extconf.rb".freeze]

data/vendor/bundle/ruby/3.2.0/specifications/{reline-0.6.3.gemspec → reline-0.7.0.gemspec}

@@ -1,9 +1,9 @@
 # -*- encoding: utf-8 -*-
-# stub: reline 0.6.3 ruby lib
+# stub: reline 0.7.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "reline".freeze
-  s.version = "0.6.3"
+  s.version = "0.7.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.metadata = { "bug_tracker_uri" => "https://github.com/ruby/reline/issues", "changelog_uri" => "https://github.com/ruby/reline/releases", "source_code_uri" => "https://github.com/ruby/reline" } if s.respond_to? :metadata=