expect-pty 0.2.0

data/test/fixtures/ssh_scripts/01_identity.sh

@@ -0,0 +1,4 @@
+set -eu
+printf 'USER=%s\n' "$(id -un)"
+printf 'TTY=%s\n' "$(tty)"
+printf 'IDENTITY_OK\n'

data/test/fixtures/ssh_scripts/02_output.sh

@@ -0,0 +1,5 @@
+set -eu
+printf 'STDOUT_FIRST\n'
+printf 'STDERR_SECOND\n' >&2
+printf '中文输出：日志验证\n'
+printf 'STDOUT_LAST\n'

data/test/fixtures/ssh_scripts/03_delayed.sh

@@ -0,0 +1,6 @@
+set -eu
+printf 'DELAY_BEGIN\n'
+sleep 0.1
+printf 'DELAY_MIDDLE\n'
+sleep 0.1
+printf 'DELAY_END\n'

data/test/fixtures/ssh_scripts/04_failure.sh

@@ -0,0 +1,2 @@
+printf 'EXPECTED_FAILURE\n' >&2
+exit 7

data/test/fixtures/ssh_scripts/05_recovery.sh

@@ -0,0 +1,3 @@
+set -eu
+printf 'RECOVERY_OK\n'
+printf 'VALUE=%s\n' "$((20 + 22))"

data/test/integration/README.md

