442 lines
16 KiB
Bash
Executable File
442 lines
16 KiB
Bash
Executable File
#!/bin/sh
|
||
# Persistent terminals for the agent, on top of tmux.
|
||
#
|
||
# A `shell` call used to be a fresh `bash -lc`: the working directory, exports,
|
||
# and anything started in the background died with the call, so the model had to
|
||
# re-derive its way back to a working shell every time. A named tmux session per
|
||
# agent terminal keeps what a human keeps - one place to stand, jobs that stay
|
||
# alive, a Ctrl-C that interrupts the right thing - and the human can watch the
|
||
# same terminal on the desktop with `show`.
|
||
#
|
||
# The API reaches it through the container exec path (one-shot, argv only, no
|
||
# streaming), so finishing is detected by markers in the pane rather than by the
|
||
# exit of the exec itself. Markers are matched only at the start of a line: the
|
||
# shell echoes the typed command, and that echo contains both markers too.
|
||
#
|
||
# lazyboy-shell run <session> <wait_ms> <command> run, wait, print output + exit code
|
||
# lazyboy-shell log <session> [lines] what the terminal shows right now
|
||
# lazyboy-shell keys <session> <key>... C-c / Enter / literal text
|
||
# lazyboy-shell show <session> open it on the desktop for a human
|
||
# lazyboy-shell reset <session> drop the session and start clean
|
||
# lazyboy-shell list sessions and their state
|
||
#
|
||
# Every call is sourced into the live shell (`. file`), which is what makes
|
||
# state survive and also what would let `exit` take the terminal down; a trap on
|
||
# EXIT turns that into a normal end marker and the pane is restarted.
|
||
|
||
set -eu
|
||
|
||
# Wide enough that compiler output and `ls -l` do not wrap, short enough to stay
|
||
# cheap to capture after every call.
|
||
COLS=220
|
||
ROWS=50
|
||
HISTORY=50000
|
||
BACK=4000
|
||
# Guard the model's context: keep the head and the tail of very chatty commands.
|
||
MAX_OUT=20000
|
||
# A marker that scrolled away must not lock a terminal forever.
|
||
STALE_AFTER=600
|
||
|
||
export LANG="${LANG:-zh_TW.UTF-8}"
|
||
export LC_ALL="${LC_ALL:-zh_TW.UTF-8}"
|
||
export TMUX_TMPDIR="${TMUX_TMPDIR:-/tmp}"
|
||
STATE_DIR="${LAZYBOY_SHELL_STATE:-${TMPDIR:-/tmp}/lazyboy-shell}"
|
||
|
||
die() {
|
||
printf 'error: %s\n' "$1" >&2
|
||
exit 2
|
||
}
|
||
|
||
need_tmux() {
|
||
command -v tmux >/dev/null 2>&1 ||
|
||
die "tmux is missing from this desktop image (rebuild with: make computer)"
|
||
}
|
||
|
||
# Paths end up inside the shell code the pane sources; single quotes are the
|
||
# only thing that has to survive.
|
||
sq() {
|
||
printf "'%s'" "$(printf '%s' "$1" | sed "s/'/'\\\\''/g")"
|
||
}
|
||
|
||
# Session names are model input: keep them boring, and namespace them so an
|
||
# agent terminal never collides with a tmux session the human started.
|
||
session_of() {
|
||
case "$1" in
|
||
'' | *[!A-Za-z0-9._-]*) die "session name must use [A-Za-z0-9._-], got: $1" ;;
|
||
esac
|
||
printf 'lazyboy-%s' "$1"
|
||
}
|
||
|
||
# Pane commands name an explicit pane: a detached tmux server has no current
|
||
# pane for the session-only forms to resolve against, and set-option reads the
|
||
# target as a window, so even session options go through the pane.
|
||
pane_target() {
|
||
printf '=%s:0.0' "$1"
|
||
}
|
||
|
||
pane_of() {
|
||
tmux capture-pane -p -J -S "-$BACK" -t "$(pane_target "$1")" 2>/dev/null || true
|
||
}
|
||
|
||
# Tmux paints; the model reads text.
|
||
clean() {
|
||
sed -e 's/\x1b\[[0-9;?]*[a-zA-Z]//g' -e 's/\x1b[()][A-Za-z0-9]//g' -e 's/\x1b[>=]//g' |
|
||
tr -d '\r'
|
||
}
|
||
|
||
# A pane is a fixed grid, so below the prompt there are only empty rows. Tailing
|
||
# one without trimming reads as a blank screen.
|
||
trim_blanks() {
|
||
awk '{ line[NR] = $0; if ($0 !~ /^[ \t]*$/) last = NR }
|
||
END { for (i = 1; i <= last; i++) print line[i] }'
|
||
}
|
||
|
||
# Everything the terminal showed since this call printed its start marker.
|
||
after_start() {
|
||
printf '%s\n' "$1" | awk -v start="LB_START $2" '
|
||
index($0, start) == 1 { keep = 1; next }
|
||
keep { print }'
|
||
}
|
||
|
||
finished_in() {
|
||
printf '%s\n' "$1" | grep -q "^LB_END $2 rc=[0-9][0-9]*$"
|
||
}
|
||
|
||
exit_code_in() {
|
||
printf '%s\n' "$1" | sed -n "s/^LB_END $2 rc=\\([0-9][0-9]*\\)\$/\\1/p" | tail -n 1
|
||
}
|
||
|
||
# The shell is back at its prompt for this call, without having printed an end
|
||
# marker: the command was interrupted (or abandoned the runner). Either way the
|
||
# terminal belongs to the next command.
|
||
ready_in() {
|
||
after_start "$1" "$2" | grep -q '^LB_READY$'
|
||
}
|
||
|
||
is_dead() {
|
||
[ "$(tmux display-message -p -t "$(pane_target "$1")" '#{pane_dead}' 2>/dev/null)" = "1" ]
|
||
}
|
||
|
||
# Fallback for when the integration itself is gone (the model ran `exec bash`,
|
||
# replaced PROMPT_COMMAND, ...): a shell sitting on its prompt is free.
|
||
at_prompt() {
|
||
case "$(tmux display-message -p -t "$(pane_target "$1")" '#{pane_current_command}' 2>/dev/null)" in
|
||
bash | -bash | zsh | -zsh | sh | dash | '' ) ;;
|
||
*) return 1 ;;
|
||
esac
|
||
after_start "$(pane_of "$1")" "${2:-}" | clean | trim_blanks | tail -n 1 |
|
||
grep -qE '[#$%>][[:space:]]*$'
|
||
}
|
||
|
||
# Free for the next command even though this call never reported a result:
|
||
# interrupted at a prompt, replaced its own shell, or died outright.
|
||
released() {
|
||
# Distinct names: sh functions share the caller's variables.
|
||
lb_pane="$1"
|
||
lb_pending="$2"
|
||
lb_name="$3"
|
||
if ready_in "$lb_pane" "$lb_pending"; then
|
||
return 0
|
||
fi
|
||
is_dead "$lb_name" || at_prompt "$lb_name" "$lb_pending"
|
||
}
|
||
|
||
truncate_out() {
|
||
awk -v max="$MAX_OUT" '
|
||
{ if (length(all) < max) all = all $0 "\n"; else dropped = 1 }
|
||
END {
|
||
printf "%s", all
|
||
if (dropped) printf "\n…（輸出過長，已截斷尾段；完整輸出請在 shell 裡用 > 寫進檔案再讀）\n"
|
||
}'
|
||
}
|
||
|
||
# Text between this call's start marker and its end marker.
|
||
output_between() {
|
||
printf '%s\n' "$1" | awk -v start="LB_START $2" -v end="LB_END $2 " '
|
||
index($0, start) == 1 { keep = 1; next }
|
||
index($0, end) == 1 { keep = 0 }
|
||
keep { print }'
|
||
}
|
||
|
||
state_dir_ready() {
|
||
mkdir -p "$STATE_DIR"
|
||
# Snapshots hold exported variables, so keep them out of other users' reach.
|
||
chmod 700 "$STATE_DIR" 2>/dev/null || true
|
||
}
|
||
|
||
# The shell in a dead pane is restarted where it left off: same directory, and
|
||
# the next command re-loads the exported variables from the last snapshot.
|
||
revive_pane() {
|
||
name="$1"
|
||
env_file="$STATE_DIR/$name.env"
|
||
dir="${HOME:-/tmp}"
|
||
if [ -f "$env_file" ]; then
|
||
saved=$(sed -n '1p' "$env_file" 2>/dev/null || true)
|
||
if [ -n "$saved" ] && [ -d "$saved" ]; then
|
||
dir="$saved"
|
||
fi
|
||
fi
|
||
tmux respawn-pane -k -t "$(pane_target "$name")" -c "$dir" /bin/bash -i 2>/dev/null || true
|
||
: >"$STATE_DIR/$name.revive"
|
||
}
|
||
|
||
# REVIVED tells the caller whether it has to say something about the restart.
|
||
REVIVED=no
|
||
ensure_session() {
|
||
name="$1"
|
||
state_dir_ready
|
||
if ! tmux has-session -t "=$name" 2>/dev/null; then
|
||
tmux new-session -d -s "$name" -x "$COLS" -y "$ROWS" -c "${HOME:-/tmp}" "/bin/bash -i"
|
||
fi
|
||
target=$(pane_target "$name")
|
||
# remain-on-exit keeps a dead pane readable, so `exit` in a command does not
|
||
# swallow the output the model still needs; the history has to outlive a
|
||
# compile.
|
||
tmux set-option -t "$target" history-limit "$HISTORY" 2>/dev/null || true
|
||
tmux set-option -t "$target" remain-on-exit on 2>/dev/null || true
|
||
if is_dead "$name"; then
|
||
revive_pane "$name"
|
||
REVIVED=yes
|
||
fi
|
||
}
|
||
|
||
# The shell code a call types into the pane. It is sourced, so `cd` and exports
|
||
# land in the terminal's own shell; it carries its own integration, so a model
|
||
# that clobbers PROMPT_COMMAND or replaces the shell only loses it for one call.
|
||
write_runner() {
|
||
run_file="$1"
|
||
name="$2"
|
||
nonce="$3"
|
||
command="$4"
|
||
env_file="$STATE_DIR/$name.env"
|
||
{
|
||
printf '%s\n' '# LazyBoy agent terminal (see image/computer/lazyboy-shell)'
|
||
printf 'LB_STATE_DIR=%s\n' "$(sq "$STATE_DIR")"
|
||
printf '%s\n' 'lb_ready() { printf "\nLB_READY\n"; }'
|
||
printf 'LB_ENV=%s\n' "$(sq "$env_file")"
|
||
printf '%s\n' 'lb_snapshot() { { pwd -P; export -p; } >"$LB_ENV" 2>/dev/null; }'
|
||
printf '%s\n' 'lb_exit() { printf "\nLB_END %s rc=%s\n" "${LB_NONCE:-shell}" "$1"; lb_snapshot; }'
|
||
printf '%s\n' 'case "${PROMPT_COMMAND-}" in *lb_ready*) : ;; *) PROMPT_COMMAND="lb_ready${PROMPT_COMMAND:+;$PROMPT_COMMAND}" ;; esac'
|
||
printf '%s\n' 'trap '"'"'lb_exit "$?"'"'"' EXIT'
|
||
if [ -f "$STATE_DIR/$name.revive" ] && [ -f "$env_file" ]; then
|
||
printf '%s\n' '{ cd "$(sed -n 1p -- '"$(sq "$env_file")"')" 2>/dev/null;' \
|
||
'eval "$(tail -n +2 -- '"$(sq "$env_file")"' 2>/dev/null)"; } >/dev/null 2>&1 || true'
|
||
rm -f "$STATE_DIR/$name.revive"
|
||
fi
|
||
printf 'LB_NONCE=%s\n' "$(sq "$nonce")"
|
||
printf 'printf %s\n' "'\nLB_START $nonce\n'"
|
||
printf '%s\n' "$command"
|
||
printf '%s\n' '__lb_rc=$?'
|
||
printf 'printf %s\n' "'\nLB_END $nonce rc=%s\n' \"\$__lb_rc\""
|
||
} >"$run_file"
|
||
}
|
||
|
||
do_run() {
|
||
[ "$#" -ge 3 ] || die "run needs <session> <wait_ms> <command>"
|
||
session="$1"
|
||
wait_ms="$2"
|
||
command="$3"
|
||
case "$wait_ms" in '' | *[!0-9]*) die "wait_ms must be a number" ;; esac
|
||
need_tmux
|
||
name=$(session_of "$session")
|
||
ensure_session "$name"
|
||
nonce="$(date +%s%N)-$$"
|
||
pending_file="$STATE_DIR/$name.pending"
|
||
run_file="$STATE_DIR/$name.sh"
|
||
|
||
# An earlier call may still own this terminal. Typing now would feed the
|
||
# running program instead of the shell, so say so rather than corrupt it.
|
||
pending=$(sed -n 's/^nonce=\(.*\)$/\1/p' "$pending_file" 2>/dev/null || true)
|
||
started=$(sed -n 's/^started=\(.*\)$/\1/p' "$pending_file" 2>/dev/null || true)
|
||
if [ -n "$pending" ]; then
|
||
pane=$(pane_of "$name")
|
||
if finished_in "$pane" "$pending" || released "$pane" "$pending" "$name"; then
|
||
# Finished, interrupted, or crashed: the marker is gone or meaningless,
|
||
# and the next command can have the terminal.
|
||
pending=""
|
||
rm -f "$pending_file"
|
||
elif [ -n "$started" ] && [ $(( $(date +%s) - started )) -ge "$STALE_AFTER" ] &&
|
||
printf '%s\n' "$pane" | clean | trim_blanks | tail -n 3 | grep -qE '[\$#>] ?$'; then
|
||
# A marker that scrolled out of the capture window would otherwise lock
|
||
# this terminal forever; an idle prompt after ten minutes means free.
|
||
pending=""
|
||
rm -f "$pending_file"
|
||
fi
|
||
if [ -n "$pending" ]; then
|
||
printf 'status=running session=%s\n' "$session"
|
||
printf 'This terminal is still busy with an earlier command, so nothing was typed.\n'
|
||
printf 'Read it with shell {"session":"%s","logLines":120}, interrupt it with\n' "$session"
|
||
printf '{"session":"%s","keys":"C-c"}, or reset it with {"session":"%s","reset":true}.\n' "$session" "$session"
|
||
printf -- '--- terminal ---\n'
|
||
pane_of "$name" | clean | trim_blanks | tail -n 60 | truncate_out
|
||
return 0
|
||
fi
|
||
fi
|
||
|
||
write_runner "$run_file" "$name" "$nonce" "$command"
|
||
{
|
||
printf 'nonce=%s\n' "$nonce"
|
||
printf 'started=%s\n' "$(date +%s)"
|
||
} >"$pending_file"
|
||
|
||
# One short typed line: the runner itself lives in a file, so nothing about
|
||
# the command needs quoting and long commands cannot outgrow send-keys.
|
||
target=$(pane_target "$name")
|
||
tmux send-keys -t "$target" -l -- ". $(sq "$run_file")"
|
||
tmux send-keys -t "$target" Enter
|
||
|
||
deadline=$(( $(date +%s) + wait_ms / 1000 + 1 ))
|
||
while [ "$(date +%s)" -lt "$deadline" ]; do
|
||
pane=$(pane_of "$name")
|
||
if finished_in "$pane" "$nonce"; then
|
||
rm -f "$pending_file"
|
||
printf 'status=done session=%s exit=%s\n' "$session" "$(exit_code_in "$pane" "$nonce")"
|
||
printf -- '--- output ---\n'
|
||
output_between "$pane" "$nonce" | clean | truncate_out
|
||
# `exit` in a command, or a shell that died by itself: hand the next
|
||
# command a terminal again instead of a dead pane.
|
||
if is_dead "$name"; then
|
||
revive_pane "$name"
|
||
printf 'note: the shell in this terminal exited; it was restarted in the same directory,\n'
|
||
printf 'so cd and exported variables are back but background jobs of that shell are gone.\n'
|
||
fi
|
||
return 0
|
||
fi
|
||
if is_dead "$name"; then
|
||
break
|
||
fi
|
||
sleep 0.1
|
||
done
|
||
|
||
if is_dead "$name"; then
|
||
rm -f "$pending_file"
|
||
printf 'status=closed session=%s\n' "$session"
|
||
printf 'The shell in this terminal exited before it could report a result.\n'
|
||
printf -- '--- terminal ---\n'
|
||
pane_of "$name" | clean | trim_blanks | tail -n 60 | truncate_out
|
||
revive_pane "$name"
|
||
printf 'note: it was restarted in the same directory and is ready for the next command.\n'
|
||
return 0
|
||
fi
|
||
printf 'status=running session=%s waitedMs=%s\n' "$session" "$wait_ms"
|
||
printf 'The command is still running; the output so far follows. Do not type another command into\n'
|
||
printf 'this terminal - poll with shell {"session":"%s","logLines":120} or interrupt with {"keys":"C-c"}.\n' "$session"
|
||
printf -- '--- terminal ---\n'
|
||
pane_of "$name" | clean | trim_blanks | tail -n 60 | truncate_out
|
||
}
|
||
|
||
do_log() {
|
||
[ "$#" -ge 1 ] || die "log needs <session>"
|
||
session="$1"
|
||
lines="${2:-80}"
|
||
case "$lines" in '' | *[!0-9]*) die "lines must be a number" ;; esac
|
||
need_tmux
|
||
name=$(session_of "$session")
|
||
tmux has-session -t "=$name" 2>/dev/null || {
|
||
printf 'status=idle session=%s\nThis terminal has not been used yet.\n' "$session"
|
||
return 0
|
||
}
|
||
pending=$(sed -n 's/^nonce=\(.*\)$/\1/p' "$STATE_DIR/$name.pending" 2>/dev/null || true)
|
||
pane=$(pane_of "$name")
|
||
if is_dead "$name"; then
|
||
printf 'status=closed session=%s\n' "$session"
|
||
elif [ -n "$pending" ] && ! finished_in "$pane" "$pending" &&
|
||
! released "$pane" "$pending" "$name"; then
|
||
printf 'status=running session=%s\nThe command from the earlier call is still running.\n' "$session"
|
||
else
|
||
rm -f "$STATE_DIR/$name.pending"
|
||
printf 'status=idle session=%s\n' "$session"
|
||
fi
|
||
printf -- '--- terminal ---\n'
|
||
printf '%s\n' "$pane" | clean | trim_blanks | tail -n "$lines" | truncate_out
|
||
}
|
||
|
||
# A key name tmux understands is sent as a key; anything else is typed as text.
|
||
send_one() {
|
||
target=$(pane_target "$name")
|
||
case "$1" in
|
||
C-* | M-* | Enter | Return | Escape | Esc | Tab | BSpace | DC | IC | \
|
||
Up | Down | Left | Right | Home | End | PageUp | PageDown | F[1-9] | F1[0-2])
|
||
tmux send-keys -t "$target" "$1"
|
||
;;
|
||
*)
|
||
tmux send-keys -t "$target" -l -- "$1"
|
||
;;
|
||
esac
|
||
}
|
||
|
||
do_keys() {
|
||
[ "$#" -ge 2 ] || die "keys needs <session> <key>..."
|
||
session="$1"
|
||
shift
|
||
need_tmux
|
||
name=$(session_of "$session")
|
||
ensure_session "$name"
|
||
for key in "$@"; do
|
||
case "$key" in
|
||
# Ctrl-C throws the end marker away with the command, which would leave
|
||
# the terminal looking busy forever; the interrupt *is* the release.
|
||
C-c | C-\\ | C-z) rm -f "$STATE_DIR/$name.pending" ;;
|
||
esac
|
||
send_one "$key"
|
||
done
|
||
printf 'status=sent session=%s keys=%s\n' "$session" "$*"
|
||
printf 'Use shell {"session":"%s","logLines":60} to see what it did.\n' "$session"
|
||
}
|
||
|
||
do_show() {
|
||
[ "$#" -ge 1 ] || die "show needs <session>"
|
||
session="$1"
|
||
need_tmux
|
||
name=$(session_of "$session")
|
||
ensure_session "$name"
|
||
command -v xfce4-terminal >/dev/null 2>&1 ||
|
||
die "no desktop terminal available to show this session"
|
||
# Detached so the window outlives this exec: the human sees the same terminal
|
||
# the agent types in and can click into it to take over.
|
||
setsid nohup xfce4-terminal --disable-server --geometry=112x30+64+64 \
|
||
--title="終端機 $session" --command="tmux attach -t $name" >/dev/null 2>&1 &
|
||
printf 'status=shown session=%s\nThe terminal is open on the desktop screen.\n' "$session"
|
||
}
|
||
|
||
do_reset() {
|
||
[ "$#" -ge 1 ] || die "reset needs <session>"
|
||
need_tmux
|
||
name=$(session_of "$1")
|
||
tmux kill-session -t "=$name" 2>/dev/null || true
|
||
rm -f "$STATE_DIR/$name.pending" "$STATE_DIR/$name.revive" "$STATE_DIR/$name.env"
|
||
ensure_session "$name"
|
||
printf 'status=reset session=%s\n' "$1"
|
||
}
|
||
|
||
do_list() {
|
||
need_tmux
|
||
panes=$(tmux list-panes -a -F '#{session_name}|#{pane_dead}' 2>/dev/null || true)
|
||
if [ -z "$panes" ]; then
|
||
printf 'status=empty\nNo agent terminals are running.\n'
|
||
return 0
|
||
fi
|
||
printf '%s\n' "$panes" | while IFS='|' read -r name dead; do
|
||
case "$name" in
|
||
lazyboy-*)
|
||
if [ "$dead" = 1 ]; then
|
||
printf 'session=%s state=closed\n' "${name#lazyboy-}"
|
||
else
|
||
printf 'session=%s state=open\n' "${name#lazyboy-}"
|
||
fi
|
||
;;
|
||
esac
|
||
done
|
||
}
|
||
|
||
program=${0##*/}
|
||
case "${1:-}" in
|
||
run) shift; do_run "$@" ;;
|
||
log) shift; do_log "$@" ;;
|
||
keys) shift; do_keys "$@" ;;
|
||
show) shift; do_show "$@" ;;
|
||
reset) shift; do_reset "$@" ;;
|
||
list) shift; do_list ;;
|
||
*) die "usage: $program run|log|keys|show|reset|list ..." ;;
|
||
esac
|