The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
"""One idle check for a Bot Desktop screen, run by the screen's own launcher.
The screen outlives the gateway that started it on purpose (a restarted gateway re-attaches to it), so the
gateway's display watcher cannot be the only thing that ever stops it: when no gateway comes back, Xvnc +
Xfce and any browser left open run until reboot. ``launcher.sh`` therefore runs this module (through the
install's stable command) in a loop of its own. Each run applies :func:`runtime.stop_if_idle` (the same
``bot_desktop.idle_stop_minutes`` window and the same human-lease rule as the gateway's watcher) and prints
how long the launcher should sleep before the next run, so no interpreter stays resident between checks.
"""
from __future__ import annotations
import logging
import math
import os
import sys
from typing import Optional
from tools.bot_desktop import runtime
logger = logging.getLogger(__name__)
_MIN_DELAY_S = 30.0 # the gateway watcher's cadence; a window shorter than that is checked at its own length
def next_check_in(limit: float, idle: Optional[float]) -> int:
"""Whole seconds until the screen could next be due: when the window runs out at the current idle age,
or a full window later while something (a human holding it) keeps it past that. With the auto-stop off
(``limit <= 0``) the setting is re-read every default window."""
if limit <= 0:
return runtime.DEFAULT_IDLE_STOP_MINUTES * 60
idle = idle or 0.0
return math.ceil(max(min(_MIN_DELAY_S, limit), limit - idle if idle < limit else limit))
def _own_launcher(argv: list[str]) -> Optional[tuple[int, float]]:
"""``(pid, create_time)`` of the launcher that ran this check (its pid is the one argument), so the
check stops only that screen and never a replacement started while it waited on ``start.lock``. A
launcher already gone gets an identity nothing matches."""
pid_s = argv[0] if argv else ""
if not pid_s.isdigit():
return None
born = runtime._create_time(int(pid_s))
return int(pid_s), born if born is not None else -1.0
def main() -> None:
logging.basicConfig(level=logging.INFO, format="%(asctime)s idle-watch %(message)s") # stderr = launcher.log
if runtime.stop_if_idle(launcher=_own_launcher(sys.argv[1:])):
return
delay = next_check_in(runtime.idle_stop_seconds(), runtime.idle_seconds())
logger.info("screen kept; next idle check in %ds", delay)
print(delay)
if __name__ == "__main__":
# stop() kills the launcher's process group, which this check was started in; in a session of its own it
# survives that kill to finish the stop (SIGKILL stragglers, drop the runtime files), then exits. A process
# that already leads its group (run by hand from a shell) cannot setsid and is not in the launcher's group.
if os.getpgrp() != os.getpid(): # windows-footgun: ok — Linux-only (launcher.sh)
os.setsid() # windows-footgun: ok — Linux-only (launcher.sh) detached-spawn: ok — short-lived, outlives the group kill it performs
main()