| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102 |
- """What ``save_config`` persists when the process serves a frozen session config.
- A managed worker binds its session's creation-time config (``agent.safe_worker_policy``), so its
- ``load_config()`` is that snapshot, not the profile file. A read-modify-write in such a worker
- (an ``always`` approval, a connector enable) must land only what it changed on the LIVE file:
- writing the whole snapshot back would revert every profile edit made since the session was
- created. Outside a frozen worker this is ``save_config``'s ordinary ``merge_existing`` handling.
- """
- from __future__ import annotations
- import copy
- from typing import Any
- def rebase_for_save(config: dict[str, Any], live_raw: dict[str, Any], merge_existing: bool) -> dict[str, Any]:
- from hermes_cli import config as _config
- snapshot = _config._worker_config_snapshot()
- if snapshot is not None:
- return _three_way(live_raw or {}, config, _config.load_config(), _frozen_for_deletion(snapshot))
- if merge_existing and live_raw:
- return _config._merge_partial_save(live_raw, config)
- return config
- def _frozen_for_deletion(snapshot: dict[str, Any]) -> Any:
- """The snapshot branches that count as operator state.
- An ordinary snapshot only contains what the profile had at creation, so an explicit
- empty allowlist is a real branch. A bypass worker (safe mode, ``--ignore-user-config``)
- freezes a copy of the schema, so a branch that is still the schema default was never
- an operator choice and must not count as a deletion."""
- from agent.safe_worker_policy import _current_policy
- policy = _current_policy()
- if policy is None or not policy.ignore_user_config:
- return snapshot
- from hermes_cli.config_defaults import DEFAULT_CONFIG
- return _schema_default_branch(snapshot, DEFAULT_CONFIG)
- def _schema_default_branch(snapshot: Any, defaults: Any) -> Any:
- """*snapshot* without branches whose value is still the schema default."""
- if not isinstance(snapshot, dict) or not isinstance(defaults, dict):
- return copy.deepcopy(snapshot)
- kept: dict[str, Any] = {}
- for key, value in snapshot.items():
- if key not in defaults:
- kept[key] = copy.deepcopy(value)
- continue
- default = defaults[key]
- if value == default:
- continue
- if isinstance(value, dict) and isinstance(default, dict):
- nested = _schema_default_branch(value, default)
- if nested:
- kept[key] = nested
- else:
- kept[key] = copy.deepcopy(value)
- return kept
- _SAME_AS_BASE = object()
- def _three_way(live: Any, desired: Any, base: Any, frozen: Any = _SAME_AS_BASE) -> Any:
- """*live* with the caller's edits (*desired* relative to the *base* it loaded) applied.
- Mappings recurse; list edits add/remove items; a key the caller dropped is left alone. A
- mapping/list branch deleted (or retyped) on *live* since *base* stays as live has it: a
- leaf edit must not resurrect the stale snapshot subtree around it.
- *frozen* is the operator-owned snapshot under *base* (``load_config()`` merges the schema
- defaults over the raw snapshot). A branch in neither *frozen* nor *live* came only from the
- defaults, so nothing deleted it: the edit applies to the default (a fresh profile's first
- ``always`` grant, including one made in safe mode). A branch the operator set and the live
- file then lost stays deleted."""
- if frozen is _SAME_AS_BASE:
- frozen = base
- if desired == base:
- return copy.deepcopy(live)
- if isinstance(desired, dict) and isinstance(base, dict) and isinstance(live, dict):
- frozen_map = frozen if isinstance(frozen, dict) else {}
- merged = copy.deepcopy(live)
- for key, value in desired.items():
- if key not in base:
- merged[key] = copy.deepcopy(value)
- elif value != base[key]:
- kind = dict if isinstance(base[key], dict) else list if isinstance(base[key], list) else None
- current = live.get(key)
- if kind is not None and not isinstance(current, kind):
- if key in live or key in frozen_map:
- continue # concurrently deleted/replaced live branch: live wins
- current = copy.deepcopy(base[key]) # default-only branch
- merged[key] = _three_way(current, value, base[key], frozen_map.get(key, {}))
- return merged
- if isinstance(desired, list) and isinstance(base, list) and isinstance(live, list):
- removed = [item for item in base if item not in desired]
- kept = [item for item in live if item not in removed]
- return kept + [copy.deepcopy(item) for item in desired if item not in base and item not in kept]
- return copy.deepcopy(desired)
|