tribble-control 0.4.4

data/examples/tribble.conf

@@ -0,0 +1,208 @@
+# -*- conf -*-
+#
+# Which device sits on which hub port, and how to reach it.  Copy this
+# beside your own setup's configuration, edit it, and point
+# tribble-control at it with -C/--config.
+#
+# See `tribble-control --man`: CONFIGURATION for every key, PROTECTED PORTS
+# for what 'protect' does.
+#
+# Two keys on one line need a comma between them; one key per line, as
+# below, needs nothing.
+
+# Which hub these ports are on.  Three shapes, told apart by what they
+# look like:
+#
+#     AL03GD7X       the serial number of its FT232 control adapter
+#     1-1.2.4.4      a USB path: the adapter in that socket (Linux)
+#     /dev/ttyUSB1   the serial line itself, if it has a '/' in it
+#
+# Do not write the third.  The number in /dev/ttyUSB1 is the usbserial
+# layer's index -- not the hub's, not the USB device number -- and it
+# is the lowest one free when the adapter is probed.  It is reused,
+# too: unplug whatever holds ttyUSB0 and the next thing to attach takes
+# it.  Two hubs can swap names across a reboot or while the machine is
+# up, and nothing notices.
+#
+# The serial follows the HUB, the USB path follows the SOCKET.  The
+# serial is the usual want; the path is for a hub whose EEPROM carries
+# no serial, which has no other stable name, and for a bench where the
+# socket is what is fixed.  A path is this host's own numbering and
+# does not mean the same thing on another machine.
+#
+# A host with one hub does not need this line at all: the tool finds
+# the one FTDI 0403:6001 on it.  A host with two refuses to guess, and
+# lists the serials to put here.  With the line, -C alone says which
+# bench, which is already the thing a command has to say.
+#
+# Quote a serial that is all digits.  UCL reads an unquoted one as a
+# number, and a number has no leading zeros: 00760040233 arrives here
+# as 760040233 and matches nothing.  Quoting costs nothing on a serial
+# that does not need it, so quote them all.
+device = 'AL03GD7X'
+
+# Which KIND of hub the lines above describe.  'exsys' (the default) is
+# the ExSYS managed hub over its FT232 line; 'usb' is any standard USB
+# hub with per-port power switching, driven on FreeBSD through
+# usbconfig(8) hub-class requests and needing membership of group
+# operator, not root.  It has to be said, because it cannot be read off
+# the 'device' line: a USB path names the FT232's socket for the one and
+# the hub itself for the other.  --hub on the command line overrides it.
+#
+# A 'usb' hub is named the same three ways, in its own shapes:
+#
+#     AC0528515619   the hub's own serial number
+#     1-1.1          a USB path: the hub in that socket
+#     ugen1.4        that device, used as given
+#
+# Write the serial.  The path is for a hub that carries none, or for a
+# bench where the socket is the fixed thing.  The third is for the
+# one-off only: the number is enumeration order, so a replug renumbers
+# it, the same way /dev/ttyUSB1 above is renumbered.  Leave the line out
+# on a host with one switchable hub below its root hubs and it is found;
+# with two, the refusal lists them with serial, ugen name, path and port
+# count.  The ports are then the hub's own, 1 to the bNbrPorts its hub
+# descriptor reports, and not the ExSYS hub's fixed 16.
+hub = exsys
+
+# For hub = usb only: what that hub's 'off' does.  'link' (the default)
+# takes the port off the bus and leaves the board powered; 'vbus' cuts
+# the socket's power.  Software cannot tell the two apart -- a hub with
+# no power switch wired still reports the port unpowered and drops the
+# link, so the device vanishes and returns either way -- so watch a
+# board's LED during `tribble-control usb off <port>`: an LED that goes
+# out is vbus, one that stays lit while the board disappears from the
+# host is link.  Test the socket you will use, since the USB 2 and USB 3
+# sides of one socket are different ports on different hubs.  Under
+# 'link' every power-down still works and warns, and the after-flash
+# power cycle is skipped rather than pretended: the board does not
+# restart.  The ExSYS hub refuses this key rather than ignoring it; it
+# always cuts power.
+#switch = link
+
+# What must never be powered down.
+#
+# 'undeclared' decides the fate of a port this file does not mention:
+# yes, the default, means only declared ports may be powered down; no
+# means any port the hub has may be.  It matters more on a dock, where
+# one hub port feeds the next hub in the chain and another the Ethernet
+# adapter.
+#
+# 'ports' and 'nodes' name what stays powered whichever way that falls:
+# a port number for what has no entry in this file, the name of an
+# entry for what has one.  Anything the hub feeds but nobody talks to
+# belongs in one of them -- a single-board computer, a powered
+# peripheral.  Nothing notices if their VBUS disappears, they simply
+# reboot, uncleanly, mid-write.
+#
+# Prefer the name where there is an entry to name: the port is then
+# written once instead of twice, and the protection moves with the
+# board.  A name nothing declares is refused, not a line that quietly
+# protects nothing.
+protect {
+  undeclared = yes
+  ports      = [ 13, 14, 15, 16 ]
+  nodes      = [ rpi ]
+}
+
+# Which tally reads the boards' consoles: it counts what the firmware
+# prints and writes the SUMMARY line at the end of a 'connect' capture.
+# 'lines' (the default) counts lines and nothing else; 'none' writes no
+# summary; anything else is registered by a Ruby file given with
+# -r/--require, and is where knowledge of one firmware's output lives.
+# See `tribble-control --man`: TALLIES.  A device entry may override it.
+tally = lines
+
+# Settings a device can inherit, so that what a KIND of board is gets
+# said once instead of on every board of that kind.  A device names one
+# with `type =`, and its own keys win over the type's.
+#
+# A type may not set 'port' or 'serial' -- both name one particular
+# board -- and types do not nest.  A type nothing defines here is an
+# error, not a quiet fall back to the tool's defaults: a board that
+# asked for jlink and silently got cmsis-dap is a flash through the
+# wrong probe, reported as success.
+types {
+  nrf52840-mdk {
+    interface = cmsis-dap
+    target    = nrf52
+    transport = swd
+    baud      = 230400
+  }
+  dwm1001-dev {
+    interface   = jlink
+    target      = nrf52
+    transport   = swd
+    baud        = 115200
+    # For a module whose radio does not come back from a plain SWD
+    # reset: cut and restore the port after a successful flash.
+    power_cycle = after-flash
+  }
+}
+
+# Every other key is a device.  'port' is required: the hub's own port
+# number, 1 to 16.
+#
+# 'serial' is the debug probe's serial number, not the board's.  It is
+# what addresses a board for 'reset' and for flashing in parallel
+# (--method serial), so a board without one can only be reached by
+# cutting every other port (--method power).  Read it off a powered
+# board with `tribble-control serial <name>` and paste it whole: 48 hex
+# characters for CMSIS-DAP, 12 for J-Link.
+alpha {
+  type   = nrf52840-mdk
+  serial = '1026360216055e5b00000000000000000000000097969902'
+  port   = 1
+}
+
+# interface defaults to cmsis-dap, target to nrf52 and baud to 230400.
+# Spelling them out on every board, as above, is worth the noise once a
+# setup carries more than one kind: a default that fits most of them and
+# not the rest is the sort of thing nobody checks until a flash goes to
+# the wrong probe or a console comes back as noise.
+#
+# interface and target are independent: the first is the openocd
+# interface script (which probe), the second its target script (which
+# chip).  Either is any name openocd can find, without the .cfg.
+#
+# transport defaults to swd; set it to jtag, or to whatever the pair
+# speaks, and to none to let the interface script decide.  work_area,
+# not shown, is the target RAM openocd may use for flash algorithms:
+# 0x4000 by default, or none to leave it to the target script.
+beta {
+  type   = dwm1001-dev
+  serial = '000760040233'
+  port   = 7
+}
+
+# A type says what a KIND has in common; an entry may still differ.
+# This one is an MDK whose console has been moved.
+delta {
+  type   = nrf52840-mdk
+  serial = '1026360213072dde00000000000000000000000097969902'
+  baud   = 9600
+  port   = 3
+}
+
+# A board with no serial is still switchable and still has a console;
+# it just cannot be reset, or flashed in parallel.
+gamma {
+  port = 2
+}
+
+# Something the bench only feeds.  It is declared for two reasons:
+# 'protect { nodes }' can then name it, which keeps the port number in
+# one place, and 'usb status' prints 'rpi' on that row instead of a
+# dash -- so the protected port says what it is protecting.
+rpi {
+  port = 12
+}
+
+# 'port = none' keeps a record without a board: the entry is never
+# selected, switched or flashed, and naming it says so.  Write it when
+# a board stops enumerating and its port is given away, so that its
+# serial is not lost.
+retired {
+  serial = '1026360202c4dc0f00000000000000000000000097969902'
+  port   = none
+}

