expect-pty 0.5.3 → 0.7.1

data/examples/kibitz/kibitz.rb

@@ -1,142 +0,0 @@
-# frozen_string_literal: true
-
-require "socket"
-require "tmpdir"
-require "optparse"
-require "shellwords"
-require_relative "../../lib/expect/pty"
-
-# Local counterpart of jacoby/expect.pm examples/kibitz: both keyboards feed
-# one process, whose output is broadcast to both terminals using listeners.
-module Kibitz
-  ESCAPE = "\x1d".b.freeze
-
-  def self.relay(input:, output:, peer:, shell: nil, escape: ESCAPE, timeout: nil, log: nil)
-    Expect.open(input, log_stdout: false, write_timeout: 5) do |keyboard|
-      Expect.open(peer, log_stdout: false, write_timeout: 5) do |partner|
-        keyboard.on_sequence(escape) if escape
-        if shell
-          keyboard.listeners = [shell]
-          partner.listeners = [shell]
-          shell.listeners = [output, partner]
-          shell.log_stdout = false
-          shell.log_output = log if log
-          # Keep canonical input, echo and ISIG on the process's own terminal.
-          shell.raw_terminal = false
-        else
-          keyboard.listeners = [partner]
-          partner.listeners = [output]
-          partner.log_output = log if log
-        end
-        stopped = Expect.interconnect(*[keyboard, partner, shell].compact, timeout: timeout)
-        reason = if stopped.nil?
-                   :timeout
-                 elsif stopped.equal?(keyboard)
-                   :local
-                 elsif stopped.equal?(partner)
-                   :peer
-                 else
-                   :process
-                 end
-        { reason: reason, tail: keyboard.buffer }
-      end
-    end
-  end
-
-  def self.escape(value)
-    return (value.getbyte(1) & 31).chr if value.match?(/\A\^[@A-Z\[\\\]\^_]\z/)
-
-    raise OptionParser::InvalidArgument, "escape must not be empty" if value.empty?
-
-    value
-  end
-
-  # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity -- CLI 建连、终端接管和 ensure 清理共享一次生命周期。
-  def self.run(argv, input: $stdin, output: $stdout)
-    options = { escape: ESCAPE }
-    parser = OptionParser.new do |opts|
-      opts.banner = "Usage: ruby examples/kibitz/kibitz.rb [options] [-- program args...]"
-      opts.on("--join SOCKET", "Join the local session printed by its host") { |value| options[:join] = value }
-      opts.on("--noproc", "Exchange input directly, with no shared process or local echo") { options[:noproc] = true }
-      opts.on("--escape TEXT", "Local exit sequence (default ^]; caret notation accepted)") do |value|
-        options[:escape] = escape(value)
-      end
-      opts.on("--noescape", "Forward all keys; end by exiting the shared process") { options[:escape] = nil }
-      opts.on("--timeout SECONDS", Float, "Limit connection wait and then relay duration") do |value|
-        options[:timeout] = value
-      end
-      opts.on("--log FILE", "Create a new received-output log (0600)") { |value| options[:log] = value }
-      opts.on("-h", "--help") do
-        output.puts(opts)
-        return 0
-      end
-    end
-    parser.order!(argv)
-    raise OptionParser::InvalidArgument, "a terminal is required" unless input.tty?
-    if options[:timeout] && (!options[:timeout].finite? || options[:timeout] <= 0)
-      raise OptionParser::InvalidArgument,
-            "timeout must be positive and finite"
-    end
-    if options[:join] && (options[:noproc] || !argv.empty?)
-      raise OptionParser::InvalidArgument,
-            "--join cannot start a program or use --noproc"
-    end
-    raise OptionParser::InvalidArgument, "--noproc cannot start a program" if options[:noproc] && !argv.empty?
-
-    output.sync = true
-    # The ensure below closes the log after both terminal connections end.
-    log = File.open(options[:log], File::WRONLY | File::CREAT | File::EXCL, 0o600) if options[:log] # rubocop:disable Style/FileOpen
-
-    if options[:join]
-      peer = UNIXSocket.new(options[:join])
-    else
-      # A short, private socket path works with macOS's sockaddr_un limit.
-      directory = Dir.mktmpdir("expect-kibitz-", "/tmp")
-      socket_path = File.join(directory, "peer.sock")
-      server = UNIXServer.new(socket_path)
-      File.chmod(0o600, socket_path)
-      output.puts("Join from another terminal on this machine:")
-      output.puts(Shellwords.join([RbConfig.ruby, File.expand_path(__FILE__), "--join", socket_path]))
-      raise IOError, "timed out waiting for partner" unless server.wait_readable(options[:timeout])
-
-      peer = server.accept
-      server.close
-      File.unlink(socket_path)
-      unless options[:noproc]
-        command = argv.empty? ? [ENV.fetch("SHELL", "/bin/sh")] : argv
-        shell = Expect.spawn(*command, log_stdout: false, raw_terminal: false, write_timeout: 5)
-        shell.winsize = input.winsize
-      end
-    end
-    # Announce readiness only after local echo/canonical input are disabled.
-    # A fast typist (or PTY driver) may send bytes immediately after the banner.
-    result = input.raw do
-      hint = options[:escape] ? "Escape #{options[:escape].inspect} ends this session." : "Escape disabled."
-      output.write("Kibitz connected. #{hint}\r\n")
-      relay(input: input, output: output, peer: peer, shell: shell,
-            escape: options[:escape], timeout: options[:timeout], log: log)
-    end
-    if result[:reason] == :process
-      shell.soft_close(timeout: 2)
-      status = shell.exit_code || 1
-    else
-      status = result[:reason] == :timeout ? 1 : 0
-    end
-    output.puts("\nKibitz ended (#{result[:reason]}).")
-    status
-  rescue OptionParser::ParseError, IOError, SystemCallError, Expect::SpawnError => error
-    warn "kibitz: #{error.message}"
-    1
-  ensure
-    shell&.close
-    peer&.close
-    server&.close unless server&.closed?
-    log&.close
-    File.unlink(socket_path) if socket_path && File.socket?(socket_path)
-    Dir.rmdir(directory) if directory && Dir.exist?(directory)
-  end
-
-  # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-end
-
-exit Kibitz.run(ARGV) if $PROGRAM_NAME == __FILE__

