Kevin Veen-BirkenbachandClaude Opus 5.5
d09ed61161
Operator tasks move from the Inbox into Tasks with the Waits on Operator filter. Review and commit asks carry the staged diff; a file whose old or new blob holds an armour line or a detection-pattern match, or every file when no pattern loads, ships only its path, status, mode and counts. The approval binds to the staged tree id from git write-tree, the encoded request body respects the hub limit, and the hub image ships every client module signed.py loads. Committed below the bar on the operator's word 2026-11-12 (no further per-bundle tests, one gate after the merge): the full hub suite and the W1 e2e never ran, two high MEDUSA rows (sandbox_paths.py FLOOR, permission_hook.py ask POST) wait for their acceptance. 🎯 Fix: 85 % 💥 Break: 12 % 💸 Cost: 30 % ⏱️ Time: 30 % 🛡️ Security: 50 % 🏆 Score: 100 🚦 Gate: ⛔ fix 85 % < 90, break 12 % > 5; security 50 % < 100: ask the operator before the commit Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
109 lines
3.7 KiB
Python
109 lines
3.7 KiB
Python
from __future__ import annotations
|
|
|
|
import json
|
|
import math
|
|
import re
|
|
|
|
from .errors import ToolError
|
|
from .signed import limits
|
|
|
|
WAIT_CAP = 300
|
|
TEXT_LIMIT = 20_000
|
|
COMMAND_LIMIT = 4000
|
|
PATH_LIMIT = limits.PATH_LIMIT
|
|
NAME_LIMIT = 120
|
|
COUNT = re.compile(r"[0-9]{1,12}")
|
|
PATH = re.compile(rf"/[^\x00-\x1f\x7f]{{0,{PATH_LIMIT - 1}}}")
|
|
LINE = r"(?=[^\x00-\x1f\x7f]*\S)[^\x00-\x1f\x7f]{{1,{0}}}"
|
|
ORDER_NAME = re.compile(r"(?![\s-])[^,\x00-\x1f\x7f]{1,200}")
|
|
FIELDS = {
|
|
"repo": (PATH, "an absolute path"),
|
|
"worktree": (PATH, "an absolute path"),
|
|
"page": (PATH, "an absolute path"),
|
|
"branch": (re.compile(r"[\w./@+-]{1,255}"), "a branch name"),
|
|
"tree": (re.compile(r"[0-9a-f]{40}|[0-9a-f]{64}"), "the hash git write-tree prints"),
|
|
"title": (re.compile(LINE.format(200)), "one line of 1 to 200 characters"),
|
|
"agent": (re.compile(LINE.format(200)), "one line of 1 to 200 characters"),
|
|
"to": (re.compile(LINE.format(200)), "an agent name, one line of 1 to 200 characters"),
|
|
"label": (re.compile(LINE.format(NAME_LIMIT)), f"one line of 1 to {NAME_LIMIT} characters"),
|
|
"tool": (re.compile(LINE.format(200)), "one line of 1 to 200 characters"),
|
|
"id": (re.compile(r"[0-9a-f]{16}"), "an id the Agent Orchestrator returned"),
|
|
}
|
|
|
|
|
|
def expect(arguments: dict, names: tuple[str, ...]) -> None:
|
|
problems = [f"missing argument {name}" for name in names if name not in arguments]
|
|
problems += [f"unknown argument {key}" for key in sorted(map(str, arguments)) if key not in names]
|
|
if problems:
|
|
raise ToolError("; ".join(problems))
|
|
|
|
|
|
def field(arguments: dict, name: str) -> str:
|
|
pattern, hint = FIELDS[name]
|
|
value = arguments[name]
|
|
if not isinstance(value, str) or not pattern.fullmatch(value):
|
|
raise ToolError(f"{name} must be {hint}")
|
|
return value
|
|
|
|
|
|
def bounded(arguments: dict, name: str, limit: int) -> str:
|
|
value = arguments[name]
|
|
if not isinstance(value, str) or len(value) > limit:
|
|
raise ToolError(f"{name} must be text of at most {limit} characters")
|
|
return value
|
|
|
|
|
|
def message_text(arguments: dict, name: str) -> str:
|
|
value = bounded(arguments, name, TEXT_LIMIT)
|
|
if not value.strip():
|
|
raise ToolError(f"{name} must not be empty")
|
|
return value.strip()
|
|
|
|
|
|
def seconds(arguments: dict, name: str, cap: float) -> float:
|
|
value = arguments[name]
|
|
if isinstance(value, bool) or not isinstance(value, int | float) or not 0 <= value < math.inf:
|
|
raise ToolError(f"{name} must be a finite number of seconds, 0 or more")
|
|
return float(min(value, cap))
|
|
|
|
|
|
def decode(body: bytes) -> dict:
|
|
try:
|
|
data = json.loads(body)
|
|
except (ValueError, RecursionError):
|
|
raise ToolError("body must be a JSON object") from None
|
|
if not isinstance(data, dict):
|
|
raise ToolError("body must be a JSON object")
|
|
return data
|
|
|
|
|
|
def single(query: dict[str, list[str]], name: str) -> str | None:
|
|
values = query.get(name)
|
|
if values is None:
|
|
return None
|
|
if len(values) != 1:
|
|
raise ToolError(f"{name} must be given once")
|
|
return values[0]
|
|
|
|
|
|
def instant(query: dict[str, list[str]], name: str) -> float | None:
|
|
text = single(query, name)
|
|
if text is None or text == "":
|
|
return None
|
|
try:
|
|
value = float(text)
|
|
except ValueError:
|
|
raise ToolError(f"{name} must be seconds since the epoch") from None
|
|
if not 0 <= value < 1e11:
|
|
raise ToolError(f"{name} must be seconds since the epoch")
|
|
return value
|
|
|
|
|
|
def whole(query: dict[str, list[str]], name: str) -> int | None:
|
|
text = single(query, name)
|
|
if text is None or text == "":
|
|
return None
|
|
if not COUNT.fullmatch(text):
|
|
raise ToolError(f"{name} must be a whole number")
|
|
return int(text)
|