expect-pty 0.5.3 → 0.6.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/script/ci

@@ -1,121 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-cd "$(dirname "${BASH_SOURCE[0]}")/.."
-
-bundle exec rake
-bundle exec ruby examples/dialogue.rb
-
-# 只检查小规模工作负载的正确性，不为共享 CI 机器设置性能阈值。
-for benchmark in matching relay send_slow scaling redactor; do
-  bundle exec ruby "benchmark/${benchmark}.rb" --smoke
-done
-
-mkdir -p tmp/ci
-gem_version="$(ruby -Ilib -rexpect/version -e 'print Expect::VERSION')"
-gem_file="tmp/ci/expect-pty-${gem_version}.gem"
-if git rev-parse --git-dir >/dev/null 2>&1; then
-  export SOURCE_DATE_EPOCH="$(git log -1 --format=%ct)"
-fi
-gem build expect-pty.gemspec --output "$gem_file"
-
-# 在独立目录安装刚构建的包，避免源码路径或 Bundler 掩盖打包遗漏。
-smoke_dir="$(mktemp -d)"
-trap 'rm -rf "$smoke_dir"' EXIT
-gem_file="$(pwd)/$gem_file"
-bundler_version="$(bundle exec ruby -rbundler -e 'print Bundler::VERSION')"
-bundler_gem="$(bundle exec ruby -e 'print Gem.loaded_specs.fetch("bundler").cache_file')"
-
-(
-  cd "$smoke_dir"
-  # 清除 Bundler 的自动加载与路径设置；Ruby 4 还会通过 BUNDLER_SETUP 自动启用 Bundler。
-  for bundle_variable in ${!BUNDLE_@} ${!BUNDLER_@}; do
-    unset "$bundle_variable"
-  done
-  unset RUBYOPT RUBYLIB RUBYGEMS_GEMDEPS
-  export GEM_HOME="$smoke_dir/gems" GEM_PATH="$smoke_dir/gems"
-  gem install --local --no-document "$gem_file"
-
-  cat > smoke.rb <<'RUBY'
-require "expect/pty"
-require "rbconfig"
-
-spec = Gem.loaded_specs.fetch("expect-pty")
-# 临时目录可能经由符号链接访问，先统一为实际路径再检查。
-install_root = File.realpath(ENV.fetch("GEM_HOME"))
-abort "gem was loaded outside the isolated install" unless File.realpath(spec.full_gem_path).start_with?("#{install_root}/")
-abort "Bundler leaked into the plain gem smoke" if ARGV.first == "plain" && defined?(Bundler)
-unexpected = %w[minitest rake rubocop parallel logger].select { |name| Gem.loaded_specs.key?(name) }
-abort "development dependencies leaked into the application: #{unexpected.join(', ')}" unless unexpected.empty?
-spec.runtime_dependencies.each do |dependency|
-  loaded = Gem.loaded_specs.fetch(dependency.name)
-  abort "incompatible dependency: #{dependency}" unless dependency.matches_spec?(loaded)
-end
-
-# 检查实际使用的标准库已在包元数据中声明，默认 gem 可加载不能代替依赖声明。
-%w[forwardable io-console io-wait shellwords stringio].each do |name|
-  abort "undeclared runtime dependency: #{name}" unless spec.runtime_dependencies.any? { |dependency| dependency.name == name }
-end
-child = 'STDOUT.sync = true; puts "ready"; puts "reply:#{$stdin.gets&.strip}"'
-Expect.spawn(RbConfig.ruby, "--disable-gems", "-e", child, raw_pty: true, log_stdout: false) do |session|
-  session.winsize = [30, 100]
-  abort "io-console terminal size failed" unless session.winsize == [30, 100]
-  # BSD stty 设置模式会清空待读输出，先收取提示，使子进程停在等待输入的位置。
-  abort "installed gem did not receive the PTY prompt" unless session.expect("ready", timeout: 5)
-  mode = session.stty
-  abort "installed stty query failed" if mode.empty?
-  session.stty(mode)
-
-  session.puts("expect-ruby")
-  abort "installed gem PTY dialogue failed" unless session.expect("reply:expect-ruby", timeout: 5)
-  status = session.soft_close(timeout: 5)
-  abort "installed gem child did not exit successfully" unless status&.success?
-end
-
-# 使用已安装包验证公共过滤器随包分发，且结构化诊断无需加载可选的 Logger。
-filter = Expect::Redactor.new(["secret"], replacement: "[REDACTED]")
-filtered = filter.append("sec") + filter.append("ret!") + filter.finish
-abort "installed public redactor failed" unless filtered == "[REDACTED]!"
-abort "installed complete-text redactor failed" unless Expect::Redactor.redact("sec", ["secret"]) == "sec"
-reader, producer = IO.pipe
-events = []
-transcript = StringIO.new
-begin
-  Expect.open(reader, own: true, buffer_limit: 5, debug_level: 2,
-              diagnostic_output: ->(event) { events << event }) do |session|
-    session.redact("secret")
-    session.log_to(transcript)
-    session.buffer = "ready"
-    expired = session.expect_result("ready", deadline: Expect.monotonic)
-    abort "expired deadline consumed buffered text" unless expired.timeout? && session.buffer == "ready"
-    abort "zero timeout lost buffered text" unless session.expect("ready", timeout: 0) == 1
-    producer.write("secret!")
-    producer.close
-    result = session.expect_result(:eof, deadline: Expect.monotonic + 5)
-    abort "installed gem did not preserve capped input" unless result.eof? && result.before == "cret!"
-    abort "incorrect installed buffer accounting" unless session.buffer_discarded_bytes == 2
-    abort "installed redaction failed" unless transcript.string == "[FILTERED]!"
-    abort "diagnostics leaked secret" if events.any? { |event| event[:message].include?("secret") }
-    abort "filtered diagnostic missing" unless events.any? { |event| event[:message].include?("[FILTERED]") }
-  end
-ensure
-  reader.close unless reader.closed?
-  producer.close unless producer.closed?
-end
-
-puts "Installed #{spec.full_name}: #{ARGV.fetch(0)} PTY, core contracts and runtime dependencies passed"
-RUBY
-  ruby smoke.rb plain
-
-  # 消费方仅声明当前 Gem，不能借用项目 Gemfile 中的测试和发布依赖。
-  # 单独安装本次开发检查使用的 Bundler，避免依赖宿主 Ruby 的默认 Bundler 副本。
-  if [ -f "$bundler_gem" ]; then
-    gem install --local --no-document "$bundler_gem"
-  else
-    gem install --no-document bundler --version "$bundler_version"
-  fi
-  export BUNDLE_IGNORE_CONFIG=true
-  printf 'source "https://rubygems.org"\ngem "expect-pty", "= %s", require: "expect/pty"\n' "$gem_version" > Gemfile
-  bundle lock --local
-  bundle exec ruby -rbundler -e 'Bundler.require; load "smoke.rb"' bundler
-)