mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-11-21 04:09:45 +03:00
2087cbe469
The Skills Guard scan for skill_manage writes is opt-in (skills.guard_agent_created) because terminal() can write the same files ungated. That reason does not hold for the background self-improvement review: its whitelist is memory+skills only, so skill_manage is its only write path, and what it writes reaches every later session's prompt. Run the existing scan when the guard is on OR the write comes from the background review, including create/edit/patch/write_file on supporting files of an existing skill. The scan already fails closed on error. A review write staged by skills.write_approval keeps that scan when the user approves it via /skills approve (the staged origin is passed to apply_skill_pending). Foreground writes are unchanged. Hardening (Skills Guard is a heuristic, SECURITY.md §2.4/§3.2). Fixes #78515 Refs #84250 Co-authored-by: Christopher-Schulze <210261288+Christopher-Schulze@users.noreply.github.com>
189 lines
7.7 KiB
Python
189 lines
7.7 KiB
Python
#!/usr/bin/env python3
|
|
"""Shared handlers for the /memory and /skills write-approval subcommands."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
from typing import List, Optional
|
|
|
|
from tools import write_approval as wa
|
|
|
|
|
|
def _fmt_state(subsystem: str) -> str:
|
|
on = wa.write_approval_enabled(subsystem)
|
|
return f"{subsystem}.write_approval = {'on' if on else 'off'}"
|
|
|
|
|
|
def _fmt_pending_list(subsystem: str) -> str:
|
|
records = wa.list_pending(subsystem)
|
|
if not records:
|
|
return f"No pending {subsystem} writes."
|
|
lines = [f"Pending {subsystem} writes ({len(records)}):"]
|
|
for r in records:
|
|
origin = r.get("origin", "foreground")
|
|
tag = " [auto]" if origin == "background_review" else ""
|
|
lines.append(f" {r['id']}{tag} {r.get('summary', '')}")
|
|
if subsystem == wa.MEMORY:
|
|
lines.extend(f" {line}" for line in _matched_entries(r["payload"]))
|
|
lines.append("")
|
|
lines.append(f"Apply: /{subsystem} approve <id> Reject: /{subsystem} reject <id>")
|
|
if subsystem == wa.SKILLS:
|
|
lines.append("Review full diff: /skills diff <id>")
|
|
return "\n".join(lines)
|
|
|
|
|
|
def handle_pending_subcommand(
|
|
subsystem: str, args: list[str], *, memory_store=None, set_mode_fn=None) -> Optional[str]:
|
|
"""Dispatch a /memory or /skills write-approval subcommand.
|
|
|
|
``memory_store`` applies approved memory writes (CLI passes its live store; gateway a freshly
|
|
loaded one); ``set_mode_fn`` persists the write_approval boolean. Returns text for the user,
|
|
or None when the args are not a write-approval subcommand so the caller falls through to its
|
|
other handling (e.g. /skills search).
|
|
"""
|
|
if not args:
|
|
return f"{_fmt_state(subsystem)}\n\n" + _fmt_pending_list(subsystem)
|
|
sub, rest = args[0].lower(), args[1:]
|
|
if sub == "pending":
|
|
return _fmt_pending_list(subsystem)
|
|
if sub in {"approve", "apply"}:
|
|
return _approve(subsystem, rest, memory_store)
|
|
if sub in {"reject", "deny", "drop"}:
|
|
return _reject(subsystem, rest)
|
|
if sub == "diff" and subsystem == wa.SKILLS:
|
|
return _diff(rest)
|
|
if sub in {"approval", "mode"}: # 'mode' kept as a back-compat alias
|
|
return _set_approval(subsystem, rest, set_mode_fn)
|
|
return None # not ours — caller handles
|
|
|
|
|
|
def _usage(subsystem: str) -> str:
|
|
return f"Usage: /{subsystem} approve|reject <id> (or 'all')"
|
|
|
|
|
|
def _approve(subsystem: str, rest: list[str], memory_store) -> str:
|
|
if not rest:
|
|
return _usage(subsystem)
|
|
target = rest[0]
|
|
records = wa.list_pending(subsystem)
|
|
if not records:
|
|
return f"No pending {subsystem} writes."
|
|
if target.lower() == "all":
|
|
targets = list(records)
|
|
else:
|
|
rec = wa.get_pending(subsystem, target)
|
|
if not rec:
|
|
return f"No pending {subsystem} write with id '{target}'."
|
|
targets = [rec]
|
|
|
|
applied, failed, overwritten, patched, removed = 0, [], [], [], []
|
|
for rec in targets:
|
|
ok, msg, result = _apply_one(subsystem, rec, memory_store)
|
|
if ok:
|
|
wa.discard_pending(subsystem, rec["id"])
|
|
applied += 1
|
|
overwritten.extend(f" {rec['id']}: {text}" for text in _changed_entries(result, "replaced"))
|
|
patched.extend(f" {rec['id']}: {text}" for text in _changed_entries(result, "patched"))
|
|
removed.extend(f" {rec['id']}: {text}" for text in _changed_entries(result, "removed"))
|
|
else:
|
|
failed.append(f"{rec['id']}: {msg}")
|
|
|
|
out = [f"Approved {applied} {subsystem} write(s)."]
|
|
if overwritten:
|
|
# A memory 'replace' overwrites the WHOLE matched entry (#117952); the approver
|
|
# is the last person who can notice a clause went missing, so show what was lost.
|
|
out.append("Overwrote entire entry (re-add anything you still need):")
|
|
out.extend(overwritten)
|
|
if patched:
|
|
# A patch keeps the rest of the entry, so show it as it was, not as lost text.
|
|
out.append("Patched entry (as it was before the edit):")
|
|
out.extend(patched)
|
|
if removed:
|
|
out.append("Removed entry (re-add anything you still need):")
|
|
out.extend(removed)
|
|
if failed:
|
|
out.append("Failed:")
|
|
out.extend(f" {f}" for f in failed)
|
|
return "\n".join(out)
|
|
|
|
|
|
def _changed_entries(result: dict, kind: str) -> list[str]:
|
|
"""Full text of every entry a memory write changed, single-op or batch shape."""
|
|
single = result.get(f"{kind}_entry")
|
|
if kind == "patched" and single is None:
|
|
single = result.get("patched_entry_before")
|
|
batch = result.get(f"{kind}_entries") or {}
|
|
return ([single] if single else []) + [batch[k] for k in sorted(batch, key=int)]
|
|
|
|
|
|
def _matched_entries(payload) -> list[str]:
|
|
"""The full entry each staged memory replace/remove is pinned to: the summary shows only
|
|
the old_text search string, and approval applies to this entry, not to that search."""
|
|
from tools.memory_tool import destructive_ops
|
|
return [f"{op['action']}s entry: {op['matched_entry']}" if op.get("matched_entry")
|
|
else f"{op['action']}: unpinned legacy target \u2014 reject and recreate before approving"
|
|
for op in destructive_ops(payload)]
|
|
|
|
|
|
def _apply_one(subsystem: str, rec, memory_store):
|
|
"""``(ok, error, result)`` — *result* is the applier's full payload (empty on exceptions)."""
|
|
payload = rec.get("payload", {})
|
|
try:
|
|
if subsystem == wa.MEMORY:
|
|
if memory_store is None:
|
|
return False, "memory store unavailable", {}
|
|
from tools.memory_tool import apply_memory_pending
|
|
result = apply_memory_pending(payload, memory_store)
|
|
else:
|
|
from tools.skill_manager_tool import apply_skill_pending
|
|
result = json.loads(apply_skill_pending(payload, origin=rec.get("origin", "foreground")))
|
|
return bool(result.get("success")), result.get("error", ""), result
|
|
except Exception as e:
|
|
return False, str(e), {}
|
|
|
|
|
|
def _reject(subsystem: str, rest: list[str]) -> str:
|
|
if not rest:
|
|
return _usage(subsystem)
|
|
target = rest[0]
|
|
if target.lower() == "all":
|
|
n = sum(1 for rec in wa.list_pending(subsystem) if wa.discard_pending(subsystem, rec["id"]))
|
|
return f"Rejected {n} pending {subsystem} write(s)."
|
|
if wa.discard_pending(subsystem, target):
|
|
return f"Rejected pending {subsystem} write '{target}'."
|
|
return f"No pending {subsystem} write with id '{target}'."
|
|
|
|
|
|
def _diff(rest: list[str]) -> str:
|
|
if not rest:
|
|
return "Usage: /skills diff <id>"
|
|
rec = wa.get_pending(wa.SKILLS, rest[0])
|
|
if not rec:
|
|
return f"No pending skill write with id '{rest[0]}'."
|
|
return f"# Pending skill write {rec['id']}: {rec.get('summary', '')}\n\n" + wa.skill_pending_diff(rec)
|
|
|
|
|
|
_APPROVAL_VALUES = {
|
|
**dict.fromkeys(("on", "true", "yes", "1", "enable", "enabled"), True),
|
|
**dict.fromkeys(("off", "false", "no", "0", "disable", "disabled"), False)}
|
|
|
|
|
|
def _set_approval(subsystem: str, rest: list[str], set_mode_fn) -> str:
|
|
"""Turn the approval gate on/off for a subsystem."""
|
|
if not rest:
|
|
return (f"{_fmt_state(subsystem)}\n"
|
|
f"Set with: /{subsystem} approval <on|off>")
|
|
arg = rest[0].strip().lower()
|
|
enabled = _APPROVAL_VALUES.get(arg)
|
|
if enabled is None:
|
|
return f"Invalid value '{arg}'. Use: on or off."
|
|
if set_mode_fn is None:
|
|
val = "true" if enabled else "false"
|
|
return (f"To change the {subsystem} approval gate, run:\n"
|
|
f" hermes config set {subsystem}.write_approval {val}")
|
|
try:
|
|
set_mode_fn(enabled)
|
|
except Exception as e:
|
|
return f"Failed to set {subsystem}.write_approval: {e}"
|
|
return f"{subsystem}.write_approval set to '{'on' if enabled else 'off'}'."
|