data/examples/vbus-check

@@ -0,0 +1,140 @@
+#!/bin/sh
+# vbus-check — find out what a hub's 'off' does to a socket: cut one
+# port for a few seconds while you watch the LED of the board on it,
+# restore it, and print the 'switch =' line the answer implies.
+#
+# usage: vbus-check [-n] [-t seconds] [tribble-control options...] PORT|NAME
+#
+# Everything between the script's own flags and the last argument is
+# handed to tribble-control unchanged, so name the hub the way you
+# would for any command: -C tribble.conf, or --hub usb -d SERIAL -F.
+# Without a configuration tribble-control refuses to power anything down,
+# which is what -F is for here.
+#
+#   -n           dry run: print what would be switched, switch nothing
+#   -t seconds   how long the port stays off (default 5)
+#
+# Environment: TRIBBLE_CONTROL names the binary (default: tribble-control
+# on PATH).  Exit 0 with an answer, 1 when tribble-control refused or
+# the port could not be switched, 2 on a usage error.
+#
+# Why a script: software cannot tell whether a hub's power switch is
+# wired to VBUS.  A hub with none still reports the port unpowered and
+# drops the link, so the board vanishes and returns either way.  Only
+# an LED knows -- see 'switch' in tribble-control(1).
+set -eu
+
+: "${TRIBBLE_CONTROL:=tribble-control}"
+readonly countdown=3
+
+progname=${0##*/}
+
+die()  { printf '%s: %s\n' "$progname" "$*" >&2; exit 1; }
+warn() { printf '%s: %s\n' "$progname" "$*" >&2; }
+
+usage() {
+    printf 'usage: %s [-n] [-t seconds] [tribble-control options...] PORT|NAME\n' \
+           "$progname" >&2
+    exit 2
+}
+
+# The script's own flags come first and are few; everything after them
+# belongs to tribble-control, so getopts cannot be let loose on the
+# whole line.
+dry_run=0 hold=5
+while [ $# -gt 0 ]; do
+    case $1 in
+    -n) dry_run=1; shift ;;
+    -t) [ $# -ge 2 ] || usage
+        hold=$2; shift 2 ;;
+    -t*) hold=${1#-t}; shift ;;
+    --) shift; break ;;
+    *)  break ;;
+    esac
+done
+case $hold in
+    ''|*[!0-9]*) warn "-t takes a number of seconds, not '$hold'"; usage ;;
+esac
+[ $# -ge 1 ] || usage
+
+# The last argument is the port; the rest are tribble-control's.  POSIX
+# sh has no arrays, so the list is rebuilt: the first n-1 arguments are
+# appended after the originals, then the originals are shifted off.
+port=
+for arg in "$@"; do port=$arg; done
+n=$(( $# - 1 ))
+i=0
+for arg in "$@"; do
+    i=$(( i + 1 ))
+    [ "$i" -le "$n" ] && set -- "$@" "$arg"
+done
+shift $(( n + 1 ))
+
+command -v "$TRIBBLE_CONTROL" >/dev/null 2>&1 \
+    || die "no $TRIBBLE_CONTROL on PATH; set TRIBBLE_CONTROL to the binary"
+
+tc() { "$TRIBBLE_CONTROL" "$@"; }
+
+# Status listings are commentary: the product of this script is the one
+# 'switch =' line at the end, and that is all that goes to stdout.
+status() {
+    printf -- '--- %s\n' "$1" >&2
+    shift
+    tc "$@" usb status >&2 || die 'usb status failed; is the hub named?'
+}
+
+# Restore the port on every exit once it has been cut, Ctrl-C during
+# the hold included: a check that leaves the board off has done the
+# one thing it exists to warn about.
+cut=0
+restore() {
+    if [ "$cut" -eq 1 ]; then
+        cut=0
+        warn "making sure port $port is on"
+        tc "$@" usb on "$port" >&2 || warn "could not restore port $port"
+    fi
+}
+# shellcheck disable=SC2064  # "$@" must be captured now: the trap runs after the list is gone
+trap "restore $(printf "'%s' " "$@")" EXIT
+trap 'exit 130' INT TERM
+
+printf 'Watch the LED of the board on port %s.\n' "$port" >&2
+printf 'In %s seconds the port is cut for %s seconds, then restored.\n' \
+       "$countdown" "$hold" >&2
+
+status 'before' "$@"
+
+if [ "$dry_run" -eq 1 ]; then
+    printf 'dry run: would run %s %s usb off %s, wait %ss, then usb on %s\n' \
+           "$TRIBBLE_CONTROL" "$*" "$port" "$hold" "$port" >&2
+    exit 0
+fi
+
+sleep "$countdown"
+cut=1
+tc "$@" usb off "$port" >&2 || die "tribble-control refused to cut port $port"
+status 'while cut' "$@"
+sleep "$hold"
+restore "$@"
+status 'after' "$@"
+
+# The question, asked on the terminal even when stdin is a pipe.  With
+# no terminal at all there is nobody to ask, so both readings are
+# printed and the caller decides.
+if [ ! -r /dev/tty ]; then
+    warn 'no terminal to ask on; the LED decides:'
+    printf '%s\n' 'switch = vbus   # if the LED went out' \
+                  'switch = link   # if it stayed lit'
+    exit 0
+fi
+while :; do
+    printf 'Did the LED go out while the port was off? [y/n] ' >&2
+    IFS= read -r answer < /dev/tty || die 'no answer'
+    case $answer in
+    [Yy]*) printf 'Write this at the top of the configuration:\n' >&2
+           printf '%s\n' 'switch = vbus'; break ;;
+    [Nn]*) printf 'Write this at the top of the configuration, or leave it out (it is the default):\n' >&2
+           printf '%s\n' 'switch = link'; break ;;
+    *)     warn 'y or n' ;;
+    esac
+done