@@ -0,0 +1,90 @@
+# SSH 多脚本和日志验证
+
+在仓库根目录运行，要求 Ruby 3.2+、SSH 服务，以及能运行 POSIX `/bin/sh` 的目标账户：
+
+```sh
+SSH_HOST=127.0.0.1 SSH_USER=crate ruby test/integration/ssh_scripts.rb
+# 也可以通过 Rake：
+SSH_HOST=127.0.0.1 SSH_USER=crate bundle exec rake test:ssh
+```
+
+脚本隐藏读取密码；也支持由运行环境提供 `EXPECT_PASSWORD`。密码不会作为 SSH 命令行参数传递，日志在认证完成后才开启。默认自动测试不连接 SSH、不读取密码。
+
+支持 `SSH_PORT`（默认 22）、`EXPECT_LOG_DIR`（日志根目录）、`SSH_KNOWN_HOSTS`。连接非本机主机时，必须提供已有的受信任 known_hosts，例如：
+
+```sh
+SSH_HOST=192.0.2.10 SSH_USER=operator SSH_PORT=22 \
+  SSH_KNOWN_HOSTS="$HOME/.ssh/known_hosts" \
+  EXPECT_LOG_DIR=tmp/device-check ruby test/integration/ssh_scripts.rb
+```
+
+这是 POSIX shell 脚本测试；厂商专用 CLI（如交换机的 `show` 命令、分页提示符）需要对应设备的命令和预期输出，不能直接使用这些 shell fixtures。
+
+## 同一个登录会话执行的脚本
+
+| 脚本 | 验证内容 | 预期退出码 |
+| --- | --- | --- |
+| `01_identity.sh` | 当前用户、远端 PTY、完成标记 | 0 |
+| `02_output.sh` | stdout、stderr、中文和输出顺序 | 0 |
+| `03_delayed.sh` | 分三次延迟输出，确保日志完整 | 0 |
+| `04_failure.sh` | 明确输出错误并退出 | 7（预期失败） |
+| `05_recovery.sh` | 上个脚本失败后继续执行，计算结果为 42 | 0 |
+
+fixtures 位于 `test/fixtures/ssh_scripts/`，都不修改目标文件或设备配置。文件内容通过 SSH 的交互 shell 传给独立 `/bin/sh -c` 执行，不需要上传文件。每个脚本都有随机开始/结束标记，结束标记携带真实 `$?`；脚本输出和退出码都必须符合预期才算通过。
+
+测试关闭终端回显和 shell 行编辑，使用单引号传输完整脚本，保留中文 UTF-8 和引号，避免 C locale 的交互式 readline 把高位字节当快捷键执行。末尾仍等待 shell 提示符，确认可以继续执行下一项。
+
+另外执行两条日志控制命令：关闭日志后输出 `UNLOGGED_OUTPUT`，再以默认追加模式开启日志并输出 `APPEND_OK`。最后发送延迟输出及退出命令，只调用 `soft_close`，确认 `SESSION_FINAL_TAIL` 确实在关闭过程中写入日志。
+
+## 检查和输出文件
+
+每次执行在 `tmp/ssh-logs/` 下创建独立目录，目录权限 0700，文件权限 0600：
+
+- `session.log`：收到的原始数据，以及手工添加的 `[SEND] 脚本名 sha256=...` 和 `[EXIT] 脚本名 status=...`。
+- `report.json`：主机、用户、远端 TTY、每项脚本输出和退出码、校验结果、SSH 退出码、日志字节数及 SHA-256。
+
+只有认证后的输出进入日志。Expect 自动记录接收字节，发送的脚本名称和摘要由 `write_log` 明确写入，便于审核执行了哪个 fixture；fixture 文件中的原文可以用报告内的 SHA-256 核对。
+
+共 11 项日志/流程检查：完整输出、执行顺序、即时 flush、stdout/stderr、UTF-8、非零退出后恢复、覆盖模式、暂停记录、追加模式、关闭前尾部输出、密码不出现在日志中。另校验日志条目没有重复，日志句柄在停止记录和关闭会话后正确关闭。
+
+成功返回进程退出码 0。认证失败、超时、脚本输出错误、意外退出码或日志校验失败均返回非零，并在有报告目录时留下 `passed: false` 的报告。不用仅看到终端输出就判断成功；请查看最终 PASS 和 `report.json` 的 `passed`。
+
+## 无需 SSH 的回归测试
+
+```sh
+bundle exec ruby -Itest test/script_logging_test.rb
+bundle exec rake test
+```
+
+`test/script_logging_test.rb` 使用真实本地 PTY 执行相同 fixtures，另外验证回调日志、借用 File 日志、错误退出/错误输出的反例、引号和 shell 元字符、日志错误上抛，以及超时后继续收集日志。它和 SSH 脚本共享测试 helper，不依赖远端账户。
+
+## SSH interact 人工和自动验证
+
+```sh
+ruby examples/ssh_interact.rb
+ruby examples/ssh_interact.rb --auto
+# 自动方式也可通过 Rake 运行
+bundle exec rake test:ssh_interact
+```
+
+使用上述同一套 SSH 环境变量和隐藏密码输入。人工模式显示 `EXPECT_SCRIPT_PROMPT>`；输入命令有回显，Ctrl-C 传给远端前台任务。在命令结束、回到 shell 提示符后按 Ctrl-]，会关闭远端回显，执行 `MANUAL_AUTOMATION_RESUMED` 检查，再正常退出 SSH。也支持直接输入 `exit`：成功退出记为 `completion: remote_exit`，此路径不执行返回 expect 的检查。非零 SSH 退出仍判为失败。
+
+`--auto` 创建真实本地 PTY，验证两次 `interact` 接管、当前用户和远端 TTY、stdout/stderr/中文、Ctrl-C、Ctrl-]、转义后的本地尾部不进入 SSH、恢复 `expect` 及终端与监听设置。4 项命令输出和 13 项交互/日志检查全部通过后才返回 0。
+
+日志在认证之后开启；每次在 `tmp/ssh-interact/` 新建 0700 目录，保存 0600 的 `session.log` 和 `report.json`。报告包含检查项、命令输出、SSH 退出码及日志摘要。自动模式也校验日志无重复、退出尾部不丢失、密码不出现在日志中。
+
+无需 SSH 的回归位于 `test/interact_test.rb`，覆盖可见输入、Ctrl-C、两次接管、返回自动命令、超时、两端 EOF、回调异常和输出 IO 故障时的终端恢复。`test/script_logging_test.rb` 另验证 CRLF 输出边界，包括空输出、末尾有/无换行和多个换行。
+
+## `ssh_auto.rb` 环境检查
+
+```sh
+ruby examples/ssh_auto.rb
+# 无人值守执行（密码可以由运行环境提供 EXPECT_PASSWORD）
+ruby examples/ssh_auto.rb --no-interact
+# 或执行 Rake 的自动退出入口
+bundle exec rake test:ssh_auto
+```
+
+该示例自动登录 `SSH_HOST`（默认 `127.0.0.1`），用本库的 `write` / `expect` 顺序执行文件顶部的 `COMMANDS`，显示真实输出并检查退出码。默认命令为 `id`、`uname -srm`、`sw_vers`、`df -h /` 和 `uptime`，不修改系统设置；可直接修改数组来下发其他 macOS/POSIX shell 命令。它不依赖 `test/support`，`ScriptProbe.check` 只供测试脚本使用。
+
+执行成功后默认进入 `interact`，输入有回显，Ctrl-C 发给远端前台任务；`exit` 或 Ctrl-] 结束连接。使用 `--no-interact` 则执行完退出。`EXPECT_LOG_DIR` 可指定日志目录，默认 `tmp/ssh-auto/`；每次创建独立 0600 日志，记录命令和远端输出，认证前关闭日志。此使用示例不生成 JSON 测试报告，详细日志断言仍由 `ssh_scripts.rb` 和 `ssh_interact.rb --auto` 验证。

