| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123 |
- """``cron/bot_chat_pending``: Bot Chat outputs whose target owner was not running yet.
- ``defer`` parks one (a cross-profile target whose gateway is down or still starting), and
- the retired CLI lane left records of the same shape behind. Each still-``queued`` record is handed,
- under its own id, to the target profile's live owner through the canonical
- ``tools.bot_live_delivery.deliver_to_live_owner`` door (idempotent per id). Records are
- never deleted: they keep their final status as evidence, exactly as the old drain did.
- A ``claimed`` record was an uncertain CLI turn and is never resent.
- """
- from __future__ import annotations
- import json
- import logging
- from pathlib import Path
- from hermes_dir_acl import make_user_dir
- from hermes_constants import get_hermes_home
- from utils import atomic_json_write
- logger = logging.getLogger(__name__)
- _warned: set[Path] = set()
- def defer(key: str, job: dict, content: str, home: Path, *, for_failure: bool) -> None:
- """Park one never-admitted output under its delivery id; a later tick hands it to the owner."""
- import time
- root = get_hermes_home().resolve() / "cron" / "bot_chat_pending"
- make_user_dir(root, parents=True, exist_ok=True, mode=0o700)
- path = root / f"{key}.json"
- if not path.exists(): # an existing record (queued or already transferred) keeps its status
- atomic_json_write(path, dict(
- id=key, status="queued", job={k: job[k] for k in ("id", "name") if k in job}, content=content,
- home=str(home), for_failure=for_failure, sequence=time.time_ns()), fsync_dir=True, mode=0o600)
- def _queued(root: Path) -> list[tuple[Path, dict]]:
- found = []
- for path in root.glob("*.json"):
- try:
- record = json.loads(path.read_text(encoding="utf-8-sig"))
- if not isinstance(record, dict):
- raise ValueError(f"expected a JSON object, got {type(record).__name__}")
- except (OSError, ValueError) as exc:
- if path not in _warned:
- _warned.add(path)
- logger.error("Unreadable legacy Bot Chat pending record %s kept as evidence: %s", path, exc)
- continue
- if record.get("status") == "queued":
- found.append((path, record))
- return sorted(found, key=lambda item: (item[1].get("sequence", 0), item[0].name))
- def _malformed(record: dict) -> str:
- """Why *record* can never be handed off (empty when its required fields are usable)."""
- missing = [key for key in ("id", "home", "content")
- if not isinstance(record.get(key), str) or not record.get(key)]
- if missing:
- return f"malformed legacy bot-chat record (missing {', '.join(missing)}); not delivered"
- if not isinstance(record.get("job") or {}, dict):
- return "malformed legacy bot-chat record (job is not an object); not delivered"
- return ""
- def _dispose(path: Path, record: dict) -> bool:
- """Decide one queued record in place; False leaves it queued for a later tick."""
- from cron.scheduler_delivery import BOT_CHAT_POLICY_PLATFORM, bot_chat_message
- from gateway.warning_notifications import warning_notifications_enabled
- from hermes_cli.config_effective import load_user_config_effective
- from tools.bot_live_delivery import deliver_to_live_owner, find_canonical_live_owner
- if reason := _malformed(record):
- record.update(status="ambiguous", error=reason)
- return True
- home = Path(record["home"]).resolve()
- for_failure = bool(record.get("for_failure"))
- if not (home / "state.db").is_file():
- record.update(status="ambiguous", error=f"bot-chat delivery target no longer exists: {home}")
- elif for_failure and not warning_notifications_enabled(
- BOT_CHAT_POLICY_PLATFORM, load_user_config_effective(home / "config.yaml")):
- record.update(status="suppressed", error=None)
- else:
- try:
- owner = find_canonical_live_owner(home)
- except ValueError:
- return False # Owner not ready: discovery uncertainty is not a disposition.
- if owner is None:
- return False
- try:
- receipt = deliver_to_live_owner(
- home, owner, bot_chat_message(record.get("job") or {}, record["content"]),
- delivery_id=record["id"], notification_category="diagnostic" if for_failure else "result")
- except Exception as exc:
- # The door is idempotent per id (a replay returns the existing receipt), so the
- # record stays queued for the next tick; log loudly once, quietly after.
- logger.log(logging.DEBUG if path in _warned else logging.WARNING,
- "Legacy Bot Chat pending record %s not handed off yet: %s", path, exc, exc_info=True)
- _warned.add(path)
- return False
- receipt_status = receipt.get("status") if isinstance(receipt, dict) else None
- record.update(status="transferred", error=None, receipt_status=receipt_status)
- return True
- def drain_legacy_pending() -> None:
- """Admit queued legacy records to their live owner; an absent owner leaves them for a later tick.
- Each record is isolated: a malformed one is kept as ``ambiguous`` evidence and an
- unexpected failure leaves only that record queued, so one bad file never stops cron.
- """
- root = get_hermes_home().resolve() / "cron" / "bot_chat_pending"
- if not root.is_dir():
- return
- for path, record in _queued(root):
- try:
- if not _dispose(path, record):
- continue
- atomic_json_write(path, record, fsync_dir=True, mode=0o600)
- except Exception as exc:
- logger.log(logging.DEBUG if path in _warned else logging.WARNING,
- "Legacy Bot Chat pending record %s left queued: %s", path, exc, exc_info=True)
- _warned.add(path)
- continue
- logger.info("Legacy Bot Chat pending record %s -> %s", path.name, record["status"])
|