data/examples/kibitz/test_kibitz.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require "fileutils"
-require "tmpdir"
-require "time"
-require_relative "../../test/support/kibitz_probe"
-
-base = File.expand_path(ENV.fetch("EXPECT_LOG_DIR", "../../tmp/kibitz"), __dir__)
-FileUtils.mkdir_p(base)
-directory = Dir.mktmpdir("#{Time.now.utc.strftime("%Y%m%dT%H%M%SZ")}-", base)
-report = { passed: false, cases: [], started_at: Time.now.utc.iso8601 }
-begin
-  {
-    shared_shell: ->(dir) { KibitzProbe.shared_shell(dir) },
-    host_escape: ->(dir) { KibitzProbe.direct(dir, ending: :host) },
-    guest_escape: ->(dir) { KibitzProbe.direct(dir, ending: :guest) },
-    noescape: ->(dir) { KibitzProbe.noescape(dir) },
-    process_failure: ->(dir) { KibitzProbe.process_failure(dir) },
-    relay_timeout: ->(dir) { KibitzProbe.relay_timeout(dir) }
-  }.each do |name, probe|
-    path = File.join(directory, name.to_s)
-    Dir.mkdir(path, 0o700)
-    result = probe.call(path)
-    report[:cases] << result.merge(log_path: File.join(path, "session.log"))
-    puts "PASS #{name}: #{result[:checks].join(", ")}"
-  end
-  report[:passed] = true
-rescue StandardError => error
-  report[:error] = "#{error.class}: #{error.message}"
-ensure
-  report[:finished_at] = Time.now.utc.iso8601
-  path = File.join(directory, "report.json")
-  File.open(path, File::WRONLY | File::CREAT | File::EXCL, 0o600) { |file| file.write(JSON.pretty_generate(report)) }
-  puts "Report: #{path}"
-end
-abort(report[:error]) unless report[:passed]