data/test/integration/ssh_scripts.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+# Opt-in: this script makes a real SSH connection. The default rake test does
+# not load it, and no password belongs in fixture files or command arguments.
+require "io/console"
+require "json"
+require "fileutils"
+require "tmpdir"
+require "time"
+require_relative "../support/script_probe"
+
+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-logs", __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 = { host: host, port: port, user: user, started_at: Time.now.utc.iso8601, passed: false }
+runner = nil
+session = 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"]
+    # Authentication is completed before opening any log. Parent defaults
+    # cannot accidentally turn on debug or console logging for this check.
+    session = Expect.spawn(*args, raw_pty: true, log_stdout: false, log_listeners: false,
+                                  debug_level: 0, write_timeout: 5)
+    authentication = session.expect_result(/password:\s*\z/i, /Permission denied/i, timeout: 10)
+    ScriptProbe.check(authentication.number == 1,
+                      "SSH password prompt not received (#{authentication.error || "authentication rejected"})")
+    session.write(password, "\n")
+    runner = ScriptProbe::Runner.new(session, timeout: 10).ready!
+    report.merge!(ScriptProbe.verify_file_session(runner, log_path, user: user))
+    report[:ssh_exit_code] = session.exit_code
+    ScriptProbe.check(!File.binread(log_path).include?(password.b), "password detected in session log")
+    report[:checks] << "password_absent"
+    report[:passed] = true
+  end
+rescue StandardError => error
+  # Error messages identify the failed check; raw authentication output is
+  # deliberately excluded from both the report and the console.
+  report[:error] = "#{error.class}: #{error.message}".gsub(password, "[REDACTED]")
+  report[:cases] ||= runner&.results || []
+ensure
+  session&.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_sha256] = Digest::SHA256.file(log_path).hexdigest
+    report[:log_bytes] = File.size(log_path)
+  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
+
+report.fetch(:cases, []).each do |result|
+  puts "#{result[:passed] ? "PASS" : "FAIL"} #{result[:name]} " \
+       "exit=#{result[:status]} expected=#{result[:expected_status]}"
+end
+puts "Log: #{log_path}"
+puts "Report: #{report_path}"
+abort(report[:error]) unless report[:passed]
+puts "PASS SSH multi-script execution and #{report[:checks].length} logging checks; SSH exit=0"