data/exe/tribble-control

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+#
+# tribble-control -- power, flash and monitor the boards plugged into a
+# switchable USB hub.  See `tribble-control --man`.
+#
+require 'tribble-control'
+
+begin
+    TribbleControl::CLI.run
+rescue => e
+    warn "#{TribbleControl::CLI::PROGNAME}: #{e.message || 'unknown'}"
+    warn e.backtrace if $DEBUG
+    exit 1
+end

data/lib/tribble-control/cli/connect.rb

@@ -0,0 +1,282 @@
+require_relative '../cli'
+require_relative '../tally'
+require 'uart'
+
+module TribbleControl
+
+class CLI
+class Connect < CLI::Command
+    DESCRIPTION = 'Read board consoles'
+
+    # usb first, so it stays the default where it works.  serial is
+    # what reaches a console on a host with no /sys/bus/usb: it needs
+    # no topology, only the probe serial the configuration already carries
+    # to address the board for flashing.
+    Methods  = [ 'usb', 'serial' ]
+    Defaults = {}
+    Repeatable = [ :tally ]
+    Parser   = OptionParser.new do |opts|
+        opts.banner = "Usage: #{PROGNAME} connect [options] PORT"
+
+        opts.separator ''
+        opts.separator "#{DESCRIPTION}."
+        opts.separator ''
+
+        opts.separator 'Options:'
+        opts.on '--off', 'Start with all devices off'
+        opts.on '--reset', 'Reset each board once its console is open,' \
+                           ' so boot output is captured'
+        opts.on '--duration=SECONDS', Integer,
+                'How long to capture for (default 600)'
+        opts.on '--command=CMD', 'Shell command to send to every selected' \
+                                 " board's own console once it is up"
+        opts.on '--interactive', 'Type at the board: forward this' \
+                                 ' standard input to it, and stay until' \
+                                 ' end of input rather than for a duration'
+        # NAME, not [DEV=]NAME: OptionParser reads brackets after the
+        # '=' as an optional argument, which '--tally twr' never fills.
+        opts.on '--tally=NAME', Array,
+                'Read the consoles with tally NAME for this run,' \
+                ' whatever the configuration says; DEV=NAME for one' \
+                ' board only (repeatable, comma-separated)'
+    end
+
+    # Each selected board's tally, built: { name => tally }.
+    #
+    # +given+ is what --tally said, in order.  A bare NAME is the run's
+    # tally, DEV=NAME is one board's; the configuration answers for
+    # whatever neither names.  So, for one board, the first of: DEV=NAME,
+    # NAME, the board's own tally key (or its type's), the file's, lines.
+    #
+    # Built here, all of them, before anything is switched, so an unknown
+    # name stops the run before --off cuts the bench or a reader starts.
+    # A board later skipped for having no console costs a block call.
+    #
+    # The run gets the last word because the configuration is about
+    # boards, not about what is flashed on them, and the same board
+    # carries different firmware from one run to the next.
+    def tallies(ids, given)
+        names   = (ids.empty? ? devices : ids).map {|id| name_of(id) }
+        run     = nil
+        boards  = {}
+
+        # '--tally=' stores an empty list and 'a,,b' a nil between a and
+        # b.  Taken as no --tally at all, the first would hand every
+        # board back to the configuration -- the silent fallback this
+        # option exists to prevent.
+        if given && (given.empty? || given.any? {|s| s.to_s.empty? })
+            raise Error, '--tally: an empty NAME (--tally= or a doubled' \
+                         ' comma); give NAME or DEV=NAME'
+        end
+
+        Array(given).each do |spec|
+            dev, eq, which = spec.rpartition('=')
+            if eq.empty?
+                if run && run != which
+                    raise Error, "--tally gives two tallies for the run" \
+                                 " (#{run}, #{which}): use DEV=NAME for" \
+                                 ' one board'
+                end
+                run = which
+                next
+            end
+            if dev.empty? || which.empty?
+                raise Error, "--tally #{spec}: expected NAME or DEV=NAME"
+            end
+            name = name_of(dev)
+            unless names.include?(name)
+                raise Error, "--tally #{spec}: #{name} is not captured by" \
+                             " this run (#{names.join(' ')})"
+            end
+            if boards[name] && boards[name] != which
+                raise Error, "--tally gives #{name} two tallies" \
+                             " (#{boards[name]}, #{which})"
+            end
+            boards[name] = which
+        end
+
+        names.to_h {|n| [ n, Tally.build(boards[n] || run || tally(n), n) ] }
+    end
+
+    # A device name, from a name or a port number as the command line
+    # takes them.  An id the configuration does not know is the user's
+    # error, said as one, not a KeyError.
+    def name_of(id)
+        @cli.name_port(id).first
+    rescue KeyError
+        raise Error, "no device '#{id}' in the configuration"
+    end
+
+    # Where this board's console is.
+    #
+    # The USB path first, because it names the device itself and is
+    # what --method usb went to the trouble of working out.  The probe
+    # serial second: it identifies the console just as exactly, needs
+    # no USB tree to be walked, and is therefore the only one of the
+    # two that a FreeBSD host can answer.  nil means neither found it,
+    # which is a board that is not there.
+    def console(hopts)
+        if hopts[:usb] && (path = Platform.usb_to_tty(hopts[:usb]))
+            path
+        else
+            Platform.serial_to_tty(hopts[:serial])
+        end
+    end
+
+    def run(argv, **opts)
+        # No configuration, no boards to name: each_device says so below,
+        # in its own words, before a counter is ever asked for.
+        counters = opts.include?(:config) ? tallies(argv, opts[:tally]) : {}
+
+        # Before anything is powered, reset or started.
+        if opts[:interactive] && opts.include?(:config) && counters.size != 1
+            raise Error, 'connect: --interactive takes a single device' \
+                         " (#{counters.size} selected)"
+        end
+        @failed = []
+
+        if opts[:off]
+            off_ports = offable(force: opts[:force])
+            tty&.info "Starting from off state: #{off_ports.join(' ')}"
+            hub.off(*off_ports)
+            warn_link_only(off_ports)
+        end
+
+        connected = []
+        each_device(argv).each do |name, hopts={}|
+          # No tty, no reader.  usb_to_tty returns nil when the glob finds
+          # no ttyACM under the port: the board is dead, unplugged, or
+          # simply slower to enumerate than --warm-up allowed.  Said, and
+          # counted as a failure: a board that cannot be read must not
+          # look like one that is up and saying nothing, which is the one
+          # question 'connect' exists to answer.
+          dev_tty = console(hopts)
+          if dev_tty.nil?
+            where = hopts[:usb] || "probe #{hopts[:serial] || '(no serial)'}"
+            tty&.error "Device #{name}: no console enumerated at" \
+                       " #{where}; not capturing it"
+            @failed << name
+            next
+          end
+          tty&.info "Connecting to #{name} on #{dev_tty}"
+          connected << [ name, hopts ]
+
+            # What the lines MEAN is not this tool's business: the
+            # strings worth counting belong to whatever firmware
+            # happens to be on the bench this month, and they change
+            # without a hub changing.  The tally --tally or the
+            # configuration names is handed every line and asked, at the
+            # end, for one summary.  See #tallies, TribbleControl::Tally,
+            # and --require.
+            counter = counters.fetch(name)
+            Thread.new { read_console(name, dev_tty, counter) }
+        end
+
+        # A board that is already running has usually said everything it
+        # had to say before its console was opened: the banner and the
+        # driver's init lines are long gone.  Resetting once the readers
+        # are attached is the only way to see them.
+        if opts[:reset]
+            sleep(1)                    # let the reader threads settle
+            connected.each do |name, hopts|
+                tty&.info "Resetting #{name}"
+                unless openocd('init', 'reset run', **hopts)
+                    tty&.error "Device #{name}: Reset failed"
+                end
+            end
+        end
+
+        # The interesting output is often below the firmware's compiled-in
+        # log level, and spank can be turned up at run time, by typing at
+        # the shell.  Written on a second, write-only handle: the reader
+        # thread already holds the port, and sharing one IO across threads
+        # for opposite directions is a race waiting for a long bench run.
+        if (cmd = opts[:command])
+            sleep(opts[:reset] ? 2 : 0.5)   # let the shell come up
+            connected.each do |name, hopts|
+                dev_tty = console(hopts)
+                tty&.info "Sending to #{name}: #{cmd}"
+                begin
+                    File.open(dev_tty, File::WRONLY | File::NOCTTY) do |w|
+                        w.sync = true
+                        w.write("\r#{cmd}\r")
+                    end
+                rescue SystemCallError => e
+                    tty&.error "Device #{name}: could not send command" \
+                               " (#{e.message})"
+                end
+            end
+        end
+
+        # Either we are being watched or we are being typed at.  A
+        # duration is what an unattended capture needs; a console is
+        # what a question needs, and it ends when the person asking
+        # says so, not on a timer they would have to guess in advance.
+        if opts[:interactive]
+            interact(connected)
+        else
+            sleep(opts[:duration] || 600)
+        end
+
+        # A board that was never read is not a quiet board: exit 1.
+        @failed.empty?
+    end
+
+    # Read one board's console until the run ends, and say how it went.
+    #
+    # A console that will not open (permission, busy, gone), a read that
+    # fails on unplug, or a tally that raises ends the reader with an
+    # ERROR line on stdout, where a capture keeps it, and no SUMMARY: a
+    # summary of a board never read would read as one that said
+    # nothing.  The run then exits 1.
+    def read_console(name, dev_tty, counter)
+        failed = false
+        UART.open dev_tty, @cli.baud(name) do |serial|
+            loop do
+              line = serial.readline
+              counter << line
+              puts "<#{name}> #{line}"
+            rescue EOFError
+                retry
+            end
+        end
+    rescue StandardError => e
+        failed = true
+        (@failed ||= []) << name
+        puts "<#{name}> ERROR: #{e.message} (#{e.class}); not read past this point"
+    ensure
+        if !failed && (summary = counter.summary)
+            puts "<#{name}> SUMMARY: #{summary}"
+        end
+    end
+
+    # Stdin to the board, a line at a time.
+    #
+    # On a second, write-only handle, as --command is.  What comes back
+    # is printed by the reader thread, prefixed like everything else, so
+    # the answer to what was typed appears where the rest of the board's
+    # output does.
+    #
+    # Lines, not characters: the shell on the far end wants a complete
+    # line terminated by \r, and there is nowhere here to run a line
+    # editor.  Over ssh -t that is no loss -- the pty at the other end
+    # of the connection does the editing and the echo, so what arrives
+    # is already the line that was meant.
+    def interact(connected)
+        # One device was selected (run checked); none here means its
+        # console did not enumerate, which run has already reported.
+        raise Error, 'connect: no console to type at' if connected.empty?
+        name, hopts = connected.first
+        dev_tty = console(hopts)
+        tty&.info "Typing at #{name} (^D to leave)"
+        File.open(dev_tty, File::WRONLY | File::NOCTTY) do |w|
+            w.sync = true
+            while (line = $stdin.gets)
+                w.write("#{line.chomp}\r")
+            end
+        end
+    end
+end
+end
+
+end