Skip to content

The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.

fix(os): target the active updater instead of a named tab (#820)

Dee0de712afa23c
diff --git a/.github/workflows/os-input.yml b/.github/workflows/os-input.yml
index 3add318db..bd8b241a4 100644
--- a/.github/workflows/os-input.yml
+++ b/.github/workflows/os-input.yml
@@ -9,9 +9,9 @@ on:
default: '37222390225'
required: true
probe:
- description: 'Laptop controls, Apple boot modules or unsupported-platform install refusal'
+ description: 'Laptop controls, Apple boot modules, install refusal or updater pane ownership'
type: choice
- options: [laptop-input, apple-boot, install-preflight]
+ options: [laptop-input, apple-boot, install-preflight, update-pane, update-context]
default: laptop-input
required: true
push:
@@ -42,7 +42,9 @@ jobs:
env:
PROBE: ${{ inputs.probe }}
run: |
- if [[ "$PROBE" == install-preflight ]]; then
+ if [[ "$PROBE" == update-pane || "$PROBE" == update-context ]]; then
+ python3 -m py_compile os/tests/update_pane_vm.py os/tests/update_pane_guest.py os/tests/update_context_vm.py os/live_update.py os/root/usr/lib/harness-os/open-updates
+ elif [[ "$PROBE" == install-preflight ]]; then
PYTHONPATH=os/tests python3 -m unittest test_hardware test_installer
python3 -m py_compile os/tests/platform_preflight_vm.py os/tests/platform_preflight_guest.py
python3 os/tools/check.py
@@ -54,7 +56,7 @@ jobs:
sudo apt-get install -y --no-install-recommends qemu-system-x86 qemu-utils ovmf python3-pil tesseract-ocr
sudo chmod a+rw /dev/kvm
- name: Check actual media-key input on USB and installed sessions
- if: ${{ inputs.probe != 'apple-boot' && inputs.probe != 'install-preflight' }}
+ if: ${{ inputs.probe == 'laptop-input' || !inputs.probe }}
run: python3 os/tests/input_vm.py --iso os/dist/*.iso
- name: Check Apple initramfs selection and encrypted boot
if: ${{ inputs.probe == 'apple-boot' }}
@@ -62,6 +64,12 @@ jobs:
- name: Check unsupported-platform refusal without disk writes
if: ${{ inputs.probe == 'install-preflight' }}
run: python3 os/tests/platform_preflight_vm.py --iso os/dist/*.iso
+ - name: Check actual updater pane ownership and closing handoff
+ if: ${{ inputs.probe == 'update-pane' }}
+ run: python3 os/tests/update_pane_vm.py --iso os/dist/*.iso
+ - name: Observe shipped updater pane identity interfaces without installing
+ if: ${{ inputs.probe == 'update-context' }}
+ run: python3 os/tests/update_context_vm.py --iso os/dist/*.iso
- name: Retain actual input, module and display evidence
if: always()
uses: actions/upload-artifact@v6
@@ -71,11 +79,17 @@ jobs:
os/test-results/input/
os/test-results/apple-boot/
os/test-results/install-preflight/
+ os/test-results/update-pane/
+ os/test-results/update-context/
!os/test-results/input/*.qcow2
!os/test-results/input/OVMF_VARS.fd
!os/test-results/apple-boot/*.qcow2
!os/test-results/apple-boot/OVMF_VARS.fd
!os/test-results/install-preflight/*.qcow2
!os/test-results/install-preflight/OVMF_VARS.fd
+ !os/test-results/update-pane/*.qcow2
+ !os/test-results/update-pane/OVMF_VARS.fd
+ !os/test-results/update-context/*.qcow2
+ !os/test-results/update-context/OVMF_VARS.fd
retention-days: 14
compression-level: 0
diff --git a/os/README.md b/os/README.md
index b7d47a072..2ed4a5e37 100644
--- a/os/README.md
+++ b/os/README.md
@@ -205,7 +205,7 @@ is always deliberate. After that reboot, the same update request finishes any
remaining hn/CLI release against the new OS base. Later background checks return
to downloading only. See [update development](DEVELOPMENT.md#fast-hn-updates).
-Earlier previews retain their existing controls until this update is installed:
+Previews 5 through 11 retain their existing controls until this update is installed:
**Super+u**, then **s**, then the account password. No new USB flash is needed.
Preview 4 needs the matching bootstrap bundle from the
diff --git a/os/live_update.py b/os/live_update.py
index 720cc077e..c4df8bde1 100644
--- a/os/live_update.py
+++ b/os/live_update.py
@@ -38,6 +38,7 @@ DOWNLOAD_CHUNK = 1024 * 1024
RESTART_REQUIRED = Path('/run/harness-os-restart-required')
SYSTEM_LOCK = Path('/run/lock/hn-os.lock')
BOOT_ID = Path('/proc/sys/kernel/random/boot_id')
+PROC = Path('/proc')
WORDMARK = ('█ █ ▄▀█ █▀█ █▄ █ █▀▀ █▀ █▀', '█▀█ █▀█ █▀▄ █ ▀█ ██▄ ▄█ ▄█')
@@ -78,6 +79,59 @@ def write(path, data):
temporary.unlink(missing_ok=True)
+@contextmanager
+def screen_registration():
+ """Publish only an active Updates UI, not the rest of its process lifetime."""
+ token = os.environ.get('HARNESS_UPDATE_INSTANCE', '')
+ if re.fullmatch(r'[0-9a-f]{32}', token):
+ (STATE / 'screens').mkdir(parents=True, exist_ok=True, mode=0o700)
+ start = (PROC / str(os.getpid()) / 'stat').read_text().rsplit(')', 1)[1].split()[19]
+ # Do not acquire open.lock here: the opener can be waiting for this
+ # registration while serializing another simultaneous shortcut.
+ write(STATE / 'screens' / str(os.getpid()), dict(
+ pid=os.getpid(), start=start, token=token, boot_id=BOOT_ID.read_text().strip()))
+ try:
+ yield
+ finally:
+ unregister_screen()
+
+
+def unregister_screen():
+ (STATE / 'screens' / str(os.getpid())).unlink(missing_ok=True)
+
+
+def request_for_screen():
+ request = read(STATE / 'request.json', {})
+ if not isinstance(request, dict) or 'requested_at' not in request:
+ return False
+ target = request.get('target')
+ return target is None or (isinstance(target, str) and re.fullmatch(r'[0-9a-f]{32}', target) is not None
+ and target == os.environ.get('HARNESS_UPDATE_INSTANCE'))
+
+
+def consume_request():
+ # Match and claim together: another client must not replace the request
+ # between our read and unlink. The opener uses this same handoff lock.
+ with (STATE / 'open.lock').open('a') as lock:
+ fcntl.flock(lock, fcntl.LOCK_EX)
+ if not request_for_screen():
+ return False
+ (STATE / 'request.json').unlink()
+ return True
+
+
+def close_screen():
+ # Serialize the final close decision with Super+u's request and selection.
+ # A request arriving after the last UI poll must be handled, not abandoned
+ # while this Python process is still alive in curses cleanup.
+ with (STATE / 'open.lock').open('a') as lock:
+ fcntl.flock(lock, fcntl.LOCK_EX)
+ if request_for_screen():
+ return False
+ unregister_screen()
+ return True
+
+
@contextmanager
def locked():
STATE.mkdir(parents=True, exist_ok=True, mode=0o700)
@@ -292,7 +346,7 @@ def prepared():
def notice(message):
- # Only OS configuration renders this option. No shared hn welcome/UI change.
+ # Retained for an explicitly customized footer; the OS uses hn's standard bar.
try:
run('/usr/bin/hn', 'set-option', '-g', '@harness-update', message)
except (OSError, subprocess.SubprocessError):
@@ -625,7 +679,7 @@ def update_all():
(STATE / 'approved.json').unlink(missing_ok=True)
-def screen(window, message='', refresh=False):
+def screen(window, message='', refresh=False, retry=False):
curses.curs_set(0)
window.keypad(True)
window.timeout(500)
@@ -699,9 +753,8 @@ def screen(window, message='', refresh=False):
message = str(error)
while True:
choices = draw()
- requested = STATE / 'request.json'
- if requested.exists():
- requested.unlink(missing_ok=True)
+ if consume_request() or retry:
+ retry = False
if not RESTART_REQUIRED.exists():
# The shortcut starts updating. A ready download needs no
# further network round trip; otherwise discover it now.
@@ -718,18 +771,22 @@ def screen(window, message='', refresh=False):
refresh = False
key = window.getch()
if key in (27, ord('q')):
- return
+ if close_screen():
+ return
if key in (9, curses.KEY_BTAB, curses.KEY_LEFT, curses.KEY_RIGHT):
choice = (choice + 1) % len(choices)
elif key in (10, 13, curses.KEY_ENTER):
- return choices[choice % len(choices)][1]
+ action = choices[choice % len(choices)][1]
+ if action is not None or close_screen():
+ return action
elif key == curses.KEY_MOUSE:
try:
_, x, y, _, buttons = curses.getmouse()
if buttons & (curses.BUTTON1_CLICKED | curses.BUTTON1_RELEASED):
for row, left, right, action in targets:
if y == row and left <= x < right:
- return action
+ if action is not None or close_screen():
+ return action
except curses.error:
pass
@@ -743,38 +800,24 @@ def main(argv=None):
parser.error('Open Updates as your normal user on an installed Harness system.')
STATE.mkdir(parents=True, exist_ok=True, mode=0o700)
if args.action == 'request':
- write(STATE / 'request.json', {'requested_at': time.time()})
+ target = os.environ.get('HARNESS_UPDATE_TARGET')
+ request = {'requested_at': time.time()}
+ if target is not None:
+ if not re.fullmatch(r'[0-9a-f]{32}', target):
+ raise ValueError('Invalid Updates screen target.')
+ # Private opener handoff already holds open.lock while waiting for
+ # this child. Taking it again here would deadlock startup.
+ write(STATE / 'request.json', dict(request, target=target))
+ else:
+ with (STATE / 'open.lock').open('a') as lock:
+ fcntl.flock(lock, fcntl.LOCK_EX)
+ write(STATE / 'request.json', request)
elif args.action == 'check':
check(read(args.feeds) if args.feeds else None)
finish_approved_update()
elif args.action == 'screen':
- message = ''
- # A prepared release can be applied immediately. Otherwise check now
- # instead of exposing another command or making the user wait for a timer.
- refresh = not (prepared() or system_channel().get('available'))
- while True:
- action = curses.wrapper(screen, message, refresh)
- if action is None:
- break
- message, refresh = '', action == 'check'
- try:
- if action == 'check':
- # Retry means finish updating, without another confirmation
- # after the connection or release has recovered.
- write(STATE / 'request.json', {'requested_at': time.time()})
- if action == 'reboot':
- subprocess.run(['systemctl', 'reboot'], check=True)
- break
- if action == 'update':
- print('Updating Harness… Your agents keep running.', flush=True)
- update_all()
- elif action == 'restore-system':
- subprocess.run(['sudo', '-n', '/usr/bin/harness', 'rollback'], check=True)
- (STATE / 'system.json').unlink(missing_ok=True)
- (STATE / 'approved.json').unlink(missing_ok=True)
- except (ValueError, OSError, subprocess.SubprocessError) as error:
- write(STATE / 'error.json', {'at': time.time(), 'error': str(error)})
- message = 'The update did not finish. Try again.'
+ with screen_registration():
+ run_screen()
elif args.action in ('apply', 'rollback'):
apply(rollback=args.action == 'rollback')
else:
@@ -784,6 +827,35 @@ def main(argv=None):
'system': system_channel(), 'check': read(STATE / 'check.json')}, indent=2))
+def run_screen():
+ message = ''
+ retry = False
+ # A prepared release can be applied immediately. Otherwise check now
+ # instead of exposing another command or making the user wait for a timer.
+ refresh = not (prepared() or system_channel().get('available'))
+ while True:
+ action = curses.wrapper(screen, message, refresh, retry)
+ if action is None:
+ break
+ message, refresh, retry = '', action == 'check', action == 'check'
+ try:
+ # Retry belongs to this inspection, even when a different Updates
+ # screen is open. It must not broadcast an apply request there.
+ if action == 'reboot':
+ subprocess.run(['systemctl', 'reboot'], check=True)
+ break
+ if action == 'update':
+ print('Updating Harness… Your agents keep running.', flush=True)
+ update_all()
+ elif action == 'restore-system':
+ subprocess.run(['sudo', '-n', '/usr/bin/harness', 'rollback'], check=True)
+ (STATE / 'system.json').unlink(missing_ok=True)
+ (STATE / 'approved.json').unlink(missing_ok=True)
+ except (ValueError, OSError, subprocess.SubprocessError) as error:
+ write(STATE / 'error.json', {'at': time.time(), 'error': str(error)})
+ message = 'The update did not finish. Try again.'
+
+
if __name__ == '__main__':
try:
main()
diff --git a/os/root/usr/bin/harness b/os/root/usr/bin/harness
index 9311faac2..267ce36e7 100644
--- a/os/root/usr/bin/harness
+++ b/os/root/usr/bin/harness
@@ -28,6 +28,13 @@ if [ "${1:-}" = rollback ]; then
fi
if [ "${1:-}" = updates ]; then
shift
+ if [ -t 0 ] && [ -z "${SSH_CONNECTION:-}${SSH_TTY:-}" ] &&
+ { [ "$#" = 0 ] || { [ "$#" = 1 ] && [ "$1" = screen ]; }; }; then
+ /usr/lib/harness-os/open-updates --view
+ updates_status=$?
+ # No hn client (or SSH): retain the ordinary terminal inspection.
+ [ "$updates_status" = 3 ] || exit "$updates_status"
+ fi
exec /usr/bin/python3 /usr/lib/harness-os/live_update.py "$@"
fi
. /usr/lib/harness-os/runtime-path
diff --git a/os/root/usr/lib/harness-os/open-updates b/os/root/usr/lib/harness-os/open-updates
index f828c388e..c33394156 100644
--- a/os/root/usr/lib/harness-os/open-updates
+++ b/os/root/usr/lib/harness-os/open-updates
@@ -1,5 +1,161 @@
-#!/bin/sh
-# Reuse hn's existing surface, including when the browser has focus.
-[ ! -f /etc/harness-live ] || exit 0
-harness updates request || exit
-hn select-window -t Updates 2>/dev/null || hn new-window -n Updates '/usr/bin/harness updates'
+#!/usr/bin/python3
+"""Open the live updater pane; its display name is not an ownership marker."""
+import argparse
+import fcntl
+import json
+import os
+from pathlib import Path
+import re
+import secrets
+import subprocess
+import time
+
+STATE = Path.home() / '.local/state/harness-os/updates'
+PROC = Path('/proc')
+BOOT_ID = Path('/proc/sys/kernel/random/boot_id')
+UPDATER = '/usr/lib/harness-os/live_update.py'
+OPTION = '@harness-update-instance'
+FORMAT = '#{pane_id}\t#{pane_dead}\t#{window_id}\t#{' + OPTION + '}'
+
+
+def hn(*args, socket=None):
+ target = ['-S', socket] if socket is not None else []
+ return subprocess.check_output(['/usr/bin/hn', *target, *args], text=True, timeout=5).strip()
+
+
+def process(pid):
+ """Read a Linux process identity without mistaking a reused PID for its owner."""
+ try:
+ path = PROC / str(pid)
+ fields = (path / 'stat').read_text().rsplit(')', 1)[1].split()
+ if path.stat().st_uid != os.getuid() or fields[0] in ('Z', 'X'):
+ return None
+ return {'pid': pid, 'start': fields[19], 'group': fields[2], 'foreground': fields[5]}
+ except (OSError, IndexError):
+ return None
+
+
+def registration(token, owner):
+ try:
+ record = json.loads((STATE / 'screens' / str(owner['pid'])).read_text())
+ if (record['pid'] == owner['pid'] and record['start'] == owner['start']
+ and record['token'] == token and record['boot_id'] == BOOT_ID.read_text().strip()):
+ return record
+ except (OSError, ValueError, KeyError, TypeError):
+ pass
+ return None
+
+
+def updater_process(token):
+ # Daemon-backed panes need not expose pane_pid or HN_SOCKET, and their
+ # TMUX_PANE belongs to the backend, not hn's UI namespace. The opener binds
+ # a fresh token to both the actual UI pane and the active Python process.
+ owners = []
+ for entry in (STATE / 'screens').glob('*'):
+ if not entry.name.isdigit():
+ continue
+ current = int(entry.name)
+ before = process(current)
+ if not before:
+ continue
+ path = PROC / str(current)
+ try:
+ argv = (path / 'cmdline').read_bytes().rstrip(b'\0').split(b'\0')
+ env = (path / 'environ').read_bytes().split(b'\0')
+ active = registration(token, before)
+ if (argv in ([b'/usr/bin/python3', UPDATER.encode()],
+ [b'/usr/bin/python3', UPDATER.encode(), b'screen'])
+ and active
+ and before['group'] == before['foreground']
+ and ('HARNESS_UPDATE_INSTANCE=' + token).encode() in env
+ and process(current) == before):
+ owners.append(before)
+ except (OSError, ValueError):
+ continue
+ return owners[0] if len(owners) == 1 else None
+
+
+def updater_panes(socket):
+ for line in hn('list-panes', '-s', '-F', FORMAT, socket=socket).splitlines():
+ parts = line.split('\t')
+ if len(parts) != 4:
+ continue
+ pane, dead, window, token = parts
+ if not (re.fullmatch(r'%\d+', pane) and dead == '0'
+ and re.fullmatch(r'@\d+', window) and re.fullmatch(r'[0-9a-f]{32}', token)):
+ continue
+ owner = updater_process(token)
+ if owner:
+ yield pane, window, token, owner
+
+
+def request_update(token):
+ # The caller holds open.lock until the selected UI owns this request.
+ subprocess.run(['/usr/bin/harness', 'updates', 'request'],
+ env=dict(os.environ, HARNESS_UPDATE_TARGET=token), check=True, timeout=5)
+
+
+def open_updates(view=False):
+ if view and (os.environ.get('SSH_CONNECTION') or os.environ.get('SSH_TTY')):
+ return False # Keep an SSH inspection on its own terminal.
+ STATE.mkdir(parents=True, exist_ok=True, mode=0o700)
+ # Serialize shortcut handoff, not downloads or activation. Waiting for a new
+ # pane's actual process prevents rapid shortcuts from creating duplicate tabs.
+ with (STATE / 'open.lock').open('a') as lock:
+ fcntl.flock(lock, fcntl.LOCK_EX)
+ try:
+ socket = hn('display-message', '-p', '#{socket_path}')
+ except (OSError, subprocess.SubprocessError):
+ if view:
+ return False
+ raise
+ if not socket.startswith('/'):
+ if view:
+ return False
+ raise ValueError('Harness has no active terminal. Open a terminal and try again.')
+ if view:
+ # hn can answer from a headless server restored for stored sessions.
+ # Its own client row is empty; do not send manual inspection into
+ # an invisible pane or use another client's row via list fanout.
+ try:
+ client = hn('hn-list-clients', '-F', '#{client_tty}', socket=socket)
+ except (OSError, subprocess.SubprocessError):
+ return False
+ if not client.startswith('/dev/') or '\n' in client:
+ return False
+ for pane, window, token, owner in updater_panes(socket):
+ if not view:
+ request_update(token)
+ try:
+ hn('select-window', '-t', window, socket=socket)
+ hn('select-pane', '-t', pane, socket=socket)
+ except subprocess.CalledProcessError:
+ continue # The old pane can finish closing during selection.
+ if (pane, window, token, owner) in updater_panes(socket):
+ return True
+ token = secrets.token_hex(16)
+ if not view:
+ request_update(token)
+ pane = hn('new-window', '-P', '-F', '#{pane_id}', '-n', 'Updates',
+ 'exec env HARNESS_UPDATE_INSTANCE=' + token + ' /usr/bin/python3 ' + UPDATER + ' screen', socket=socket)
+ if not re.fullmatch(r'%\d+', pane):
+ raise ValueError('The Updates pane did not open.')
+ hn('set-option', '-p', '-t', pane, OPTION, token, socket=socket)
+ deadline = time.monotonic() + 5
+ while time.monotonic() < deadline:
+ if any(item[0] == pane and item[2] == token for item in updater_panes(socket)):
+ return True
+ time.sleep(.05)
+ raise ValueError('The Updates screen did not start. Press Super+u to try again.')
+
+
+if __name__ == '__main__':
+ parser = argparse.ArgumentParser(description=__doc__)
+ parser.add_argument('--view', action='store_true', help='Inspect without requesting an update')
+ args = parser.parse_args()
+ if Path('/etc/harness-live').exists() or (args.view and os.geteuid() == 0):
+ raise SystemExit(3 if args.view else 0)
+ try:
+ raise SystemExit(0 if open_updates(view=args.view) else 3)
+ except (ValueError, OSError, subprocess.SubprocessError) as error:
+ raise SystemExit('Harness updates: ' + str(error))
diff --git a/os/tests/test_live_update.py b/os/tests/test_live_update.py
index c1e6a0900..a356733b2 100644
--- a/os/tests/test_live_update.py
+++ b/os/tests/test_live_update.py
@@ -4,6 +4,7 @@ import fcntl
import importlib.util
import io
import json
+import os
from pathlib import Path
import struct
import subprocess
@@ -372,7 +373,7 @@ class FastUpdates(unittest.TestCase):
update.prune()
self.assertTrue(old_runtime.is_dir())
- def show(self, keys, mouse=None, refresh=False):
+ def show(self, keys, mouse=None, refresh=False, retry=False):
class Window:
def __init__(self): self.drawn, self.keys = [], iter(keys)
def keypad(self, _): pass
@@ -389,7 +390,7 @@ class FastUpdates(unittest.TestCase):
with patch.object(update.curses, 'curs_set'), patch.object(update.curses, 'has_colors', return_value=False), \
patch.object(update.curses, 'mousemask'), patch.object(update.curses, 'mouseinterval'), \
patch.object(update.curses, 'getmouse', side_effect=event):
- return update.screen(window, refresh=refresh)
+ return update.screen(window, refresh=refresh, retry=retry)
def test_update_button_click_and_keyboard_use_the_same_action_without_a_confirmation(self):
with self.feed(): update.check()
@@ -405,6 +406,111 @@ class FastUpdates(unittest.TestCase):
self.assertEqual(self.show([]), 'update')
self.assertFalse((self.state / 'request.json').exists())
+ def test_targeted_request_is_inert_in_other_owned_or_direct_inspection(self):
+ with self.feed(): update.check()
+ request = dict(requested_at=1, target='a' * 32)
+ update.write(self.state / 'request.json', request)
+ for env in [{}, {'HARNESS_UPDATE_INSTANCE': 'b' * 32}]:
+ with self.subTest(env=env), patch.dict(os.environ, env, clear=True):
+ self.assertIsNone(self.show([27]))
+ self.assertEqual(update.read(self.state / 'request.json'), request)
+ with patch.dict(os.environ, {'HARNESS_UPDATE_INSTANCE': 'a' * 32}, clear=True):
+ self.assertEqual(self.show([]), 'update')
+ self.assertFalse((self.state / 'request.json').exists())
+
+ def test_request_claim_holds_handoff_lock_through_match_and_unlink(self):
+ from concurrent.futures import ThreadPoolExecutor
+ import threading
+ self.state.mkdir()
+ first, second = dict(requested_at=1, target='a' * 32), dict(requested_at=2, target='b' * 32)
+ update.write(self.state / 'request.json', first)
+ matched, publishing, published = threading.Event(), threading.Event(), threading.Event()
+ predicate = update.request_for_screen
+ def match():
+ result = predicate()
+ matched.set()
+ self.assertTrue(publishing.wait(timeout=2))
+ self.assertFalse(published.is_set())
+ return result
+ def publish():
+ self.assertTrue(matched.wait(timeout=2))
+ with (self.state / 'open.lock').open('a') as lock:
+ publishing.set()
+ fcntl.flock(lock, fcntl.LOCK_EX)
+ update.write(self.state / 'request.json', second)
+ published.set()
+ with (patch.dict(os.environ, {'HARNESS_UPDATE_INSTANCE': 'a' * 32}, clear=True),
+ patch.object(update, 'request_for_screen', side_effect=match),
+ ThreadPoolExecutor(max_workers=1) as pool):
+ future = pool.submit(publish)
+ self.assertTrue(update.consume_request())
+ future.result(timeout=2)
+ self.assertEqual(update.read(self.state / 'request.json'), second)
+
+ def test_explicit_request_stays_compatible_and_private_target_is_validated(self):
+ with patch.object(update.os, 'geteuid', return_value=1000), patch.dict(os.environ, {}, clear=True):
+ update.main(['request'])
+ self.assertEqual(set(update.read(self.state / 'request.json')), {'requested_at'})
+ with patch.dict(os.environ, {'HARNESS_UPDATE_TARGET': 'c' * 32}):
+ update.main(['request'])
+ self.assertEqual(update.read(self.state / 'request.json')['target'], 'c' * 32)
+ with patch.dict(os.environ, {'HARNESS_UPDATE_TARGET': 'invalid'}), self.assertRaisesRegex(ValueError, 'target'):
+ update.main(['request'])
+ self.assertEqual(update.read(self.state / 'request.json')['target'], 'c' * 32)
+
+ def test_shortcut_after_last_poll_prevents_close_and_needs_no_second_key(self):
+ with self.feed(): update.check()
+ def keys():
+ # The screen has polled request.json already. Super+u arrives just
+ # before an older Escape is handled, while the process is alive.
+ update.write(self.state / 'request.json', dict(requested_at=2, target='a' * 32))
+ yield 27
+ self.fail('The pending shortcut needed another key')
+ with patch.dict(os.environ, {'HARNESS_UPDATE_INSTANCE': 'a' * 32}, clear=True):
+ self.assertEqual(self.show(keys()), 'update')
+ self.assertFalse((self.state / 'request.json').exists())
+
+ def test_screen_registration_ends_before_close_returns_even_if_process_is_alive(self):
+ proc = self.root / 'proc'
+ pid = os.getpid()
+ (proc / str(pid)).mkdir(parents=True)
+ (proc / str(pid) / 'stat').write_text(f'{pid} (python) ' + ' '.join(['S'] + ['0'] * 18 + ['123']))
+ with (patch.object(update, 'PROC', proc),
+ patch.dict(os.environ, {'HARNESS_UPDATE_INSTANCE': 'a' * 32}, clear=True)):
+ with update.screen_registration():
+ record = update.read(self.state / 'screens' / str(pid))
+ self.assertEqual(record, dict(pid=pid, start='123', token='a' * 32, boot_id='first-boot'))
+ self.assertTrue(update.close_screen())
+ self.assertFalse((self.state / 'screens' / str(pid)).exists())
+ self.assertEqual(os.getpid(), pid) # Still before context/process cleanup.
+
+ def test_unowned_terminal_screen_does_not_register_a_backend_pane_as_ui_identity(self):
+ with patch.dict(os.environ, {'TMUX_PANE': '%7', 'HN_SOCKET': '/tmp/hn/default.sock'}, clear=True):
+ with update.screen_registration():
+ self.assertFalse((self.state / 'screens' / str(os.getpid())).exists())
+
+ def test_close_waits_for_shortcut_handoff_then_preserves_its_pending_intent(self):
+ from concurrent.futures import ThreadPoolExecutor
+ import threading
+ self.state.mkdir()
+ marker = self.state / 'screens' / str(os.getpid())
+ marker.parent.mkdir()
+ marker.write_text('{}')
+ entering = threading.Event()
+ def close():
+ entering.set()
+ return update.close_screen()
+ with (self.state / 'open.lock').open('a') as lock, ThreadPoolExecutor(max_workers=1) as pool:
+ fcntl.flock(lock, fcntl.LOCK_EX)
+ future = pool.submit(close)
+ self.assertTrue(entering.wait(timeout=2))
+ update.write(self.state / 'request.json', {'requested_at': 3})
+ self.assertFalse(future.done())
+ fcntl.flock(lock, fcntl.LOCK_UN)
+ self.assertFalse(future.result(timeout=2))
+ self.assertTrue(marker.exists())
+ self.assertTrue((self.state / 'request.json').exists())
+
def test_restart_is_never_the_default_action_or_triggered_by_update_shortcut(self):
self.state.mkdir()
update.RESTART_REQUIRED.write_text('{"status":"ready"}')
@@ -458,14 +564,18 @@ class FastUpdates(unittest.TestCase):
self.assertIsNone(self.show([10], refresh=True))
self.assertFalse((self.state / 'approved.json').exists())
- def test_retry_keeps_the_request_so_recovered_downloads_apply_without_another_key(self):
- with patch.object(update.os, 'geteuid', return_value=1000), \
- patch.object(update.curses, 'wrapper', side_effect=['check', None]):
+ def test_manual_retry_stays_local_and_applies_recovered_download_without_another_key(self):
+ self.state.mkdir()
+ other = dict(requested_at=1, target='b' * 32)
+ update.write(self.state / 'request.json', other)
+ with patch.dict(os.environ, {}, clear=True), patch.object(update.os, 'geteuid', return_value=1000), \
+ patch.object(update.curses, 'wrapper', side_effect=['check', None]) as wrapper:
update.main(['screen'])
- self.assertTrue((self.state / 'request.json').exists())
- with self.feed():
- self.assertEqual(self.show([], refresh=True), 'update')
- self.assertFalse((self.state / 'request.json').exists())
+ self.assertTrue(wrapper.call_args_list[1].args[3])
+ self.assertEqual(update.read(self.state / 'request.json'), other)
+ with self.feed(), patch.dict(os.environ, {}, clear=True):
+ self.assertEqual(self.show([], refresh=True, retry=True), 'update')
+ self.assertEqual(update.read(self.state / 'request.json'), other)
class RuntimeArchitecture(unittest.TestCase):
diff --git a/os/tests/test_open_updates.py b/os/tests/test_open_updates.py
new file mode 100644
index 000000000..e29eeef9b
--- /dev/null
+++ b/os/tests/test_open_updates.py
@@ -0,0 +1,323 @@
+import importlib.machinery
+import importlib.util
+import json
+import os
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+import shutil
+import subprocess
+import tempfile
+import threading
+import unittest
+from unittest.mock import patch
+
+SOURCE = Path(__file__).resolve().parents[1] / 'root/usr/lib/harness-os/open-updates'
+loader = importlib.machinery.SourceFileLoader('open_updates', str(SOURCE))
+spec = importlib.util.spec_from_loader(loader.name, loader)
+updates = importlib.util.module_from_spec(spec)
+loader.exec_module(updates)
+SOCKET = '/run/user/1000/hn/default.sock'
+TOKEN, NEW_TOKEN = 'a' * 32, 'b' * 32
+
+
+class UpdatePaneOwnership(unittest.TestCase):
+ def setUp(self):
+ temporary = tempfile.TemporaryDirectory()
+ self.addCleanup(temporary.cleanup)
+ self.root = Path(temporary.name)
+ self.proc = self.root / 'proc'
+ self.rows, self.commands, self.targets = [], [], []
+ self.attached = True
+ self.boot_id = self.root / 'boot-id'
+ self.boot_id.write_text('first-boot')
+ for value in [patch.object(updates, 'PROC', self.proc),
+ patch.object(updates, 'BOOT_ID', self.boot_id),
+ patch.object(updates, 'STATE', self.root / 'state'),
+ patch.object(updates, 'hn', side_effect=self.hn),
+ patch.object(updates.secrets, 'token_hex', return_value=NEW_TOKEN),
+ patch.dict(os.environ, {}, clear=True),
+ patch.object(updates.subprocess, 'run')]:
+ value.start()
+ self.addCleanup(value.stop)
+ self.request = updates.subprocess.run
+
+ def process(self, pid, *, token=TOKEN, group=10, foreground=10,
+ command=None, state='S', start=123, active=True):
+ path = self.proc / str(pid)
+ path.mkdir(parents=True, exist_ok=True)
+ fields = [state, '1', str(group), '10', '34816', str(foreground)] + ['0'] * 13 + [str(start)]
+ (path / 'stat').write_text(f'{pid} (a test (process)) ' + ' '.join(fields))
+ argv = command if command is not None else ['/usr/bin/python3', updates.UPDATER, 'screen']
+ (path / 'cmdline').write_bytes(b'\0'.join(word.encode() for word in argv) + b'\0')
+ # Shipped daemon-backed panes have a backend TMUX_PANE and no HN_SOCKET.
+ # Neither value may be used as the UI's pane/process mapping.
+ (path / 'environ').write_bytes(('TMUX_PANE=%999\0HARNESS_UPDATE_INSTANCE=' + token + '\0').encode())
+ screens = updates.STATE / 'screens'
+ screens.mkdir(parents=True, exist_ok=True)
+ if active:
+ (screens / str(pid)).write_text(json.dumps(dict(
+ pid=pid, start=str(start), token=token, boot_id='first-boot')))
+ else:
+ (screens / str(pid)).unlink(missing_ok=True)
+
+ def pane(self, pane='%1', dead='0', window='@1', token=TOKEN):
+ self.rows.append('\t'.join([pane, dead, window, token]))
+
+ def hn(self, *args, socket=None):
+ self.commands.append(args)
+ self.targets.append((args, socket))
+ if args == ('display-message', '-p', '#{socket_path}'):
+ self.assertIsNone(socket)
+ return SOCKET
+ self.assertEqual(socket, SOCKET)
+ if args[0] == 'hn-list-clients':
+ self.assertEqual(args, ('hn-list-clients', '-F', '#{client_tty}'))
+ return '/dev/pts/7' if self.attached else ''
+ if args[0] == 'list-panes':
+ self.assertEqual(args, ('list-panes', '-s', '-F', updates.FORMAT))
+ return '\n'.join(self.rows)
+ if args[0] == 'new-window':
+ self.assertEqual(args, ('new-window', '-P', '-F', '#{pane_id}', '-n', 'Updates',
+ 'exec env HARNESS_UPDATE_INSTANCE=' + NEW_TOKEN + ' /usr/bin/python3 ' + updates.UPDATER + ' screen'))
+ self.pane('%9', window='@9', token='')
+ self.process(900, token=NEW_TOKEN)
+ return '%9'
+ if args[0] == 'set-option':
+ self.assertEqual(args, ('set-option', '-p', '-t', '%9', updates.OPTION, NEW_TOKEN))
+ self.rows = [line.rsplit('\t', 1)[0] + '\t' + NEW_TOKEN if line.startswith('%9\t') else line for line in self.rows]
+ return ''
+ self.assertIn(args[0], ['select-window', 'select-pane'])
+ return ''
+
+ def assert_created_once(self):
+ self.assertEqual(sum(item[0] == 'new-window' for item in self.commands), 1)
+ self.assertNotIn(('select-window', '-t', 'Updates'), self.commands)
+
+ def test_an_unrelated_named_shell_cannot_swallow_the_request(self):
+ self.pane(token='')
+ self.process(100, command=['/bin/bash'])
+ updates.open_updates()
+ self.assert_created_once()
+ self.assertNotIn(('select-window', '-t', '@1'), self.commands)
+ self.request.assert_called_once_with(['/usr/bin/harness', 'updates', 'request'],
+ env={'HARNESS_UPDATE_TARGET': NEW_TOKEN}, check=True, timeout=5)
+
+ def test_daemon_backed_owner_is_reused_without_backend_pid_or_socket_fields(self):
+ self.pane()
+ self.process(100)
+ updates.open_updates()
+ self.assertIn(('select-window', '-t', '@1'), self.commands)
+ self.assertIn(('select-pane', '-t', '%1'), self.commands)
+ self.assertFalse(any(item[0] == 'new-window' for item in self.commands))
+ self.assertEqual(self.request.call_args.kwargs['env']['HARNESS_UPDATE_TARGET'], TOKEN)
+
+ def test_manual_view_creates_no_request_and_next_shortcut_reuses_its_owner(self):
+ self.assertTrue(updates.open_updates(view=True))
+ self.request.assert_not_called()
+ updates.open_updates()
+ self.assert_created_once()
+ self.request.assert_called_once()
+ self.assertIn(('select-pane', '-t', '%9'), self.commands)
+
+ def test_missing_dead_zombie_background_foreign_and_unregistered_are_not_reused(self):
+ for case in ['missing', 'dead', 'zombie', 'background', 'token-mismatch', 'check', 'different-script', 'closed-screen']:
+ with self.subTest(case=case):
+ self.rows, self.commands = [], []
+ shutil.rmtree(self.proc, ignore_errors=True)
+ shutil.rmtree(updates.STATE, ignore_errors=True)
+ self.pane(dead='1' if case == 'dead' else '0')
+ if case != 'missing':
+ self.process(100, state='Z' if case == 'zombie' else 'S',
+ foreground=20 if case == 'background' else 10,
+ token='c' * 32 if case == 'token-mismatch' else TOKEN,
+ active=case != 'closed-screen',
+ command=['/usr/bin/python3', updates.UPDATER, 'check'] if case == 'check' else
+ ['/usr/bin/python3', '/tmp/live_update.py'] if case == 'different-script' else None)
+ updates.open_updates()
+ self.assert_created_once()
+ self.assertNotIn(('select-window', '-t', '@1'), self.commands)
+
+ def test_registration_must_match_process_environment_not_just_custom_option(self):
+ self.pane()
+ self.process(100)
+ (self.proc / '100/environ').write_bytes(b'TMUX_PANE=%1\0')
+ updates.open_updates()
+ self.assert_created_once()
+
+ def test_ambiguous_duplicate_process_token_is_not_reused(self):
+ self.pane()
+ self.process(100)
+ self.process(101)
+ updates.open_updates()
+ self.assert_created_once()
+
+ def test_exit_pid_reuse_pane_removal_or_marker_change_during_selection_creates_new_owner(self):
+ for case in ['exit', 'pid-reuse', 'pane-removed', 'token-removed']:
+ with self.subTest(case=case):
+ self.rows, self.commands = [], []
+ shutil.rmtree(self.proc, ignore_errors=True)
+ shutil.rmtree(updates.STATE, ignore_errors=True)
+ self.pane()
+ self.process(100)
+ def select(*args, **kwargs):
+ result = self.hn(*args, **kwargs)
+ if args[0] == 'select-pane':
+ if case == 'pid-reuse':
+ self.process(100, start=456)
+ elif case == 'token-removed':
+ self.rows = ['%1\t0\t@1\t']
+ else:
+ shutil.rmtree(self.proc / '100')
+ if case == 'pane-removed':
+ raise subprocess.CalledProcessError(1, 'hn')
+ return result
+ with patch.object(updates, 'hn', side_effect=select):
+ updates.open_updates()
+ self.assert_created_once()
+
+ def test_rapid_shortcuts_wait_for_new_registration_and_reuse_one_pane(self):
+ ready = threading.Barrier(2)
+ queries = 0
+ def delayed(*args, **kwargs):
+ nonlocal queries
+ result = self.hn(*args, **kwargs)
+ if args[0] == 'list-panes':
+ queries += 1
+ if queries < 4:
+ return ''
+ return result
+ def shortcut():
+ ready.wait(timeout=2)
+ updates.open_updates()
+ with patch.object(updates, 'hn', side_effect=delayed), ThreadPoolExecutor(max_workers=2) as pool:
+ futures = [pool.submit(shortcut) for _ in range(2)]
+ for future in futures:
+ future.result(timeout=3)
+ self.assert_created_once()
+ self.assertEqual(self.request.call_count, 2)
+ self.assertIn(('select-pane', '-t', '%9'), self.commands)
+
+ def test_failed_request_never_switches_or_creates_a_pane(self):
+ self.request.side_effect = subprocess.CalledProcessError(1, 'harness')
+ with self.assertRaises(subprocess.CalledProcessError):
+ updates.open_updates()
+ self.assertTrue(self.commands) # Discover an owner before targeting it.
+ self.assertFalse(any(args[0] in ['select-window', 'select-pane', 'new-window'] for args in self.commands))
+
+ def test_startup_failure_is_bounded_and_does_not_create_more_panes(self):
+ def never_starts(*args, **kwargs):
+ result = self.hn(*args, **kwargs)
+ return '' if args[0] == 'list-panes' else result
+ with (patch.object(updates, 'hn', side_effect=never_starts),
+ patch.object(updates.time, 'monotonic', side_effect=[0, 6]),
+ self.assertRaisesRegex(ValueError, 'did not start')):
+ updates.open_updates()
+ self.assert_created_once()
+
+ def test_targeting_stays_pinned_if_default_client_changes_after_discovery(self):
+ self.pane()
+ self.process(100)
+ updates.open_updates()
+ self.assertEqual([args for args, socket in self.targets if socket is None],
+ [('display-message', '-p', '#{socket_path}')])
+ self.assertIn((('select-window', '-t', '@1'), SOCKET), self.targets)
+
+ def test_registration_from_earlier_boot_or_reused_pid_is_not_an_owner(self):
+ for key, value in [('boot_id', 'earlier-boot'), ('start', 'earlier-process')]:
+ with self.subTest(key=key):
+ self.rows, self.commands = [], []
+ shutil.rmtree(self.proc, ignore_errors=True)
+ shutil.rmtree(updates.STATE, ignore_errors=True)
+ self.pane()
+ self.process(100)
+ path = updates.STATE / 'screens/100'
+ record = json.loads(path.read_text())
+ record[key] = value
+ path.write_text(json.dumps(record))
+ updates.open_updates()
+ self.assert_created_once()
+
+ def test_ssh_view_and_missing_client_fall_back_without_creating_request(self):
+ with patch.dict(os.environ, {'SSH_CONNECTION': 'example'}):
+ self.assertFalse(updates.open_updates(view=True))
+ self.assertEqual(self.commands, [])
+ with patch.object(updates, 'hn', side_effect=subprocess.CalledProcessError(1, 'hn')):
+ self.assertFalse(updates.open_updates(view=True))
+ self.request.assert_not_called()
+
+ def test_valid_headless_socket_keeps_view_in_the_current_terminal(self):
+ self.attached = False
+ self.pane()
+ self.process(100)
+ self.assertFalse(updates.open_updates(view=True))
+ self.request.assert_not_called()
+ self.assertEqual(self.targets, [
+ (('display-message', '-p', '#{socket_path}'), None),
+ (('hn-list-clients', '-F', '#{client_tty}'), SOCKET)])
+
+
+class UpdateEntryPoints(unittest.TestCase):
+ def setUp(self):
+ temporary = tempfile.TemporaryDirectory()
+ self.addCleanup(temporary.cleanup)
+ self.root = Path(temporary.name)
+ self.opener, self.python = self.root / 'opener', self.root / 'python'
+ self.opener.write_text('#!/bin/sh\nprintf "%s\\n" "$@" > "$OPENER_LOG"\nexit "$OPENER_EXIT"\n')
+ self.python.write_text('#!/bin/sh\nprintf "%s\\n" "$@" > "$PYTHON_LOG"\n')
+ self.opener.chmod(0o755)
+ self.python.chmod(0o755)
+ self.wrapper = self.root / 'harness'
+ source = SOURCE.parents[2] / 'bin/harness'
+ self.wrapper.write_text(source.read_text().replace('/usr/lib/harness-os/open-updates', str(self.opener))
+ .replace('/usr/bin/python3', str(self.python)))
+ self.env = dict(os.environ, OPENER_LOG=str(self.root / 'opener.log'),
+ PYTHON_LOG=str(self.root / 'python.log'), OPENER_EXIT='0')
+ self.env.pop('SSH_CONNECTION', None)
+ self.env.pop('SSH_TTY', None)
+
+ def run_wrapper(self, *args, interactive=True):
+ master, slave = os.openpty()
+ try:
+ result = subprocess.run(['/bin/sh', str(self.wrapper), 'updates', *args],
+ stdin=slave if interactive else subprocess.DEVNULL,
+ capture_output=True, env=self.env, timeout=5)
+ finally:
+ os.close(master)
+ os.close(slave)
+ return result
+
+ def test_plain_and_screen_inspection_use_view_without_request(self):
+ for args in [(), ('screen',)]:
+ with self.subTest(args=args):
+ self.assertEqual(self.run_wrapper(*args).returncode, 0)
+ self.assertEqual((self.root / 'opener.log').read_text(), '--view\n')
+ self.assertFalse((self.root / 'python.log').exists())
+
+ def test_no_client_preserves_current_terminal_but_other_failure_does_not_duplicate_ui(self):
+ self.env['OPENER_EXIT'] = '3'
+ self.assertEqual(self.run_wrapper('screen').returncode, 0)
+ self.assertEqual((self.root / 'python.log').read_text(), '/usr/lib/harness-os/live_update.py\nscreen\n')
+ (self.root / 'python.log').unlink()
+ self.env['OPENER_EXIT'] = '1'
+ self.assertEqual(self.run_wrapper().returncode, 1)
+ self.assertFalse((self.root / 'python.log').exists())
+
+ def test_ssh_and_noninteractive_inspection_stays_in_current_terminal(self):
+ for ssh in [False, True]:
+ with self.subTest(ssh=ssh):
+ if ssh:
+ self.env['SSH_CONNECTION'] = 'client server'
+ self.assertEqual(self.run_wrapper(interactive=ssh).returncode, 0)
+ self.assertFalse((self.root / 'opener.log').exists())
+ self.assertEqual((self.root / 'python.log').read_text(), '/usr/lib/harness-os/live_update.py\n')
+
+ def test_other_actions_and_explicit_developer_arguments_are_forwarded_unchanged(self):
+ for args in [('check',), ('request',), ('apply',), ('rollback',), ('status',), ('screen', '--feeds', '/tmp/developer.json')]:
+ with self.subTest(args=args):
+ self.assertEqual(self.run_wrapper(*args).returncode, 0)
+ self.assertFalse((self.root / 'opener.log').exists())
+ self.assertEqual((self.root / 'python.log').read_text(), '/usr/lib/harness-os/live_update.py\n' + '\n'.join(args) + '\n')
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/os/tests/update_context_vm.py b/os/tests/update_context_vm.py
new file mode 100644
index 000000000..fdac05ea8
--- /dev/null
+++ b/os/tests/update_context_vm.py
@@ -0,0 +1,194 @@
+#!/usr/bin/env python3
+"""Observe the shipped daemon-backed pane namespace in one private live VM."""
+import argparse
+import hashlib
+import json
+import os
+from pathlib import Path
+import shlex
+import signal
+import subprocess
+import time
+from unittest.mock import patch
+from footprint_vm import copy_file
+from hardware_install_vm import candidate_record, digest
+from vm import VM
+
+TOKEN = 'owned-context-observation'
+FORMAT = '#{pane_id}\t#{pane_pid}\t#{pane_tty}\t#{pane_start_command}\t#{socket_path}\t#{@harness-update-context}'
+FIELDS = ['pane', 'pid', 'tty', 'start_command', 'socket', 'custom_option']
+IMAGE_SOURCE = 'b6cbaf3e3090f43106ad1ee47606349bd1a0ae89'
+IMAGE_SHA256 = 'fa4f282644ac81e9e3b7de55276edd7dc08405e50875da544dc7f9fd6d50ba12'
+IMAGE_BYTES = 2007023616
+RUNTIME_SHA256 = {
+ 'harness-tui': 'bd221059a24d7f7ca8ce69bb3b6d69c2fb66cb655aae6658627c278a548a8fa8',
+ 'cli.mjs': '23b46a7c498fd1ef8ff5936aeb431f1de08b959b957141fa732d2cede870d147',
+ 'notify.mjs': '5690159e964f9ce022bdb2a5e4bc9d853e595e822f254478df241e1386dde68e',
+}
+PROCESS = '''import json,os,sys,time
+from pathlib import Path
+def read_process(pid):
+ root=Path('/proc')/str(pid)
+ fields=(root/'stat').read_text().rsplit(')',1)[1].split()
+ env=dict(item.split('=',1) for item in (root/'environ').read_bytes().decode().split('\\0') if '=' in item)
+ return dict(pid=int(pid),start=fields[19],state=fields[0],group=fields[2],foreground=fields[5],
+ stdin=str((root/'fd/0').readlink()),argv=(root/'cmdline').read_bytes().rstrip(b'\\0').decode().split('\\0'),
+ env={k:env.get(k) for k in ['TMUX','TMUX_PANE','HN_SOCKET','HN_SOCKET_NAME','HARNESS_OS',
+ 'HARNESS_TUI_BIN','MACHINE_ID','HARNESS_AGENT_ID','AGENT_ID','PORT','HARNESS_UPDATE_INSTANCE']})
+if len(sys.argv)>1:
+ records=[]
+ for p in Path('/proc').iterdir():
+ if not p.name.isdigit():continue
+ try:
+ if p.stat().st_uid!=os.getuid():continue
+ argv=(p/'cmdline').read_bytes().rstrip(b'\\0').decode().split('\\0')
+ if argv==['/usr/bin/python3','/usr/lib/harness-os/live_update.py'] or (
+ argv==['python3','/tmp/update-context.py']):records.append(read_process(p.name))
+ except (FileNotFoundError,ProcessLookupError):continue
+ Path('/tmp/update-context-snapshot.json').write_text(json.dumps(records,indent=2)+'\\n')
+else:
+ Path('/tmp/update-context-owner.json').write_text(json.dumps(read_process(os.getpid()),indent=2)+'\\n')
+ print('Harness updater context observation',flush=True)
+ time.sleep(180)
+'''
+
+
+def main():
+ parser = argparse.ArgumentParser(description=__doc__)
+ parser.add_argument('--iso', type=Path, required=True)
+ parser.add_argument('--output', type=Path, default=Path('os/test-results/update-context'))
+ args = parser.parse_args()
+ assert os.access('/dev/kvm', os.R_OK | os.W_OK), 'Native x86 KVM is required'
+ iso = args.iso.resolve()
+ manifest = json.loads(iso.with_name('manifest.json').read_text())
+ assert manifest['source_commit'] == manifest['harness_inputs']['source_commit'] == IMAGE_SOURCE
+ assert manifest['iso']['sha256'] == digest(iso) == IMAGE_SHA256
+ assert manifest['iso']['bytes'] == iso.stat().st_size == IMAGE_BYTES
+ assert {name: info['sha256'] for name, info in manifest['harness_inputs']['files'].items()} == RUNTIME_SHA256
+ folder = args.output.resolve()
+ folder.mkdir(parents=True, exist_ok=False)
+ receipt = dict(status='running', started_at=time.time(), budget_seconds=300,
+ image_manifest=manifest, observer=candidate_record(Path(__file__)),
+ helpers={name:candidate_record(Path(__file__).with_name(name)) for name in [
+ 'vm.py', 'footprint_vm.py', 'hardware_install_vm.py']},
+ process_observer_sha256=hashlib.sha256(PROCESS.encode()).hexdigest(),
+ firmware='bios', cpu='Nehalem', memory_mib=2048, commands=[],
+ scope='Live overlay only: stop installer, clear live marker and start packaged daemon/hn. No installation, candidate product overlay, update activation or runtime build.',
+ limitations=['Runtime namespace observation, not ownership acceptance or physical hardware validation.'])
+ vm = VM(folder, iso, 'bios', 2048, cpu='Nehalem')
+
+ def save():
+ (folder / 'receipt.json').write_text(json.dumps(receipt, indent=2) + '\n')
+
+ def user(command):
+ # runuser retains the serial root shell's cwd; new panes need me's home.
+ return 'runuser -u me -- env XDG_RUNTIME_DIR=/run/user/1000 DBUS_SESSION_BUS_ADDRESS=unix:path=/run/user/1000/bus sh -c ' + shlex.quote('cd /home/me && ' + command)
+
+ def record(name, command, timeout=45, check=True):
+ output, status = vm.command(command, timeout=timeout, check=False)
+ (folder / (name + '.txt')).write_text(output)
+ receipt['commands'].append(dict(name=name, command=command, status=status))
+ save()
+ assert not check or status == 0, (name, status, output[-2000:])
+ return output
+
+ def snapshot(name):
+ record(name, user('python3 /tmp/update-context.py snapshot'))
+ data = vm.read_file('/tmp/update-context-snapshot.json')
+ (folder / (name + '.json')).write_bytes(data)
+ return json.loads(data)
+
+ def pane_format(name, pane):
+ record(name, user('hn display-message -p -t ' + shlex.quote(pane) + ' ' +
+ shlex.quote(FORMAT) + ' > /tmp/update-context-format'), check=False)
+ data = vm.read_file('/tmp/update-context-format')
+ (folder / (name + '.tsv')).write_bytes(data)
+ values = data.decode().rstrip('\r\n').split('\t')
+ result = dict(raw=data.decode(), fields=dict(zip(FIELDS, values)) if len(values) == len(FIELDS) else None)
+ receipt[name] = result
+ save()
+ return result
+
+ def deadline(*_):
+ raise TimeoutError('300-second live context observation budget expired')
+
+ real_popen = subprocess.Popen
+
+ def restricted(command, *argv, **kwargs):
+ if isinstance(command, list) and command[0] == 'qemu-system-x86_64':
+ command = list(command)
+ command[command.index('user,id=net')] = 'user,id=net,restrict=on'
+ receipt['qemu_command'] = command
+ return real_popen(command, *argv, **kwargs)
+
+ try:
+ signal.signal(signal.SIGALRM, deadline)
+ signal.alarm(300)
+ with patch('subprocess.Popen', restricted):
+ vm.start(live=True)
+ receipt['acceleration'] = vm.acceleration
+ assert vm.acceleration == 'kvm'
+ vm.wait(r'root@[^\r\n]*[#] ', timeout=110)
+ vm.shell_ready = True
+ vm.command('stty -echo')
+ checksums = ''.join(info['sha256'] + ' /usr/lib/harness/' + name + '\n'
+ for name, info in manifest['harness_inputs']['files'].items())
+ record('01-frozen-runtime', 'printf %s ' + shlex.quote(checksums) + ' | sha256sum -c -')
+ record('01-host-identity', 'uname -n > /tmp/context-hostname && uname -a > /tmp/context-kernel && ' +
+ user('hn -V > /tmp/context-client-version'))
+ receipt['guest'] = {key: vm.read_file('/tmp/context-' + key).decode().strip()
+ for key in ['hostname', 'kernel', 'client-version']}
+ paths = ['/usr/bin/harness', '/usr/lib/harness-os/live_update.py', '/usr/lib/harness-os/open-updates']
+ receipt['packaged_files'] = {path:hashlib.sha256(vm.read_file(path)).hexdigest() for path in paths}
+ record('02-live-session-ready', user('timeout 30 sh -c ' + shlex.quote(
+ 'until systemctl --user is-active --quiet harness-install.service 2>/dev/null && '
+ 'pgrep -u 1000 -x labwc >/dev/null; do sleep .2; done')), timeout=35)
+ record('02-private-session', user('systemctl --user stop harness-install.service harness-update.timer harness-update.service') +
+ ' && rm /etc/harness-live && ' + user('mkdir -p ~/.local/state/harness-os ~/projects; touch ~/.local/state/harness-os/onboarded; systemctl --user start harness-daemon.service hn-screen.service'), timeout=100)
+ record('03-runtime-ready', user('/usr/lib/harness-os/wait-runtime && hn list-panes -s -F ' + shlex.quote(FORMAT)), timeout=45)
+ copy_file(vm, PROCESS.encode(), '/tmp/update-context.py')
+ record('04-create-pane', user("hn new-window -P -F '#{pane_id}' -n Observation " +
+ shlex.quote('env HARNESS_UPDATE_INSTANCE=' + TOKEN + ' python3 /tmp/update-context.py') + ' > /tmp/update-context-pane'))
+ record('05-await-process', "timeout 20 sh -c 'until test -s /tmp/update-context-owner.json; do sleep .1; done'", timeout=25)
+ pane = vm.read_file('/tmp/update-context-pane').decode().strip()
+ before = json.loads(vm.read_file('/tmp/update-context-owner.json'))
+ receipt.update(pane=pane, original_process=before)
+ assert pane.startswith('%') and pane[1:].isdigit(), pane
+ assert before['env']['HARNESS_UPDATE_INSTANCE'] == TOKEN
+ record('06-custom-option', user('hn set-option -p -t ' + shlex.quote(pane) + ' @harness-update-context ' + TOKEN), check=False)
+ receipt['custom_option_status'] = receipt['commands'][-1]['status']
+ pane_format('07-format-before', pane)
+ record('08-manual-view', user("test ! -e ~/.local/state/harness-os/updates/request.json && hn new-window -n Manual '/usr/bin/harness updates'"))
+ record('09-manual-started', 'timeout 15 sh -c ' + shlex.quote(
+ "until pgrep -u 1000 -f '^/usr/bin/python3.*live_update.py' >/dev/null; do sleep .1; done"), timeout=20)
+ snapshot('10-processes-before')
+ record('11-no-apply-request', user('test ! -e ~/.local/state/harness-os/updates/request.json'))
+ vm.screenshot('before-reconnect')
+ record('12-renderer-reconnect', user('systemctl --user restart hn-screen.service && /usr/lib/harness-os/wait-runtime'), timeout=45)
+ after = snapshot('13-processes-after')
+ same = next(p for p in after if p['pid'] == before['pid'])
+ assert all(same[key] == before[key] for key in ['pid', 'start', 'stdin', 'argv'])
+ pane_format('14-format-after', pane)
+ record('15-no-apply-request', user('test ! -e ~/.local/state/harness-os/updates/request.json'))
+ record('16-frozen-runtime', 'printf %s ' + shlex.quote(checksums) + ' | sha256sum -c -')
+ vm.screenshot('after-reconnect')
+ receipt['status'] = 'passed'
+ except BaseException as error:
+ receipt.update(status='failed', error=repr(error))
+ try:
+ vm.screenshot('failure')
+ except Exception as capture:
+ receipt['capture_error'] = repr(capture)
+ raise
+ finally:
+ signal.alarm(0)
+ vm.stop()
+ receipt['finished_at'] = time.time()
+ save()
+ vm.log.close()
+ vm.stderr.close()
+ vm.control.cleanup()
+
+
+if __name__ == '__main__':
+ main()
diff --git a/os/tests/update_pane_guest.py b/os/tests/update_pane_guest.py
new file mode 100644
index 000000000..212fcfaff
--- /dev/null
+++ b/os/tests/update_pane_guest.py
@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+"""Independent observation of updater processes and pane identity in a private VM."""
+import argparse
+import hashlib
+import json
+import os
+from pathlib import Path
+import subprocess
+
+UPDATER = '/usr/lib/harness-os/live_update.py'
+STATE = Path.home() / '.local/state/harness-os/updates'
+
+
+def process(pid):
+ root = Path('/proc') / str(pid)
+ fields = (root / 'stat').read_text().rsplit(')', 1)[1].split()
+ return dict(pid=int(pid), start=fields[19], state=fields[0], group=fields[2],
+ foreground=fields[5], argv=(root / 'cmdline').read_bytes().rstrip(b'\0').decode().split('\0'))
+
+
+def snapshot():
+ template = '\t'.join('#{' + key + '}' for key in [
+ 'pane_id', 'pane_pid', 'pane_dead', 'window_id', 'window_name',
+ 'pane_active', 'window_active', 'socket_path', '@harness-update-instance'])
+ output = subprocess.check_output(['hn', 'list-panes', '-s', '-F', template], text=True, timeout=5)
+ panes = []
+ for line in output.splitlines():
+ values = line.split('\t')
+ assert len(values) == 9, repr(line)
+ panes.append(dict(zip(['pane', 'pid', 'dead', 'window', 'name', 'pane_active', 'window_active', 'socket', 'token'], values)))
+ screens = []
+ for path in Path('/proc').iterdir():
+ if not path.name.isdigit():
+ continue
+ try:
+ if path.stat().st_uid != os.getuid():
+ continue
+ record = process(path.name)
+ if record['argv'] not in (['/usr/bin/python3', UPDATER], ['/usr/bin/python3', UPDATER, 'screen']):
+ continue
+ environment = dict(value.split('=', 1) for value in (path / 'environ').read_bytes().decode().split('\0') if '=' in value)
+ record['backend_pane'] = environment.get('TMUX_PANE')
+ record['primary_socket'] = environment.get('HN_SOCKET')
+ record['token'] = environment.get('HARNESS_UPDATE_INSTANCE')
+ matches = [p['pane'] for p in panes if record['token'] and p['token'] == record['token']]
+ record['pane'] = matches[0] if len(matches) == 1 else None
+ record['stdin'] = str((path / 'fd/0').readlink())
+ registration = STATE / 'screens' / path.name
+ record['registration'] = json.loads(registration.read_text()) if registration.exists() else None
+ screens.append(record)
+ except (FileNotFoundError, ProcessLookupError):
+ continue
+ return dict(panes=panes, screens=screens, request_pending=(STATE / 'request.json').exists(),
+ boot_id=Path('/proc/sys/kernel/random/boot_id').read_text().strip())
+
+
+def work_identity():
+ agent_ids = subprocess.check_output(['pgrep', '-u', str(os.getuid()), '-x', 'opencode'], text=True).split()
+ daemon = subprocess.check_output(['systemctl', '--user', 'show', 'harness-daemon.service', '-p', 'MainPID', '--value'], text=True).strip()
+ terminal = (Path.home() / 'projects/session-probe/pid').read_text().strip()
+ return dict(agents=[process(pid) for pid in agent_ids], daemon=process(daemon), terminal=process(terminal),
+ boot_id=Path('/proc/sys/kernel/random/boot_id').read_text().strip(),
+ heartbeat=(Path.home() / 'projects/session-probe/heartbeat').stat().st_mtime_ns,
+ runtime={str(path): hashlib.sha256(path.read_bytes()).hexdigest() for path in [
+ Path('/usr/lib/harness/harness-tui'), Path('/usr/lib/harness/cli.mjs'), Path('/usr/lib/harness/notify.mjs')]})
+
+
+def main():
+ parser = argparse.ArgumentParser(description=__doc__)
+ parser.add_argument('action', choices=['snapshot', 'work'])
+ parser.add_argument('output', type=Path)
+ args = parser.parse_args()
+ result = snapshot() if args.action == 'snapshot' else work_identity()
+ args.output.write_text(json.dumps(result, indent=2) + '\n')
+
+
+if __name__ == '__main__':
+ main()
diff --git a/os/tests/update_pane_vm.py b/os/tests/update_pane_vm.py
new file mode 100644
index 000000000..afe763904
--- /dev/null
+++ b/os/tests/update_pane_vm.py
@@ -0,0 +1,373 @@
+#!/usr/bin/env python3
+"""Observe update shortcut ownership on a frozen, privately installed OS image."""
+import argparse
+import hashlib
+import json
+import os
+from pathlib import Path
+import shlex
+import time
+from footprint_vm import copy_file
+from hardware_install_vm import candidate_record, digest
+from session_vm import PROBE, screen_text
+from vm import VM
+
+UPDATER = '/usr/lib/harness-os/live_update.py'
+OPENER = '/usr/lib/harness-os/open-updates'
+WRAPPER = '/usr/bin/harness'
+GUEST = '/home/me/update-pane-observer.py'
+STATE = '/home/me/.local/state/harness-os/updates'
+
+
+def main():
+ parser = argparse.ArgumentParser(description=__doc__)
+ parser.add_argument('--iso', type=Path, required=True)
+ parser.add_argument('--output', type=Path, default=Path('os/test-results/update-pane'))
+ args = parser.parse_args()
+ assert os.access('/dev/kvm', os.R_OK | os.W_OK), 'Native x86 KVM is required'
+ iso = args.iso.resolve()
+ manifest = json.loads(iso.with_name('manifest.json').read_text())
+ assert digest(iso) == manifest['iso']['sha256'] and iso.stat().st_size == manifest['iso']['bytes']
+ assert set(manifest['harness_inputs']['files']) == {'harness-tui', 'cli.mjs', 'notify.mjs'}
+ folder = args.output.resolve()
+ folder.mkdir(parents=True, exist_ok=False)
+ (folder / 'image-manifest.json').write_text(json.dumps(manifest, indent=2) + '\n')
+ root = Path(__file__).resolve().parents[1]
+ candidates = {UPDATER: root / 'live_update.py', OPENER: root / 'root/usr/lib/harness-os/open-updates',
+ WRAPPER: root / 'root/usr/bin/harness'}
+ receipt = dict(status='running', started_at=time.time(), image_source=manifest['source_commit'],
+ iso_sha256=manifest['iso']['sha256'], firmware='bios', memory_mib=2048, cpu='Nehalem',
+ candidates={target: candidate_record(path) for target, path in candidates.items()},
+ test_inputs={name: candidate_record(Path(__file__).with_name(name)) for name in [
+ 'update_pane_vm.py', 'update_pane_guest.py', 'vm.py', 'session_vm.py',
+ 'footprint_vm.py', 'hardware_install_vm.py']}, checks=[],
+ limitations=['Updater-pane delivery and lifetime only; no new runtime or OS package activation.',
+ 'Private loopback metadata offers no update; shared runtime bytes stay frozen.',
+ 'No physical keyboard, Intel Mac, radio or GPU claim.'])
+ vm = VM(folder, iso, 'bios', 2048, cpu='Nehalem')
+ config = dict(disk='/dev/vda', expected_serial='HN_OS_TEST', confirm_erase='/dev/vda',
+ username='me', hostname='harness', password='test-password-123', encrypt=False, serial_console=True)
+
+ def observe(name, action='snapshot'):
+ vm.command('python3 ' + GUEST + ' ' + action + ' /tmp/update-pane-observation.json')
+ data = vm.read_file('/tmp/update-pane-observation.json')
+ (folder / (name + '.json')).write_bytes(data)
+ return json.loads(data)
+
+ def active(snapshot):
+ return [p for p in snapshot['screens'] if p['registration'] is not None
+ and p['pane'] is not None and p['state'] not in ['Z', 'X']]
+
+ def wait_active(name, expected=None):
+ deadline = time.monotonic() + 15
+ while time.monotonic() < deadline:
+ record = observe(name)
+ owners = active(record)
+ if len(owners) == 1 and not record['request_pending']:
+ owner = owners[0]
+ pane = next(p for p in record['panes'] if p['pane'] == owner['pane'])
+ if not (pane['dead'] == '0' and pane['pane_active'] == '1' and pane['window_active'] == '1'):
+ time.sleep(.1)
+ continue
+ if expected:
+ assert (owner['pid'], owner['start'], owner['pane']) == (expected['pid'], expected['start'], expected['pane']), record
+ assert owner['stdin'].startswith('/dev/pts/') and owner['group'] == owner['foreground'], owner
+ assert pane['token'] == owner['token']
+ assert owner['registration'] == dict(pid=owner['pid'], start=owner['start'],
+ token=owner['token'], boot_id=record['boot_id']), owner
+ return record, owner
+ time.sleep(.1)
+ raise TimeoutError('One active updater did not consume the shortcut: ' + name)
+
+ def wait_gone(previous):
+ script = '''import time
+from pathlib import Path
+path=Path('/proc/%d/stat')
+deadline=time.monotonic()+5
+while time.monotonic()<deadline:
+ try:
+ start=path.read_text().rsplit(')',1)[1].split()[19]
+ except FileNotFoundError:
+ break
+ if start != %r:
+ break
+ time.sleep(.05)
+else: raise TimeoutError('Previous updater process did not exit')
+''' % (previous['pid'], previous['start'])
+ vm.command('python3 -c ' + shlex.quote(script), timeout=10)
+
+ def wait_ui(name):
+ deadline = time.monotonic() + 15
+ while time.monotonic() < deadline:
+ if 'up to date' in screen_text(vm, name):
+ return
+ time.sleep(.1)
+ raise TimeoutError('Actual Updates screen did not render: ' + name)
+
+ def work_survives(name, original):
+ now = observe(name, 'work')
+ for key in ['agents', 'daemon', 'terminal']:
+ before = original[key] if key == 'agents' else [original[key]]
+ after = now[key] if key == 'agents' else [now[key]]
+ assert {(p['pid'], p['start']) for p in before} == {(p['pid'], p['start']) for p in after}, key
+ assert all(p['state'] not in ['Z', 'X'] for p in after), key
+ assert now['boot_id'] == original['boot_id'] and now['runtime'] == original['runtime']
+ assert now['heartbeat'] > original['heartbeat']
+
+ try:
+ vm.start(live=True)
+ receipt['acceleration'] = vm.acceleration
+ vm.wait(r'root@[^\r\n]*[#] ')
+ vm.shell_ready = True
+ vm.command('stty -echo; nmcli networking off')
+ copy_file(vm, json.dumps(config).encode(), '/tmp/install-config.json')
+ output, _ = vm.command('harness install --config /tmp/install-config.json --yes-erase-disk', timeout=360)
+ (folder / 'install.log').write_text(output)
+ vm.command('sync')
+ vm.stop()
+ vm.start(live=False)
+ vm.login_installed(config)
+ vm.command('test "$HOME" = /home/me && test -d "$HOME/projects"')
+ vm.command('printf %s ' + shlex.quote(config['password'] + '\n') + ' | sudo -S -v')
+ vm.command('systemctl --user stop harness-update.timer harness-update.service')
+ vm.command('test ! -e ' + STATE + '/ready.json && test ! -e ' + STATE + '/current && test ! -e ' + STATE + '/approved.json')
+ vm.command('for n in $(seq 1 90); do pgrep -u 1000 -x opencode >/dev/null && exit 0; sleep .5; done; exit 1', timeout=50)
+ copy_file(vm, Path(__file__).with_name('update_pane_guest.py').read_bytes(), GUEST)
+ copy_file(vm, PROBE.encode(), '/home/me/update-pane-terminal.py')
+ output, _ = vm.command("hn new-window -P -F '#{pane_id}' -n Updates 'python3 /home/me/update-pane-terminal.py' > /tmp/update-pane-terminal-id")
+ vm.command('for n in $(seq 1 60); do test -s ~/projects/session-probe/pid && exit 0; sleep .1; done; exit 1')
+ terminal = vm.read_file('/tmp/update-pane-terminal-id').decode().strip()
+ before = observe('01-original-work', 'work')
+ for path, expected in manifest['harness_inputs']['files'].items():
+ assert before['runtime']['/usr/lib/harness/' + path] == expected['sha256']
+ receipt['original_files'] = {path: hashlib.sha256(vm.read_file(path)).hexdigest() for path in candidates}
+ original_opener = vm.read_file(OPENER)
+ assert b'select-window -t Updates' in original_opener, 'This baseline fixture requires the legacy name-only adapter'
+ (folder / 'original-open-updates').write_bytes(original_opener)
+ vm.keys('meta_l', 'u')
+ vm.command('timeout 5 sh -c \'until test -s ' + STATE + '/request.json; do sleep .05; done\'')
+ baseline = observe('02-baseline-name-collision')
+ assert not baseline['screens'] and baseline['request_pending'], baseline
+ terminal_pane = next(p for p in baseline['panes'] if p['pane'] == terminal)
+ assert terminal_pane['pane_active'] == '1' and terminal_pane['window_active'] == '1'
+
+ def focus_terminal():
+ vm.command('hn select-window -t ' + shlex.quote(terminal_pane['window']) +
+ ' && hn select-pane -t ' + shlex.quote(terminal))
+
+ vm.screenshot('02-baseline-name-collision')
+ receipt['checks'].append('Original image adapter loses Super+u to the unrelated Updates terminal; no updater process exists and request remains pending.')
+
+ # Real UI with deterministic, private release input: version 0.0.0
+ # cannot activate anything. A missing OS channel is a normal 404.
+ vm.command('mkdir -p /home/me/update-pane-feed')
+ ref = dict(url='http://127.0.0.1:19447/unused', sha256='0' * 64, size=1)
+ feeds = {'hn': {'version': '0.0.0', 'builds': {'linux-x64': ref}},
+ 'cli': {'cli': {'version': '0.0.0', 'cli': ref, 'notify': ref}}}
+ for name, value in feeds.items():
+ copy_file(vm, json.dumps(value).encode(), '/home/me/update-pane-feed/' + name + '.json')
+ vm.command('systemd-run --user --collect --unit=harness-test-feed python3 -m http.server 19447 --bind 127.0.0.1 --directory /home/me/update-pane-feed')
+ vm.command('for n in $(seq 1 30); do curl -fsS http://127.0.0.1:19447/hn.json && exit 0; sleep .1; done; exit 1')
+ candidate = candidates[UPDATER].read_text()
+ fixture = candidate
+ for component, filename in [('tui', 'hn'), ('cli', 'cli')]:
+ address = "'https://storage.googleapis.com/s3-autonomous-upgrade-3/harness/" + component + "/metadata.json'"
+ assert fixture.count(address) == 1
+ fixture = fixture.replace(address, "'http://127.0.0.1:19447/" + filename + ".json'")
+ marker = 'release = module.discover()'
+ assert fixture.count(marker) == 1
+ fixture = fixture.replace(marker, "release = module.discover('http://127.0.0.1:19447/no-os-channel.json')")
+ # Hold the *same* process alive after the real close decision released
+ # open.lock and removed its registration. No close result is forged.
+ trace = '''
+_observed_consume_request = consume_request
+def consume_request():
+ gate = Path('/tmp/update-pane-route-gate')
+ request = read(STATE / 'request.json', {})
+ target = gate.read_text().strip() if gate.exists() else None
+ if target and request.get('target') == target:
+ token = os.environ.get('HARNESS_UPDATE_INSTANCE')
+ if token == target:
+ deadline = time.monotonic() + 10
+ while not Path('/tmp/update-pane-route-rejected.json').exists():
+ if time.monotonic() >= deadline:
+ raise TimeoutError('Direct inspection did not reject targeted request')
+ time.sleep(.05)
+ claimed = _observed_consume_request()
+ kind = 'claimed' if token == target else 'rejected'
+ write(Path('/tmp/update-pane-route-' + kind + '.json'), dict(
+ pid=os.getpid(), token=token, request=request, claimed=claimed))
+ return claimed
+ return _observed_consume_request()
+
+_observed_close_screen = close_screen
+def close_screen():
+ closed = _observed_close_screen()
+ hold = Path('/tmp/update-pane-hold-close')
+ if closed and hold.exists() and hold.read_text().strip() == str(os.getpid()):
+ Path('/tmp/update-pane-close-committed').write_text(str(os.getpid()))
+ deadline = time.monotonic() + 30
+ while not Path('/tmp/update-pane-release-close').exists() and time.monotonic() < deadline:
+ time.sleep(.05)
+ return closed
+
+'''
+ assert fixture.count("if __name__ == '__main__':") == 1
+ fixture = fixture.replace("if __name__ == '__main__':", trace + "if __name__ == '__main__':")
+ compile(fixture, 'observed-live-update.py', 'exec')
+ (folder / 'observed-live-update.py').write_text(fixture)
+ receipt['private_observer'] = dict(sha256=hashlib.sha256(fixture.encode()).hexdigest(),
+ differences=['hn and CLI feed URLs use loopback version 0.0.0 metadata.',
+ 'OS discovery receives its supported explicit loopback feed argument; endpoint returns 404.',
+ 'For one targeted handoff, owned consume waits up to 10 seconds for a direct inspection to execute the real consume and reject that target; both actual outcomes are retained.',
+ 'After real close_screen returns True, one selected test process waits for release, at most 30 seconds.'])
+ copy_file(vm, fixture.encode(), '/tmp/update-pane-ui.py')
+ copy_file(vm, candidates[OPENER].read_bytes(), '/tmp/update-pane-opener')
+ copy_file(vm, candidates[WRAPPER].read_bytes(), '/tmp/update-pane-wrapper')
+ vm.command('sudo install -m 644 /tmp/update-pane-ui.py ' + UPDATER +
+ ' && sudo install -m 755 /tmp/update-pane-opener ' + OPENER +
+ ' && sudo install -m 755 /tmp/update-pane-wrapper ' + WRAPPER + ' && sudo nmcli networking off')
+ assert hashlib.sha256(vm.read_file(OPENER)).hexdigest() == receipt['candidates'][OPENER]['sha256']
+ assert hashlib.sha256(vm.read_file(WRAPPER)).hexdigest() == receipt['candidates'][WRAPPER]['sha256']
+ assert hashlib.sha256(vm.read_file(UPDATER)).hexdigest() == receipt['private_observer']['sha256']
+ vm.keys('meta_l', 'u')
+ first, owner = wait_active('03-owned-updater')
+ wait_ui('03-owned-updater')
+ assert owner['pane'] != terminal
+ receipt['checks'].append('Super+u opens a real registered Updates UI beside the unrelated named terminal, and it consumes the request.')
+ for index in range(3):
+ focus_terminal()
+ vm.keys('meta_l', 'u')
+ wait_active('04-repeated-shortcut-' + str(index), owner)
+ pane = next(p for p in first['panes'] if p['pane'] == owner['pane'])
+ vm.command('hn rename-window -t ' + shlex.quote(pane['window']) + ' Versions')
+ focus_terminal()
+ vm.keys('meta_l', 'u')
+ wait_active('05-renamed-updater', owner)
+ receipt['checks'].append('Repeated Super+u and a renamed updater reuse its same PID/start time and pane rather than creating duplicate tabs.')
+
+ vm.command('systemctl --user restart hn-screen.service; /usr/lib/harness-os/wait-runtime', timeout=90)
+ focus_terminal()
+ vm.keys('meta_l', 'u')
+ resumed, _ = wait_active('06-renderer-reconnected', owner)
+ resumed_pane = next(p for p in resumed['panes'] if p['pane'] == owner['pane'])
+ receipt['socket_handover'] = dict(process_environment=owner['primary_socket'],
+ before=pane['socket'], after=resumed_pane['socket'])
+ wait_ui('06-renderer-reconnected')
+ work_survives('06-work-preserved', before)
+ receipt['checks'].append('After actual renderer restart, the same token-bound updater and work processes survive without requiring HN_SOCKET or a particular socket alias name.')
+
+ vm.command('kill -TERM ' + str(owner['pid']))
+ wait_gone(owner)
+ vm.command('test ! -e ' + STATE + '/request.json')
+ vm.command("hn new-window -P -F '#{pane_id}' -n Manual '/usr/bin/harness updates; sleep 120' > /tmp/update-pane-manual-caller")
+ manual, owner = wait_active('07-manual-view')
+ caller = vm.read_file('/tmp/update-pane-manual-caller').decode().strip()
+ assert owner['pane'] != caller and any(p['pane'] == caller for p in manual['panes']), manual
+ vm.command('test ! -e ' + STATE + '/request.json')
+ focus_terminal()
+ vm.keys('meta_l', 'u')
+ wait_active('07-manual-view-reused', owner)
+ wait_ui('07-manual-view-reused')
+ receipt['checks'].append('Manual harness updates opens an owned inspection pane without an apply request, preserves its caller terminal, and the next Super+u reuses that same actual UI process.')
+
+ # A valid headless endpoint is not a visible client. Manual inspection
+ # must remain on its caller's real terminal and never consume another
+ # screen's targeted shortcut. Use a separate private hn namespace.
+ vm.command("hn -L update-pane-headless new-session -d -s inspection 'sleep 120' && "
+ "hn -L update-pane-headless display-message -p '#{socket_path}' > /tmp/update-pane-headless-socket")
+ headless = vm.read_file('/tmp/update-pane-headless-socket').decode().strip()
+ assert headless.startswith('/') and '\n' not in headless, headless
+ headless_command = 'hn -S ' + shlex.quote(headless)
+ vm.command(headless_command + " hn-list-clients -F '#{client_tty}' > /tmp/update-pane-headless-clients && " +
+ headless_command + " list-panes -s -F '#{pane_id}' > /tmp/update-pane-headless-before")
+ assert not vm.read_file('/tmp/update-pane-headless-clients').strip()
+ default_socket = next(p for p in manual['panes'] if p['pane'] == owner['pane'])['socket']
+ vm.command('hn -S ' + shlex.quote(default_socket) + " new-window -P -F '#{pane_id}' -n Inspection " +
+ shlex.quote('env HN_SOCKET=' + headless + ' /usr/bin/harness updates; sleep 120') +
+ ' > /tmp/update-pane-inspection-caller')
+ inspection_pane = vm.read_file('/tmp/update-pane-inspection-caller').decode().strip()
+ deadline = time.monotonic() + 15
+ while time.monotonic() < deadline:
+ inspected = observe('07-direct-inspection')
+ direct = [p for p in inspected['screens'] if p['registration'] is None and p['token'] is None]
+ if len(direct) == 1:
+ inspection = direct[0]
+ assert inspection['primary_socket'] == headless
+ assert inspection['group'] == inspection['foreground'] and inspection['stdin'].startswith('/dev/pts/')
+ visible = next(p for p in inspected['panes'] if p['pane'] == inspection_pane)
+ assert visible['pane_active'] == '1' and visible['window_active'] == '1'
+ break
+ time.sleep(.1)
+ else:
+ raise TimeoutError('Manual inspection did not stay in its caller terminal')
+ wait_ui('07-direct-inspection')
+ vm.command(headless_command + " list-panes -s -F '#{pane_id}' > /tmp/update-pane-headless-after")
+ assert vm.read_file('/tmp/update-pane-headless-before') == vm.read_file('/tmp/update-pane-headless-after')
+ assert not inspected['request_pending']
+ vm.command('printf %s ' + owner['token'] + ' > /tmp/update-pane-route-gate')
+ focus_terminal()
+ vm.keys('meta_l', 'u')
+ delivered, _ = wait_active('07-targeted-delivery', owner)
+ vm.command("timeout 5 sh -c 'until test -s /tmp/update-pane-route-rejected.json && "
+ "test -s /tmp/update-pane-route-claimed.json; do sleep .05; done'")
+ evidence = {kind: json.loads(vm.read_file('/tmp/update-pane-route-' + kind + '.json'))
+ for kind in ['rejected', 'claimed']}
+ rejected, claimed = evidence['rejected'], evidence['claimed']
+ assert rejected['pid'] == inspection['pid'] and rejected['token'] is None and rejected['claimed'] is False
+ assert claimed['pid'] == owner['pid'] and claimed['token'] == owner['token'] and claimed['claimed'] is True
+ assert rejected['request'] == claimed['request'] and claimed['request']['target'] == owner['token']
+ assert any(p['pid'] == inspection['pid'] and p['start'] == inspection['start'] and p['registration'] is None
+ for p in delivered['screens'])
+ (folder / '07-targeted-delivery-outcomes.json').write_text(json.dumps(evidence, indent=2) + '\n')
+ receipt['headless_inspection'] = dict(socket=headless, caller_pane=inspection_pane, process=inspection,
+ pane_ids=vm.read_file('/tmp/update-pane-headless-after').decode())
+ vm.command('rm /tmp/update-pane-route-gate')
+ vm.command('kill -TERM ' + str(inspection['pid']))
+ wait_gone(inspection)
+ receipt['checks'].append('A manual view with a valid headless socket stays in its current PTY without creating a hidden pane or an apply request. While it remains alive, its real consume rejects the targeted shortcut before the selected owner claims that exact request.')
+
+ vm.command('printf %s ' + str(owner['pid']) + ' > /tmp/update-pane-hold-close')
+ vm.keys('esc')
+ vm.command('timeout 5 sh -c \'until test -s /tmp/update-pane-close-committed; do sleep .05; done\'')
+ closing = observe('08-close-committed-process-alive')
+ old = next(p for p in closing['screens'] if p['pid'] == owner['pid'])
+ assert old['registration'] is None and old['start'] == owner['start'] and old['state'] not in ['Z', 'X'], closing
+ vm.keys('meta_l', 'u')
+ replacement, replacement_owner = wait_active('09-closing-screen-replaced')
+ old = next(p for p in replacement['screens'] if p['pid'] == owner['pid'])
+ assert old['registration'] is None and old['start'] == owner['start'] and old['state'] not in ['Z', 'X'], replacement
+ assert replacement_owner['pid'] != owner['pid'] and replacement_owner['pane'] != owner['pane']
+ vm.screenshot('09-closing-screen-replaced')
+ vm.command('touch /tmp/update-pane-release-close')
+ receipt['checks'].append('A real Escape commits closing and unregisters; while the same Python PID remains alive, Super+u opens one replacement that consumes its request.')
+
+ focus_terminal()
+ vm.type_probe('ownership-input-survives')
+ vm.keys('ret')
+ vm.command("timeout 5 sh -c 'until grep -Fx ownership-input-survives ~/projects/session-probe/input; do sleep .1; done'")
+ vm.screenshot('10-original-terminal-input')
+ work_survives('10-final-work-preserved', before)
+ receipt['checks'].append('Original named terminal accepts actual QMP keyboard input; its heartbeat, OpenCode, daemon and boot identities survive, and frozen runtime hashes are unchanged.')
+ receipt['status'] = 'passed'
+ except BaseException as error:
+ receipt.update(status='failed', error=repr(error))
+ if vm.process and vm.process.poll() is None:
+ try:
+ vm.screenshot('failure')
+ output, _ = vm.command('journalctl --user -n 150 --no-pager; hn list-panes -a -F "#{pane_id} #{pane_pid} #{pane_dead} #{window_name} #{socket_path}"', timeout=15, check=False)
+ (folder / 'failure.log').write_text(output)
+ except Exception:
+ pass
+ raise
+ finally:
+ receipt['finished_at'] = time.time()
+ (folder / 'receipt.json').write_text(json.dumps(receipt, indent=2) + '\n')
+ vm.stop()
+ vm.log.close()
+ vm.stderr.close()
+ vm.control.cleanup()
+
+
+if __name__ == '__main__':
+ main()