The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
"""Gateway housekeeping chores that keep the data disk healthy: stale media-cache cleanup and the
home-channel prompt for the low-disk auto-prune decision (see ``hermes_cli/prune_advisor.py``).
A headless gateway on a small VPS is where a disk fills up, and its owner may never open the CLI,
so the question goes to each served profile's home channel; Desktop and Ink TUI viewers of local
sessions get it as a notice. It is posted at most once per
snooze window per profile: posting records the snooze, and ``/autoprune on|off`` ends it for good.
Runs from the housekeeping thread; the send is scheduled onto the gateway loop.
"""
from __future__ import annotations
import contextlib
import logging
from pathlib import Path
logger = logging.getLogger(__name__)
def housekeeping_media_caches() -> None:
"""Hourly media-cache prune (24h max age); spillover (None) keeps the session retention window."""
from gateway.platforms.base import (
cleanup_audio_cache, cleanup_document_cache, cleanup_image_cache, cleanup_screenshot_cache,
cleanup_video_cache)
from tools.tool_result_storage import cleanup_spillover_cache
from tools.environments.local import cleanup_terminal_temp_cache
from tools.bot_mode_dm import cleanup_bot_dm_cache
from tools.bot_relay import cleanup_bot_relay_artifacts
from agent.provider_media import MEDIA_CACHE_MAX_AGE_HOURS
from gateway.run import _housekeeping_chore
for cache_name, cleanup_fn in (
("Image", cleanup_image_cache), ("Document", cleanup_document_cache),
("Audio", cleanup_audio_cache), ("Video", cleanup_video_cache),
("Screenshot", cleanup_screenshot_cache), ("Spillover", cleanup_spillover_cache),
("Terminal temp", cleanup_terminal_temp_cache), ("Bot DM", cleanup_bot_dm_cache),
("Bot relay", cleanup_bot_relay_artifacts)):
def _one(name=cache_name, fn=cleanup_fn):
removed = fn(max_age_hours=None if fn is cleanup_spillover_cache else MEDIA_CACHE_MAX_AGE_HOURS)
if removed:
logger.info("%s cache cleanup: removed %d stale file(s)", name, removed)
_housekeeping_chore(f"{cache_name} cache cleanup", _one)
def maybe_post_auto_prune_prompt(runner, loop) -> None:
"""One housekeeping tick: post the prompt to every served profile that has a home channel, a
low disk and no decision yet. Cheap when nothing is due (two syscalls + a YAML read per
profile); the database estimate runs only for a profile that can actually receive it."""
if runner is None or loop is None:
return
from agent.async_utils import safe_schedule_threadsafe
from hermes_cli import prune_advisor
from hermes_constants import get_routing_process_hermes_home
reachable = {profile for profile, *_rest in runner._served_home_channel_transports()}
homes: dict = {None: get_routing_process_hermes_home()}
homes.update(getattr(runner, "_served_profile_homes", None) or {})
for profile, home in homes.items():
if profile not in reachable or prune_advisor.should_ask(Path(home)) is None:
continue
advice = prune_advisor.advise(Path(home))
if advice is None:
continue
fut = safe_schedule_threadsafe(_post(runner, profile, home, advice), loop, logger=logger,
log_message="Auto-prune prompt scheduling error")
# Snooze only on a delivered post: a send that failed must not swallow the question.
if fut is not None and fut.result(timeout=60):
prune_advisor.snooze(Path(home))
_LOCAL_NOTIFIED: dict[str, float] = {}
async def publish_local_auto_prune_notice(authority, ref) -> None:
"""Desktop / Ink TUI sessions (``AuthorityConnection.resume``): one sticky ``notification.show``
per profile per snooze window while the disk is low and auto-prune is undecided. The classic
CLI asks at its own startup, so its sessions are skipped here."""
import asyncio
import time
from gateway.config import Platform
from gateway.session_policy import policy_for_source
from hermes_cli import prune_advisor
from hermes_state_runtime import RuntimeStoreError
live = authority.sessions.get(ref.session_id)
source = getattr(live, "source", None)
if source is None or source.platform != Platform.LOCAL:
return
try:
policy = policy_for_source(authority.runner, source)
except RuntimeStoreError: # policy not restored yet: this viewer gets no notice, the next one may
return
if policy is None or policy.source not in {"tui", "gui"}:
return
home = Path(authority.db.db_path).parent
if not prune_advisor.notice_due(home, _LOCAL_NOTIFIED):
return
_LOCAL_NOTIFIED[str(home)] = time.time() # in-flight claim: one estimate per home at a time
advice = await asyncio.to_thread(prune_advisor.advise, home)
# Answered (here or in another window) during the estimate: publishing would re-ask it.
delivered = (advice is not None and prune_advisor.should_ask(home) is not None
and live.event_stream.publish(ref.session_id, prune_advisor.notice_payload(advice),
event_type="notification.show"))
if not delivered:
_LOCAL_NOTIFIED.pop(str(home), None) # nobody saw it: the next window may ask
def clear_local_auto_prune_notice(runner, source) -> None:
"""After /autoprune is answered on a local session, drop its sticky notice for that viewer."""
from gateway.config import Platform
from gateway.session_authorities import active_authority
from hermes_cli.prune_advisor import NOTICE_KEY
if getattr(source, "platform", None) != Platform.LOCAL:
return
authority = active_authority(runner)
live = authority.sessions.get(source.chat_id) if authority is not None else None
if live is not None:
live.event_stream.publish(source.chat_id, {"key": NOTICE_KEY}, event_type="notification.clear")
async def _post(runner, profile, home, advice) -> bool:
"""Send to the profile's home channels; True when at least one send was delivered."""
from gateway.run import _async_profile_runtime_scope
from gateway.warning_notifications import present_notification
from hermes_cli.prune_advisor import advice_lines
delivered = False
scope = _async_profile_runtime_scope(Path(home)) if profile is not None else contextlib.nullcontext()
async with scope:
for target_profile, platform, _cfg, home_ch, transport in list(runner._served_home_channel_transports()):
if target_profile != profile:
continue
prefix = getattr(transport.adapter, "typed_command_prefix", "/") if transport.adapter else "/"
message = "⚠ " + "\n".join(advice_lines(advice, command_prefix=prefix))
sent: list[bool] = []
async def _send(platform=platform, home_ch=home_ch, transport=transport, message=message):
sent.append(await runner._send_home_channel_message(
platform, home_ch, transport, message, "Auto-prune prompt failed for %s:%s: %s"))
await present_notification(_send, platform=platform)
delivered = delivered or any(sent)
return delivered