diff --git a/.github/workflows/v2-ci.yml b/.github/workflows/v2-ci.yml index b6f69f5a70..f77e8c5c88 100644 --- a/.github/workflows/v2-ci.yml +++ b/.github/workflows/v2-ci.yml @@ -983,6 +983,10 @@ jobs: working-directory: . run: bash src/deploy/test_terminal_scrollback_status.sh + - name: ttyd discovers default sockets under arbitrary UIDs (#14789) + working-directory: . + run: bash src/deploy/test_ttyd_socket_discovery.sh + # #4593: the dashboard's per-agent terminal link carries the session as # ?arg=hive-, which ttyd only forwards when started with -a # (--url-arg). The credential branch added in #2178 REPLACED the variable diff --git a/changelog.d/fixed-14789-terminal-arbitrary-uid.md b/changelog.d/fixed-14789-terminal-arbitrary-uid.md new file mode 100644 index 0000000000..61d376060b --- /dev/null +++ b/changelog.d/fixed-14789-terminal-arbitrary-uid.md @@ -0,0 +1 @@ +- Terminal attach finds default tmux sessions under arbitrary container UIDs, including OpenShift restricted SCC deployments, and respects `TMUX_TMPDIR` ([#14789](https://github.com/hivecommons/hive/issues/14789)). diff --git a/src/deploy/test_ttyd_socket_discovery.sh b/src/deploy/test_ttyd_socket_discovery.sh new file mode 100644 index 0000000000..c7c20ea18f --- /dev/null +++ b/src/deploy/test_ttyd_socket_discovery.sh @@ -0,0 +1,148 @@ +#!/bin/bash +# Isolated regression tests: UNIX socket fixtures and command stubs, no live tmux. +set -euo pipefail +export ATTACH_SCRIPT="$(cd "$(dirname "$0")" && pwd)/ttyd-tmux.sh" +python3 - <<'PY' +import json +import os +from pathlib import Path +import socket +import subprocess +import tempfile +import unittest + + +class SocketDiscovery(unittest.TestCase): + def setUp(self): + self.tmp = tempfile.TemporaryDirectory(prefix="ttyd sockets ") + self.addCleanup(self.tmp.cleanup) + self.root = Path(self.tmp.name) + self.bin = self.root / "bin" + self.bin.mkdir() + self.log = self.root / "calls" + self.sessions = {} + self.sockets = [] + self.env = dict(os.environ, PATH=f"{self.bin}:{os.environ['PATH']}", + TMUX_TMPDIR=str(self.root), HIVE_TTYD_WAIT_SEC="0", + CALL_LOG=str(self.log), CURRENT_UID="1000840000", + DEV_UID="1001", OWNER_UID="1000840000") + self.stub("id", '''import os, sys +if sys.argv[1:] == ['-u', 'dev']: + if os.environ['DEV_UID'] == 'missing': + sys.exit(1) + print(os.environ['DEV_UID']) +else: + print(os.environ['CURRENT_UID']) +''') + self.stub("stat", '''import os, sys +print(os.environ['OWNER_UID'] if sys.argv[2] == '%u' else '2000') +''') + self.stub("su-exec", '''import os, sys +with open(os.environ['CALL_LOG'], 'a') as f: + f.write('su-exec ' + sys.argv[1] + '\\n') +os.execvp(sys.argv[2], sys.argv[2:]) +''') + self.stub("tmux", '''import json, os, sys +args = sys.argv[1:] +with open(os.environ['CALL_LOG'], 'a') as f: + f.write(json.dumps(args) + '\\n') +sessions = json.loads(os.environ['SESSIONS']).get(args[1], []) +if args[2] == 'has-session': + sys.exit(0 if args[4] in sessions else 1) +if args[2] == 'list-sessions': + print('\\n'.join(sessions)) +''') + + def stub(self, name, code): + path = self.bin / name + path.write_text("#!/usr/bin/env python3\n" + code) + path.chmod(0o755) + + def server(self, uid, sessions, name="default"): + path = self.root / f"tmux-{uid}" / name + path.parent.mkdir(exist_ok=True) + sock = socket.socket(socket.AF_UNIX) + sock.bind(str(path)) + self.addCleanup(sock.close) + self.sockets.append(sock) + self.sessions[str(path)] = sessions + return str(path) + + def run_attach(self, session="hive-target"): + self.env['SESSIONS'] = json.dumps(self.sessions) + args = [] if session is None else [session] + result = subprocess.run(['bash', os.environ['ATTACH_SCRIPT'], *args], + env=self.env, capture_output=True, text=True, + timeout=10) + calls = self.log.read_text().splitlines() if self.log.exists() else [] + self.calls = [json.loads(c) for c in calls if c.startswith('[')] + self.su_calls = [c for c in calls if c.startswith('su-exec ')] + return result + + def assert_attaches(self, expected): + result = self.run_attach() + self.assertEqual(result.returncode, 0, result.stderr) + self.assertEqual([c[1] for c in self.calls if c[2] == 'attach-session'], + [expected]) + self.assertNotIn('waiting for agent', result.stderr) + + def test_arbitrary_current_uid_precedes_passwd_and_glob(self): + self.server('1001', ['hive-target']) + expected = self.server('1000840000', ['hive-target']) + self.server('42', ['hive-target']) + self.assert_attaches(expected) + + def test_skip_default_without_requested_session(self): + self.server('1000840000', ['hive-other']) + expected = self.server('1001', ['hive-target']) + self.assert_attaches(expected) + + def test_other_uid_fallback_uses_su_exec(self): + self.server('1000840000', []) + expected = self.server('42', ['hive-target']) + self.env['OWNER_UID'] = '42' + self.assert_attaches(expected) + self.assertEqual(self.su_calls, ['su-exec 42:2000'] * len(self.calls)) + + def test_missing_dev_passwd_entry_falls_back_to_1001(self): + self.env['DEV_UID'] = 'missing' + expected = self.server('1001', ['hive-target']) + self.assert_attaches(expected) + + def test_deduplicate_and_list_actual_sessions_on_failure(self): + self.env['DEV_UID'] = self.env['CURRENT_UID'] + first = self.server('1000840000', ['hive-other']) + second = self.server('42', ['hive-another']) + result = self.run_attach() + self.assertNotEqual(result.returncode, 0) + self.assertIn('available sessions: hive-other hive-another', result.stderr) + self.assertEqual([c[1] for c in self.calls if c[2] == 'has-session'], + [first, second]) + self.assertEqual([c[1] for c in self.calls if c[2] == 'list-sessions'], + [first, second]) + self.assertFalse(any(c[2] == 'attach-session' for c in self.calls)) + + def test_non_socket_candidate_is_skipped(self): + path = self.root / 'tmux-1000840000' / 'default' + path.parent.mkdir() + path.write_text('stale file') + expected = self.server('1001', ['hive-target']) + self.assert_attaches(expected) + self.assertFalse(any(c[1] == str(path) for c in self.calls)) + + def test_per_agent_socket_retains_priority(self): + self.server('1000840000', ['hive-target']) + expected = self.server('42', ['hive-target'], 'hive-target') + self.assert_attaches(expected) + + def test_no_argument_diagnostics_use_owner_for_other_default(self): + self.server('42', ['hive-other']) + self.env['OWNER_UID'] = '42' + result = self.run_attach(None) + self.assertNotEqual(result.returncode, 0) + self.assertIn('available sessions: hive-other', result.stderr) + self.assertEqual(self.su_calls, ['su-exec 42:2000']) + + +unittest.main() +PY diff --git a/src/deploy/ttyd-tmux.sh b/src/deploy/ttyd-tmux.sh index f9df51f6d5..b91e81d437 100644 --- a/src/deploy/ttyd-tmux.sh +++ b/src/deploy/ttyd-tmux.sh @@ -1,7 +1,8 @@ #!/bin/bash set -euo pipefail -# ttyd runs as dev (uid 1001) but tmux sessions are owned by per-agent UIDs. +# ttyd may run as dev or an arbitrary container UID; sessions can belong to +# per-agent UIDs. # tmux enforces that only the socket owner can attach, so we must use su-exec # to attach as the agent user. The socket path encodes the UID: # /tmp/tmux-{agent_uid}/hive-{name} @@ -31,33 +32,51 @@ if ! [[ "$TTYD_POLL_SEC" =~ ^[1-9][0-9]*$ ]]; then exit 1 fi +# Use the same search order for attach and diagnostics. OpenShift can run dev +# under a UID absent from passwd; retain the passwd UID and other servers as +# fallbacks for deployments with per-agent ownership. +TMUX_ROOT="${TMUX_TMPDIR:-/tmp}" +default_socket_candidates() { + local current_uid dev_uid sock + local -A seen=() + current_uid=$(id -u) + dev_uid=$(id -u dev 2>/dev/null || echo "1001") + for sock in "$TMUX_ROOT/tmux-${current_uid}/default" \ + "$TMUX_ROOT/tmux-${dev_uid}/default" \ + "$TMUX_ROOT"/tmux-*/default; do + [ -z "${seen[$sock]:-}" ] || continue + seen[$sock]=1 + printf '%s\n' "$sock" + done +} + list_available_sessions() { # Real sessions are named hive-, so listing them turns a dead end into # the one thing the caller needs: a name that would have worked. local found="" - local sock - for sock in /tmp/tmux-*/*; do + local sock session + for sock in "$TMUX_ROOT"/tmux-*/*; do [ -S "$sock" ] || continue + [ "${sock##*/}" = default ] && continue found="${found} $(basename "$sock")" done - local dev_uid default_socket session - dev_uid=$(id -u dev 2>/dev/null || echo "1001") - default_socket="/tmp/tmux-${dev_uid}/default" - if [ -S "$default_socket" ]; then + while IFS= read -r sock; do + [ -S "$sock" ] || continue while IFS= read -r session; do [ -n "$session" ] || continue found="${found} ${session}" - done < <(tmux -S "$default_socket" list-sessions -F '#S' 2>/dev/null || true) - fi + done < <(socket_tmux "$sock" list-sessions -F '#S' 2>/dev/null || true) + done < <(default_socket_candidates) if [ -n "$found" ]; then echo "available sessions:${found}" >&2 else - echo "available sessions: none — no agent tmux sockets exist under /tmp/tmux-*/" >&2 + echo "available sessions: none — no agent tmux sockets exist under ${TMUX_ROOT}/tmux-*/" >&2 fi } -socket_has_session() { +socket_tmux() { local socket="$1" + shift local owner_uid owner_gid owner_spec current_uid local run=() owner_uid=$(stat -c '%u' "$socket" 2>/dev/null || echo "") @@ -67,13 +86,17 @@ socket_has_session() { owner_spec="${owner_uid}:${owner_gid}" run=(su-exec "$owner_spec") fi - "${run[@]}" tmux -S "$socket" has-session -t "$SESSION" 2>/dev/null + "${run[@]}" tmux -S "$socket" "$@" +} + +socket_has_session() { + socket_tmux "$1" has-session -t "$SESSION" 2>/dev/null } find_tmux_socket() { local sock TMUX_SOCKET="" - for sock in /tmp/tmux-*/"${SESSION}"; do + for sock in "$TMUX_ROOT"/tmux-*/"${SESSION}"; do if [ -S "$sock" ] && socket_has_session "$sock"; then TMUX_SOCKET="$sock" return 0 @@ -84,13 +107,12 @@ find_tmux_socket() { # bare default socket is not enough: during boot it may exist before the # requested hive- session does, and attaching immediately would fail # tight-loop instead of waiting for that session to be created. - local dev_uid default_socket - dev_uid=$(id -u dev 2>/dev/null || echo "1001") - default_socket="/tmp/tmux-${dev_uid}/default" - if [ -S "$default_socket" ] && socket_has_session "$default_socket"; then - TMUX_SOCKET="$default_socket" - return 0 - fi + while IFS= read -r sock; do + if [ -S "$sock" ] && socket_has_session "$sock"; then + TMUX_SOCKET="$sock" + return 0 + fi + done < <(default_socket_candidates) return 1 }