data/examples/ssh_auto.rb

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-require "fileutils"
-require "securerandom"
-require "tempfile"
-require "tmpdir"
-require_relative "../lib/expect/pty"
-
-# 在这里按顺序填写要执行的 macOS / POSIX shell 命令。
-COMMANDS = ["id", "uname -srm", "sw_vers", "df -h /", "uptime"].freeze
-PROMPT = "MACOS> "
-
-if ARGV.delete("--help")
-  puts "用法：ruby examples/ssh_auto.rb [--no-interact]"
-  puts "自动 SSH 登录，执行 COMMANDS 后进入 interact；--no-interact 执行后退出。"
-  puts "环境变量：SSH_HOST、SSH_USER、SSH_PORT、SSH_KNOWN_HOSTS、EXPECT_PASSWORD、EXPECT_LOG_DIR。"
-  exit
-end
-interactive = !ARGV.delete("--no-interact")
-abort "未知参数：#{ARGV.join(" ")}" unless ARGV.empty?
-abort "interact 需要终端；批量执行请加 --no-interact" if interactive && !$stdin.tty?
-
-host = ENV.fetch("SSH_HOST", "127.0.0.1")
-user = ENV.fetch("SSH_USER", ENV.fetch("USER", "crate"))
-port = Integer(ENV.fetch("SSH_PORT", "22"), 10)
-abort "SSH_PORT 应为 1..65535" unless (1..65_535).cover?(port)
-abort "SSH_HOST / SSH_USER 格式无效" if [host, user].any? do |value|
-  value.empty? || value.start_with?("-") || value.match?(/[\s\x00]/)
-end
-known_hosts = ENV.fetch("SSH_KNOWN_HOSTS", nil)
-abort "连接其他主机时请设置 SSH_KNOWN_HOSTS" unless known_hosts || %w[127.0.0.1 ::1 localhost].include?(host)
-
-password = ENV.delete("EXPECT_PASSWORD")&.dup
-log = nil
-begin
-  unless password
-    $stderr.print("SSH password: ")
-    password = ($stdin.tty? ? $stdin.noecho(&:gets) : $stdin.gets)&.chomp
-    $stderr.puts
-  end
-  abort "请输入单行密码" if password.nil? || password.empty? || password.match?(/[\r\n\x00]/)
-
-  Dir.mktmpdir("expect-ssh-") do |dir|
-    ssh_args = ["ssh", "-F", "/dev/null", "-tt", "-p", port.to_s,
-                "-o", "ConnectTimeout=5", "-o", "NumberOfPasswordPrompts=1",
-                "-o", "PreferredAuthentications=password", "-o", "PubkeyAuthentication=no",
-                "-o", "StrictHostKeyChecking=#{known_hosts ? "yes" : "accept-new"}",
-                "-o", "UserKnownHostsFile=#{known_hosts || File.join(dir, "known_hosts")}",
-                "-l", user, host, "env ENV= PS1=#{Shellwords.escape(PROMPT)} /bin/sh -i"]
-
-    Expect.spawn(*ssh_args, raw_pty: true, log_stdout: false, write_timeout: 5) do |ssh|
-      # 登录成功后才开启日志，密码不写入文件。
-      ssh.expect(/password:\s*\z/i, timeout: 10) or abort "未收到密码提示：#{ssh.error}"
-      ssh.write(password, "\n")
-      ssh.expect(PROMPT, timeout: 10) or abort "SSH 登录失败：#{ssh.error}"
-      password.replace("\0" * password.bytesize)
-      ssh.write("stty sane -echo; set +o emacs; set +o vi\n")
-      ssh.expect(PROMPT, timeout: 5) or abort "终端初始化失败：#{ssh.error}"
-
-      log_dir = ENV.fetch("EXPECT_LOG_DIR", File.expand_path("../tmp/ssh-auto", __dir__))
-      FileUtils.mkdir_p(log_dir)
-      log = Tempfile.create(["session-", ".log"], log_dir) # 0600，退出后保留
-      ssh.log_to(log)
-      puts "已登录 #{user}@#{host}；日志：#{log.path}"
-
-      COMMANDS.each do |command|
-        puts "\n$ #{command}"
-        ssh.write_log("\n$ #{command}\n")
-        token = SecureRandom.hex(8)
-        # 远端拼接结束标记并带回退出码，避免把命令回显当成执行结果。
-        ssh.write("#{command}; printf '\\n__DONE_%s:%s\\n' '#{token}' \"$?\"\n")
-        ssh.expect(/\r?\n__DONE_#{token}:(\d+)\r?\n#{Regexp.escape(PROMPT)}/, timeout: 30) or abort "命令未完成：#{ssh.error}"
-        print ssh.before.gsub("\r\n", "\n")
-        abort "命令失败（退出码 #{ssh.captures.first}）：#{command}" unless ssh.captures.first == "0"
-      end
-
-      if interactive
-        ssh.write("stty echo\n")
-        ssh.expect(PROMPT, timeout: 5) or abort "无法进入交互：#{ssh.error}"
-        puts "\n检查完成，进入 interact。输入 exit 或按 Ctrl-] 结束。"
-        $stdout.print(PROMPT)
-        $stdout.flush
-        next unless ssh.interact(input: $stdin, escape: "\x1d", output: $stdout).equal?(ssh)
-      else
-        ssh.write("exit\n")
-      end
-      ssh.soft_close(timeout: 3)
-      abort "SSH 退出异常：#{ssh.exit_code.inspect}" unless ssh.exit_code&.zero?
-    end
-  end
-ensure
-  log&.close
-  password&.replace("\0" * password.bytesize)
-end

data/examples/ssh_interact.rb

@@ -1,159 +0,0 @@
-# frozen_string_literal: true
-
-# Run from the checkout or the unpacked gem. Test helpers use only standard
-# libraries; Minitest is not needed for this live SSH example.
-require "io/console"
-require "json"
-require "fileutils"
-require "tmpdir"
-require "time"
-require_relative "../test/support/interact_probe"
-
-if ARGV.delete("--help")
-  puts <<~HELP
-    Usage: ruby examples/ssh_interact.rb [--auto]
-
-    Default: SSH login with visible typing; Ctrl-] returns to expect, exit ends SSH.
-    --auto:  Drive a real local PTY to verify commands, Ctrl-C, Ctrl-] and reentry.
-
-    Environment: SSH_HOST (127.0.0.1), SSH_USER (current user), SSH_PORT (22),
-                 SSH_KNOWN_HOSTS, EXPECT_PASSWORD, EXPECT_LOG_DIR.
-    Password input is hidden. Non-loopback hosts require SSH_KNOWN_HOSTS.
-    Logs and JSON reports default to tmp/ssh-interact/ in this project.
-  HELP
-  exit
-end
-automatic = !ARGV.delete("--auto").nil?
-abort "unknown arguments: #{ARGV.join(" ")} (use --help)" unless ARGV.empty?
-abort "manual interact requires a terminal; use --auto for unattended testing" unless automatic || $stdin.tty?
-
-host = ENV.fetch("SSH_HOST", "127.0.0.1")
-user = ENV.fetch("SSH_USER", ENV.fetch("USER", "crate"))
-port = Integer(ENV.fetch("SSH_PORT", "22"), 10)
-ScriptProbe.check((1..65_535).cover?(port), "SSH_PORT must be between 1 and 65535")
-ScriptProbe.check([host, user].none? do |value|
-  value.empty? || value.start_with?("-") || value.match?(/[\s\x00]/)
-end, "invalid SSH host or user")
-known_hosts = ENV.fetch("SSH_KNOWN_HOSTS", nil)
-ScriptProbe.check(known_hosts || %w[127.0.0.1 ::1 localhost].include?(host),
-                  "SSH_KNOWN_HOSTS is required for remote hosts")
-
-password = ENV.delete("EXPECT_PASSWORD")&.dup
-unless password
-  $stderr.print("SSH password: ")
-  password = ($stdin.tty? ? $stdin.noecho(&:gets) : $stdin.gets)&.chomp
-  $stderr.puts
-end
-ScriptProbe.check(password && !password.empty? && !password.match?(/[\r\n\x00]/), "a single-line password is required")
-base = File.expand_path(ENV.fetch("EXPECT_LOG_DIR", File.expand_path("../tmp/ssh-interact", __dir__)))
-FileUtils.mkdir_p(base)
-directory = Dir.mktmpdir("#{Time.now.utc.strftime("%Y%m%dT%H%M%SZ")}-", base)
-log_path = File.join(directory, "session.log")
-report_path = File.join(directory, "report.json")
-report = { mode: automatic ? "automatic" : "manual", host: host, port: port, user: user,
-           started_at: Time.now.utc.iso8601, passed: false, cases: [], checks: [] }
-session = nil
-local_terminal = nil
-
-begin
-  Dir.mktmpdir("expect-known-hosts-") do |temporary|
-    policy = known_hosts ? "yes" : "accept-new"
-    hosts_path = known_hosts || File.join(temporary, "known_hosts")
-    args = ["ssh", "-F", "/dev/null", "-tt", "-p", port.to_s,
-            "-o", "ConnectTimeout=5", "-o", "NumberOfPasswordPrompts=1",
-            "-o", "PreferredAuthentications=password", "-o", "PubkeyAuthentication=no",
-            "-o", "StrictHostKeyChecking=#{policy}", "-o", "UserKnownHostsFile=#{hosts_path}",
-            "-l", user, host, "env ENV= PS1=#{Shellwords.escape(ScriptProbe::PROMPT)} /bin/sh -i"]
-    session = Expect.spawn(*args, raw_pty: true, log_stdout: false, log_listeners: false,
-                                  debug_level: 0, write_timeout: 5)
-    login = session.expect(/password:\s*\z/i, /Permission denied/i, timeout: 10)
-    ScriptProbe.check(login == 1, "SSH password prompt missing (#{session.error || "authentication rejected"})")
-    session.write(password, "\n")
-    runner = ScriptProbe::Runner.new(session, timeout: 10).ready!
-    InteractProbe.prepare(session, echo: !automatic)
-    File.open(log_path, File::WRONLY | File::CREAT | File::EXCL, 0o600) { |file| file.truncate(0) }
-    session.log_to(log_path)
-
-    remote_exit = false
-    if automatic
-      report.merge!(InteractProbe.verify(session, user: user))
-    else
-      local_terminal = Expect.open($stdin)
-      initial_mode = InteractProbe.configuration(local_terminal)
-      puts "Logged in as #{user}@#{host}. Enter commands; press Ctrl-] to return to expect."
-      puts "Log: #{log_path}"
-      # prepare consumed the initial prompt while configuring remote echo.
-      $stdout.print(ScriptProbe::PROMPT)
-      $stdout.flush
-      # This is the actual public API handoff: stdin -> SSH, SSH -> stdout.
-      returned = session.interact(input: $stdin, escape: InteractProbe::ESCAPE, output: $stdout)
-      ScriptProbe.check(InteractProbe.configuration(local_terminal) == initial_mode,
-                        "stdin terminal mode was not restored")
-      report[:local_terminal_restored] = true
-      report[:checks] += %w[real_stdin_stdout terminal_restored]
-      if returned.equal?(session)
-        remote_exit = true
-        report[:completion] = "remote_exit"
-        session.soft_close(timeout: 3)
-        ScriptProbe.check(session.closed? && session.exit_code&.zero?,
-                          "SSH exited with status #{session.exit_code.inspect}")
-        report[:checks] << "remote_eof"
-      else
-        ScriptProbe.check(returned.is_a?(Expect) && returned.to_io.equal?($stdin), "unexpected interact termination")
-        ScriptProbe.check(session.alive?, "remote session ended during interaction")
-        report[:completion] = "local_escape"
-        report[:checks] += %w[ctrl_bracket_escape remote_alive]
-        puts "\nReturned from interact; verifying automated expect resumes..."
-        InteractProbe.prepare(session)
-        runner.run(
-          "expect_after_manual", "printf 'MANUAL_AUTOMATION_RESUMED\\n'",
-          expected_status: 0, expected_output: "MANUAL_AUTOMATION_RESUMED\n"
-        )
-        report[:cases] = runner.results
-        report[:checks] << "expect_resume"
-      end
-    end
-
-    runner.finish! unless remote_exit
-    report[:ssh_exit_code] = session.exit_code
-    text = ScriptProbe.normalize(File.binread(log_path))
-    report[:cases].each do |result|
-      output = result.fetch(:output).b
-      ScriptProbe.check(text.scan(Regexp.new(Regexp.escape(output), Regexp::NOENCODING)).length == 1,
-                        "#{result[:name]}: log output missing or duplicated")
-    end
-    unless remote_exit
-      ScriptProbe.check(text.scan("SESSION_FINAL_TAIL\n").length == 1,
-                        "shutdown tail missing or duplicated")
-    end
-    ScriptProbe.check(!text.include?(InteractProbe::TAIL), "local escape tail leaked to SSH") if automatic
-    ScriptProbe.check(!text.include?(password.b), "password detected in log")
-    report[:checks] += %w[unique_log_output eof_drain password_absent clean_ssh_exit]
-    report[:passed] = true
-  end
-rescue StandardError => error
-  report[:error] = "#{error.class}: #{error.message}".gsub(password, "[REDACTED]")
-ensure
-  session&.close
-  local_terminal&.close
-  if File.file?(log_path)
-    bytes = File.binread(log_path)
-    if bytes.include?(password.b)
-      File.binwrite(log_path, bytes.gsub(password.b, "[REDACTED]"))
-      report[:passed] = false
-      report[:error] = "password detected and removed from log"
-    end
-    report[:log_bytes] = File.size(log_path)
-    report[:log_sha256] = Digest::SHA256.file(log_path).hexdigest
-  end
-  password.replace("\0" * password.bytesize)
-  report[:finished_at] = Time.now.utc.iso8601
-  report[:log_path] = log_path
-  File.open(report_path, File::WRONLY | File::CREAT | File::EXCL, 0o600) { |file| file.write(JSON.pretty_generate(report)) }
-end
-
-puts "Log: #{log_path}"
-puts "Report: #{report_path}"
-abort(report[:error]) unless report[:passed]
-puts "PASS #{report[:mode]} interact: #{report[:cases].length} command checks, " \
-     "#{report[:checks].length} interaction/log checks; SSH exit=0"