data/test/interact_test.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+require_relative "support/interact_probe"
+require "etc"
+
+class InteractTest < ExpectTest
+  def shell_session
+    session = Expect.spawn("/bin/sh", "-i", env: { "PS1" => ScriptProbe::PROMPT, "ENV" => nil, "LC_ALL" => "C" },
+                                            raw_pty: true, log_stdout: false, write_timeout: 3)
+    @sessions << session
+    ScriptProbe::Runner.new(session).ready!
+    InteractProbe.prepare(session)
+    # Unlike SSH, the simulated remote shell shares the transport's PTY.
+    # Keep its canonical/ISIG settings while interact raws the local keyboard.
+    session.raw_terminal = false
+    session
+  end
+
+  def local_terminal
+    master, slave = PTY.open
+    @ios.push(master, slave)
+    source = Expect.open(slave)
+    @sessions << source
+    [master, slave, source]
+  end
+
+  def test_real_terminal_handoff_ctrl_c_escape_and_resume
+    session = shell_session
+    log = StringIO.new
+    session.log_to(log)
+    report = bounded(20) { InteractProbe.verify(session, user: Etc.getpwuid.name) }
+    assert_equal 4, report[:cases].length
+    assert(report[:cases].all? { |result| result[:passed] })
+    assert report[:local_terminal_restored]
+    assert report[:transport_terminal_restored]
+    text = ScriptProbe.normalize(log.string)
+    %w[AUTOMATION_RESUMED SECOND_HANDOFF_OK STDOUT_FIRST STDERR_SECOND].each do |line|
+      assert_equal 1, text.scan(/^#{line}$/).length
+    end
+    refute_includes text, InteractProbe::TAIL
+  end
+
+  def test_timeout_restores_local_tty_and_session_settings
+    session = shell_session
+    _, slave, source = local_terminal
+    saved = InteractProbe.configuration(source)
+    state = InteractProbe.settings(session)
+    source.on_sequence("original")
+    source_state = InteractProbe.settings(source)
+    assert_nil session.interact(input: source, escape: "\x1d", output: slave, timeout: 0.02)
+    assert_equal saved, InteractProbe.configuration(source)
+    assert_equal state, InteractProbe.settings(session)
+    assert_equal source_state, InteractProbe.settings(source)
+    assert session.alive?
+  end
+
+  def test_manual_typing_is_visible_before_enter_and_automation_resumes_without_echo
+    session = shell_session
+    InteractProbe.prepare(session, echo: true)
+    master, slave, source = local_terminal
+    screen = Expect.open(master, write_timeout: 3)
+    @sessions << screen
+    saved = InteractProbe.configuration(source)
+    session.write("printf '\\n%s\\n' 'MANUAL_READY'\n")
+    keyboard = Thread.new do
+      ScriptProbe.check(screen.expect(/\r?\nMANUAL_READY\r?\n/, timeout: 3), "manual handoff was not ready")
+      ScriptProbe.check(screen.expect(ScriptProbe::PROMPT, timeout: 3), "manual prompt missing")
+      command = "printf 'VISIBLE_COMMAND\\n'"
+      screen.write(command)
+      ScriptProbe.check(screen.expect(command, timeout: 3), "typed command was invisible before Enter")
+      screen.write("\n")
+      ScriptProbe.check(screen.expect(/\r?\nVISIBLE_COMMAND\r?\n/, timeout: 3), "manual command output missing")
+      ScriptProbe.check(screen.expect(ScriptProbe::PROMPT, timeout: 3), "manual command did not return to shell")
+      screen.write(InteractProbe::ESCAPE)
+      true
+    rescue Exception # rubocop:disable Lint/RescueException -- Clean up terminal drivers even on Interrupt or SystemExit.
+      begin
+        screen.write(InteractProbe::ESCAPE)
+      rescue StandardError
+        nil
+      end
+      raise
+    end
+    keyboard.report_on_exception = false
+    assert_same source, session.interact(input: source, escape: InteractProbe::ESCAPE, output: slave, timeout: 12)
+    assert keyboard.join(2), "manual keyboard driver did not finish"
+    assert keyboard.value
+    assert_equal saved, InteractProbe.configuration(source)
+    InteractProbe.prepare(session)
+    log = StringIO.new
+    session.log_to(log)
+    result = ScriptProbe::Runner.new(session).run("manual_resume", "printf 'RESUMED_WITHOUT_ECHO\\n'",
+                                                  expected_status: 0, expected_output: "RESUMED_WITHOUT_ECHO\n")
+    assert result[:passed]
+    refute_includes log.string, "printf"
+  ensure
+    keyboard&.kill&.join if keyboard&.alive?
+  end
+
+  def test_remote_eof_restores_input_terminal_and_keeps_borrowed_io_open
+    session = child('STDIN.gets; print "FINAL_REMOTE_OUTPUT"', raw_pty: true)
+    _, slave, source = local_terminal
+    saved = InteractProbe.configuration(source)
+    output = StringIO.new
+    session.write("go\n")
+    assert_same session, session.interact(input: source, escape: "\x1d", output: output, timeout: 3)
+    assert_equal "FINAL_REMOTE_OUTPUT", output.string
+    assert_equal saved, InteractProbe.configuration(source)
+    refute slave.closed?
+    assert_equal 0, session.wait(timeout: 1).exitstatus
+  end
+
+  def test_local_eof_returns_without_closing_remote_session
+    session = shell_session
+    source, writer = pipe_session
+    writer.close
+    assert_same source, session.interact(input: source, escape: "\x1d", output: StringIO.new, timeout: 2)
+    assert session.alive?
+    session.write("printf 'AFTER_LOCAL_EOF\\n'\n")
+    assert_equal 1, session.expect(/AFTER_LOCAL_EOF\r?\n/, timeout: 2)
+  end
+
+  def test_remote_callback_exception_restores_both_terminals
+    session = shell_session
+    _, slave, source = local_terminal
+    local_mode = InteractProbe.configuration(source)
+    remote_mode = InteractProbe.configuration(session)
+    old_settings = InteractProbe.settings(session)
+    session.on_sequence("CALLBACK_FAILURE") { raise "test callback failed" }
+    session.write("printf 'CALLBACK_FAILURE\\n'\n")
+    error = assert_raises(RuntimeError) { session.interact(input: source, escape: "\x1d", output: slave, timeout: 2) }
+    assert_equal "test callback failed", error.message
+    assert_equal local_mode, InteractProbe.configuration(source)
+    assert_equal remote_mode, InteractProbe.configuration(session)
+    assert_equal old_settings[0..3], InteractProbe.settings(session)[0..3]
+    assert session.alive?
+  end
+
+  def test_output_io_failure_restores_input_terminal
+    session = shell_session
+    _, slave, source = local_terminal
+    saved = InteractProbe.configuration(source)
+    output = StringIO.new
+    output.close
+    session.write("printf 'OUTPUT_FAILURE\\n'\n")
+    assert_raises(IOError) { session.interact(input: source, escape: "\x1d", output: output, timeout: 2) }
+    assert_equal saved, InteractProbe.configuration(source)
+    refute slave.closed?
+  end
+end

data/test/interconnect_test.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class InterconnectTest < ExpectTest
+  def test_interconnect_forwards_and_strips_split_escape
+    session, writer = pipe_session
+    listener = StringIO.new
+    session.listeners = [listener]
+    session.on_sequence("STOP")
+    background do
+      writer.write("helloST")
+      sleep 0.03
+      writer.write("OPtail")
+    end
+    assert_same(session, bounded { Expect.interconnect(session) })
+    assert_equal "hello", listener.string
+    assert_equal "tail", session.buffer
+  end
+
+  def test_sequence_callback_parameters_and_resume
+    session, writer = pipe_session
+    listener = StringIO.new
+    values = []
+    session.listeners = [listener]
+    session.on_sequence("!") do
+      values << :event
+      true
+    end
+    session.on_sequence("?")
+    writer.write("one!two?three")
+    Expect.interconnect(session, timeout: 1)
+    assert_equal "onetwo", listener.string
+    assert_equal [:event], values
+    assert_equal "three", session.buffer
+  end
+
+  def test_zero_is_truthy_and_uppercase_eof_is_a_literal_sequence
+    session, writer = pipe_session
+    output = StringIO.new
+    session.listeners = [output]
+    session.on_sequence("!") { 0 }
+    session.on_sequence("EOF")
+    writer.write("one!twoEOFtail")
+    assert_same session, Expect.interconnect(session, timeout: 1)
+    assert_equal "onetwo", output.string
+    assert_equal "tail", session.buffer
+  end
+
+  def test_eof_flushes_partial_escape
+    session, writer = pipe_session
+    listener = StringIO.new
+    session.listeners = [listener]
+    session.on_sequence("STOP")
+    writer.write("helloST")
+    writer.close
+    assert_same session, Expect.interconnect(session, timeout: 1)
+    assert_equal "helloST", listener.string
+  end
+
+  def test_eof_handler_can_continue_other_sessions
+    first, first_writer = pipe_session
+    second, second_writer = pipe_session
+    listener = StringIO.new
+    second.listeners = [listener]
+    seen = []
+    first.on_sequence(:eof) do
+      seen << :first
+      true
+    end
+    second.on_sequence("!")
+    first_writer.close
+    second_writer.write("second!")
+    assert_same second, Expect.interconnect(first, second, timeout: 1)
+    assert_equal [:first], seen
+    assert_equal "second", listener.string
+  end
+
+  def test_interact_roundtrip_escape_and_restored_settings
+    session = child(<<~'RUBY', raw_pty: true)
+      while (value = STDIN.gets)
+        puts "reply:#{value.strip}"
+      end
+    RUBY
+    source, writer = pipe_session
+    sink = StringIO.new
+    listener = StringIO.new
+    session.listeners = [listener]
+    session.log_listeners = false
+    source.on_sequence("original")
+    background do
+      writer.write("hello\n")
+      # 收到真实响应后才发送退出键，避免将子进程启动速度当成交互完成条件。
+      bounded { sleep 0.001 until sink.string == "reply:hello\n" }
+      writer.write("\x1dtail")
+    end
+    assert_same(source, bounded { session.interact(input: source, escape: "\x1d", output: sink, timeout: 2) })
+    assert_equal "reply:hello\n", sink.string
+    assert_equal "tail", source.buffer
+    assert_equal [listener], session.listeners
+    refute session.log_listeners
+    assert_equal ["original"], source.instance_variable_get(:@sequences).keys
+  end
+
+  def test_terminal_modes_restore_after_callback_exception
+    session = child('print "!"; sleep 30')
+    mode = session.to_io.console_mode
+    original = terminal_configuration(session)
+    session.on_sequence("!") { raise "stop" }
+    assert_raises(RuntimeError) { Expect.interconnect(session, timeout: 1) }
+    assert_equal original, terminal_configuration(session)
+    refute_nil mode
+  end
+
+  def test_manual_stty_leaves_terminal_mode_to_caller
+    session = child('print "!"; sleep 30')
+    session.raw_terminal = false
+    original = session.stty
+    seen = nil
+    session.on_sequence("!") do
+      seen = session.stty
+      false
+    end
+    Expect.interconnect(session, timeout: 1)
+    assert_equal original, seen
+  end
+
+  def test_timeout_flushes_pending_escape_prefix
+    session, writer = pipe_session
+    listener = StringIO.new
+    session.listeners = [listener]
+    session.on_sequence("STOP")
+    writer.write("helloST")
+    assert_nil Expect.interconnect(session, timeout: 0.02)
+    assert_equal "helloST", listener.string
+    assert_empty session.buffer
+  end
+
+  def test_regexp_escape_matches_and_preserves_trailing_input
+    session, writer = pipe_session
+    output = StringIO.new
+    session.listeners = [output]
+    session.on_sequence(/STOP\d+;/)
+    writer.write("beforeSTOP42;after")
+    assert_same session, Expect.interconnect(session, timeout: 1)
+    assert_equal "before", output.string
+    assert_equal "after", session.buffer
+  end
+
+  def test_regexp_escape_tracks_prior_reads_without_delaying_forwarding
+    session, writer = pipe_session
+    seen = []
+    output = StringIO.new
+    session.listeners = [output]
+    session.on_sequence(/STOP\d+;/) do
+      seen << :stopped
+      false
+    end
+    # Await actual forwarding before writing the continuation, ensuring the
+    # test cannot accidentally pass with a single combined read.
+    background do
+      writer.write("beforeSTOP")
+      bounded { sleep 0.001 until output.string == "beforeSTOP" }
+      writer.write("42;after")
+    end
+    assert_same(session, bounded { Expect.interconnect(session, timeout: 1) })
+    assert_equal [:stopped], seen
+    assert_equal "beforeSTOP", output.string
+    assert_equal "after", session.buffer
+  end
+
+  def test_regexp_escape_continuation_does_not_rematch_history
+    session, writer = pipe_session
+    seen = []
+    output = StringIO.new
+    session.listeners = [output]
+    session.on_sequence(/\[[0-9]+\]/) do
+      seen << :hit
+      true
+    end
+    session.on_sequence("!")
+    writer.write("one[12]two[34]three!tail")
+    Expect.interconnect(session, timeout: 1)
+    assert_equal %i[hit hit], seen
+    assert_equal "onetwothree", output.string
+    assert_equal "tail", session.buffer
+  end
+
+  def test_zero_width_regexp_escape_is_rejected_without_spinning
+    session, writer = pipe_session
+    session.on_sequence(/(?=a)/) { true }
+    writer.write("abc")
+    assert_raises(ArgumentError) { bounded { Expect.interconnect(session, timeout: 1) } }
+    assert_equal "abc", session.buffer
+  end
+
+  def test_logs_received_bytes_once_across_expect_interconnect_and_expect
+    session, writer = pipe_session
+    log = StringIO.new
+    output = StringIO.new
+    session.log_to(log)
+    session.listeners = [output]
+    session.on_sequence("!")
+    writer.write("prompt>before!")
+    session.expect("prompt>", timeout: 1)
+    Expect.interconnect(session, timeout: 1)
+    writer.write("after")
+    session.expect("after", timeout: 1)
+    assert_equal "prompt>before!after", log.string
+  end
+
+  def test_log_includes_escape_and_tail_before_next_expect
+    session, writer = pipe_session
+    log = StringIO.new
+    output = StringIO.new
+    session.log_to(log)
+    session.listeners = [output]
+    session.on_sequence("!")
+    writer.write("before!tail")
+    Expect.interconnect(session, timeout: 1)
+    assert_equal "before", output.string
+    assert_equal "before!tail", log.string
+    assert_equal 1, session.expect("tail", timeout: 0)
+    assert_equal "before!tail", log.string
+  end
+end