Skip to content

The agent that grows with you

3.0 KB
Raw Blame
"""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()