data/examples/ssh_login.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-# Optional real SSH integration check. Password input is hidden and never logged.
-require "io/console"
-require "tmpdir"
-require "securerandom"
-require_relative "../lib/expect/pty"
-
-host = ENV.fetch("SSH_HOST", "127.0.0.1")
-user = ENV.fetch("SSH_USER", ENV.fetch("USER", "crate"))
-abort "invalid SSH host or user" if [host, user].any? do |value|
-  value.empty? || value.start_with?("-") || value.match?(/[\s\x00]/)
-end
-password = ENV.delete("EXPECT_PASSWORD")&.dup
-unless password
-  $stderr.print("SSH password: ")
-  password = $stdin.tty? ? $stdin.noecho(&:gets) : $stdin.gets
-  $stderr.puts
-  password = password&.chomp
-end
-abort "password is required" if password.nil? || password.empty?
-
-begin
-  Dir.mktmpdir("expect-ssh-") do |dir|
-    # Isolated known_hosts keeps this example independent of user SSH settings.
-    # For non-loopback hosts, use an existing trusted known_hosts file.
-    known_hosts = ENV.fetch("SSH_KNOWN_HOSTS", nil)
-    abort "SSH_KNOWN_HOSTS is required for remote hosts" unless known_hosts || %w[127.0.0.1 ::1
-                                                                                  localhost].include?(host)
-    policy = known_hosts ? "yes" : "accept-new"
-    known_hosts ||= File.join(dir, "known_hosts")
-    arguments = ["ssh", "-F", "/dev/null", "-tt", "-o", "ConnectTimeout=5",
-                 "-o", "PreferredAuthentications=password", "-o", "PubkeyAuthentication=no",
-                 "-o", "NumberOfPasswordPrompts=1", "-o", "StrictHostKeyChecking=#{policy}",
-                 "-o", "UserKnownHostsFile=#{known_hosts}", "-l", user, host,
-                 "env PS1='EXPECT_SHELL> ' /bin/sh -i"]
-    Expect.spawn(*arguments, log_stdout: false, raw_pty: true) do |session|
-      prompt = session.expect(/password:\s*\z/i, /Permission denied/i, timeout: 10)
-      abort "SSH password prompt not received (#{session.error || "authentication rejected"})" unless prompt == 1
-      session.write(password, "\n")
-      password.replace("\0" * password.bytesize)
-
-      # Start a command after authentication. The marker is assembled remotely
-      # from two quoted arguments, so terminal command echo cannot satisfy it.
-      login = session.expect("EXPECT_SHELL> ", /Permission denied/i, timeout: 10)
-      abort "SSH login failed (#{session.error || "authentication rejected"})" unless login == 1
-      token = SecureRandom.hex(12)
-      session.write("printf '\\n%s%s\\n' 'EXPECT_OK_' '#{token}'; id -un; tty\n")
-      marker = session.expect(/EXPECT_OK_#{Regexp.escape(token)}\r?\n/, timeout: 10)
-      abort "remote command did not run (#{session.error})" unless marker
-      identity = session.expect(%r{([^\r\n]+)\r?\n(/dev/[^\r\n]+)\r?\n}, timeout: 5)
-      abort "remote identity/TTY response missing" unless identity
-      abort "unexpected SSH user" unless session.captures.first == user.b
-      puts "SSH password login verified: #{user}@#{host}"
-      puts "Remote identity: #{session.captures.first}; TTY: #{session.captures.last}"
-      session.write("exit\n")
-      session.soft_close(timeout: 5)
-      abort "SSH exit status #{session.exit_code.inspect}" unless session.exit_code&.zero?
-      puts "SSH exited cleanly (0)"
-    end
-  end
-ensure
-  password&.replace("\0" * password.bytesize)
-end

data/expect-pty.gemspec

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "lib/expect/version"
-
-Gem::Specification.new do |spec|
-  spec.name = "expect-pty"
-  spec.version = Expect::VERSION
-  spec.authors = ["expect-pty contributors"]
-  spec.homepage = "https://github.com/gatework/expect-ruby"
-  spec.summary = "Ruby PTY automation with the Expect.pm interaction model"
-  spec.description = "Automate interactive programs with exact and regexp matching, " \
-                     "Ruby blocks, multi-session waits, logging and terminal interaction."
-  spec.license = "MIT"
-  spec.required_ruby_version = ">= 3.2"
-  spec.files = Dir[
-    "lib/**/*.rb", "examples/**/*.rb", "examples/**/*.md", "docs/**/*.md", "benchmark/**/*.rb",
-    "test/**/*.rb", "test/**/*.sh", "test/**/*.md", "Gemfile", "Rakefile",
-    ".rubocop.yml", "expect-pty.gemspec", "README.md", "CONTRIBUTING.md", "LICENSE", "CHANGELOG.md",
-    "script/ci", "script/release.rb"
-  ]
-  spec.require_paths = ["lib"]
-  # 显式声明可独立升级的标准库 gem，供应用的 Bundler 解析完整运行时依赖。
-  # pty 是 Ruby 自带的 POSIX 扩展，不是独立 gem。
-  spec.add_dependency "forwardable", "~> 1.3"
-  spec.add_dependency "io-console", ">= 0.6", "< 1.0"
-  spec.add_dependency "io-wait", ">= 0.3", "< 1.0"
-  spec.add_dependency "shellwords", ">= 0.1", "< 1.0"
-  spec.add_dependency "stringio", "~> 3.0"
-  spec.metadata["rubygems_mfa_required"] = "true"
-  spec.metadata["source_code_uri"] = spec.homepage
-  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
-  spec.metadata["bug_tracker_uri"] = "#{spec.homepage}/issues"
-end

data/lib/expect/configuration.rb

@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-
-class Expect
-  # 集中校验会话配置。类级默认值以冻结快照发布，每个会话再构造独立副本。
-  # 这里只保存策略值，不持有 IO、缓冲或日志对象；修改默认配置不会追溯影响已创建的会话。
-  class Configuration
-    # 会话通过 Forwardable 委托这些属性；to_h 使用同一清单生成配置副本。
-    ATTRIBUTES = %i[
-      timeout write_timeout buffer_limit debug_level raw_pty preserve_buffer
-      log_stdout log_listeners raw_terminal reset_timeout_on_read graceful_close
-    ].freeze
-    # 布尔属性同时提供普通读方法和问号查询，写入统一采用 Ruby 真值规则。
-    PREDICATES = %i[
-      raw_pty? preserve_buffer? log_stdout? log_listeners? raw_terminal?
-      reset_timeout_on_read? graceful_close?
-    ].freeze
-
-    attr_reader :timeout, :write_timeout, :buffer_limit, :debug_level, :raw_pty, :preserve_buffer, :log_stdout,
-                :log_listeners, :raw_terminal, :reset_timeout_on_read, :graceful_close
-
-    # 通过 setter 校验构造参数，确保默认值、构造覆盖和后续赋值遵守同一规则。
-    def initialize(timeout: nil, write_timeout: nil, buffer_limit: nil, debug_level: 0,
-                   raw_pty: false, preserve_buffer: false, log_stdout: false,
-                   log_listeners: true, raw_terminal: true, reset_timeout_on_read: false,
-                   graceful_close: false)
-      self.timeout = timeout
-      self.write_timeout = write_timeout
-      self.buffer_limit = buffer_limit
-      self.debug_level = debug_level
-      self.raw_pty = raw_pty
-      self.preserve_buffer = preserve_buffer
-      self.log_stdout = log_stdout
-      self.log_listeners = log_listeners
-      self.raw_terminal = raw_terminal
-      self.reset_timeout_on_read = reset_timeout_on_read
-      self.graceful_close = graceful_close
-    end
-
-    # 设置匹配等待的默认秒数；nil 表示无限等待，0 表示只轮询现有数据。
-    def timeout=(value)
-      @timeout = Expect.duration(value)
-    end
-
-    # 设置写入背压的等待期限；先转换和校验，失败时保留原配置。
-    def write_timeout=(value)
-      @write_timeout = Expect.duration(value)
-    end
-
-    # 限制接收缓冲保留的尾部字节数；正整数为上限，nil 为无限。
-    def buffer_limit=(value)
-      unless value.nil? || (value.is_a?(Integer) && value.positive?)
-        raise ArgumentError, "buffer_limit must be a positive Integer or nil"
-      end
-
-      @buffer_limit = value
-    end
-
-    # 设置诊断详细程度：0 关闭，1 生命周期与匹配，2 收发内容，3 缓冲内容。
-    def debug_level=(value)
-      unless value.is_a?(Integer) && (0..3).cover?(value)
-        raise ArgumentError, "debug_level must be an Integer between 0 and 3"
-      end
-
-      @debug_level = value
-    end
-
-    # 控制 spawn 前是否将子进程终端设为 raw，关闭回显和换行转换。
-    def raw_pty=(value)
-      @raw_pty = !!value
-    end
-
-    alias raw_pty? raw_pty
-
-    # 控制匹配成功后是否保留完整缓冲；启用时由继续回调自行消费匹配内容。
-    def preserve_buffer=(value)
-      @preserve_buffer = !!value
-    end
-
-    alias preserve_buffer? preserve_buffer
-
-    # 控制接收字节是否同步输出到当前 $stdout；默认关闭。
-    def log_stdout=(value)
-      @log_stdout = !!value
-    end
-
-    alias log_stdout? log_stdout
-
-    # 控制接收字节是否转发给监听器，与 stdout 和日志目标分别管理。
-    def log_listeners=(value)
-      @log_listeners = !!value
-    end
-
-    alias log_listeners? log_listeners
-
-    # 控制 interact 是否临时设置并恢复本地输入终端；通用 interconnect 不修改终端模式。
-    def raw_terminal=(value)
-      @raw_terminal = !!value
-    end
-
-    alias raw_terminal? raw_terminal
-
-    # 控制收到任何新数据时是否刷新匹配期限，适用于按静默时长判断超时。
-    # 只刷新相对 timeout；单次等待显式指定的绝对 deadline 仍是不可延长的上限。
-    def reset_timeout_on_read=(value)
-      @reset_timeout_on_read = !!value
-    end
-
-    alias reset_timeout_on_read? reset_timeout_on_read
-
-    # 控制通用 close 是否先软关闭；最终资源清理仍由硬关闭兜底。
-    def graceful_close=(value)
-      @graceful_close = !!value
-    end
-
-    alias graceful_close? graceful_close
-
-    # 导出新的属性 Hash，用于构造会话副本或发布下一份默认配置。
-    def to_h
-      ATTRIBUTES.to_h { |name| [name, public_send(name)] }
-    end
-  end
-end