astrbot_plugin_private_comp.../bot_personal_dto.py

259 行
9.1 KiB
Python

# -*- coding: utf-8 -*-
"""Privacy-limited DTOs for the Bot Personal archive boundary."""
from __future__ import annotations
from copy import deepcopy
from dataclasses import dataclass
from datetime import datetime
import json
import re
from typing import Any
from .bot_personal_contract import (
BOT_PERSONAL_MEMORY_DOMAIN,
BOT_PERSONAL_MEMORY_TYPES,
BOT_PERSONAL_PAYLOAD_SCHEMA_VERSION,
BOT_PERSONAL_SUBJECT,
TYPE_CONTRACTS,
normalize_window,
window_for_minutes,
)
FORBIDDEN_KEY_PARTS = {
"prompt", "conversation", "chat_history", "transcript", "message_chain", "contexts",
"cookie", "token", "password", "passwd", "secret", "credential", "authorization",
"api_key", "apikey", "access_key", "private_key", "raw_message", "binary",
"media_bytes", "media_binary", "media_data", "media_content", "media_blob",
"image_bytes", "audio_bytes", "video_bytes", "base64",
}
CERTAINTY_ALIASES = {"high": 0.9, "medium": 0.6, "low": 0.3, "高": 0.9, "中": 0.6, "低": 0.3}
class PrivacyRejected(ValueError):
def __init__(self, path: str, reason: str) -> None:
self.path = path
self.reason = reason
super().__init__(f"privacy_rejected:{path}:{reason}")
def _text(value: Any, limit: int = 240) -> str:
return str(value or "").strip()[:limit]
def _certainty(value: Any, default: float = 0.6) -> float:
if isinstance(value, str):
value = CERTAINTY_ALIASES.get(value.strip().lower(), value)
try:
number = float(value)
except (TypeError, ValueError):
number = default
return max(0.0, min(1.0, number))
def _parse_moment(value: Any) -> datetime | None:
try:
parsed = datetime.fromisoformat(str(value).replace("Z", "+00:00"))
except (TypeError, ValueError):
return None
return parsed
def _looks_sensitive_value(value: str) -> str:
text = value.strip()
lowered = text.lower()
if re.search(r"(?:password|passwd|token|secret|api[_-]?key|authorization)\s*[:=]", lowered):
return "credential_pattern"
if re.search(r"^bearer\s+", lowered):
return "authorization_value"
if "base64," in lowered or lowered.startswith("data:"):
return "base64_or_data_uri"
if "-----begin " in lowered:
return "private_key_material"
if re.search(r"(?:^|[\s=:;,])(?:[a-z]:[\\/]|\\\\|/home/|/root/|/tmp/|/var/|/volume\d+/)", text, re.IGNORECASE):
return "absolute_path"
return ""
def validate_bot_personal_key(value: Any, *, field: str = "idempotency_key") -> None:
reason = _looks_sensitive_value(str(value or ""))
if reason:
raise PrivacyRejected(field, reason)
if not _text(value, 240):
raise PrivacyRejected(field, "missing")
def validate_bot_personal_payload(value: Any, *, path: str = "payload", depth: int = 0) -> None:
if depth > 8:
raise PrivacyRejected(path, "max_depth")
if isinstance(value, dict):
if len(value) > 64:
raise PrivacyRejected(path, "too_many_fields")
for key, item in value.items():
name = _text(key, 80)
lowered = name.lower().replace("-", "_")
if not name or any(part in lowered for part in FORBIDDEN_KEY_PARTS):
raise PrivacyRejected(f"{path}.{name}", "forbidden_key")
validate_bot_personal_payload(item, path=f"{path}.{name}", depth=depth + 1)
return
if isinstance(value, (list, tuple)):
if len(value) > 64:
raise PrivacyRejected(path, "too_many_items")
for index, item in enumerate(value):
validate_bot_personal_payload(item, path=f"{path}[{index}]", depth=depth + 1)
return
if isinstance(value, (bytes, bytearray, memoryview)):
raise PrivacyRejected(path, "binary_media")
if isinstance(value, str):
reason = _looks_sensitive_value(value)
if reason:
raise PrivacyRejected(path, reason)
return
if value is None or isinstance(value, (bool, int, float)):
return
raise PrivacyRejected(path, "unsupported_value")
def _safe_value(value: Any, *, depth: int = 0, max_depth: int = 8) -> Any:
if depth > max_depth:
return None
if isinstance(value, dict):
return {
_text(key, 80): _safe_value(item, depth=depth + 1, max_depth=max_depth)
for key, item in list(value.items())[:64]
if _text(key, 80)
}
if isinstance(value, (list, tuple)):
return [_safe_value(item, depth=depth + 1, max_depth=max_depth) for item in list(value)[:64]]
if isinstance(value, str):
return _text(value, 1200)
if value is None or isinstance(value, (bool, int, float)):
return value
return _text(value, 240)
def _derive_date(value: Any, occurred_at: str, now: datetime) -> str:
explicit = _text(value, 32)
if explicit:
return explicit.split("T", 1)[0]
parsed = _parse_moment(occurred_at) or now.astimezone()
return parsed.date().isoformat()
def _derive_window(value: Any, occurred_at: str, now: datetime) -> str:
explicit = normalize_window(value)
parsed = _parse_moment(occurred_at) or now.astimezone()
if explicit:
return explicit
return window_for_minutes(parsed.hour * 60 + parsed.minute)
@dataclass(frozen=True)
class BotPersonalArchiveDTO:
record_id: str
memory_domain: str
memory_type: str
subject: str
date: str
window: str
window_date: str
occurred_at: str
created_at: str
updated_at: str
source_kind: str
source_refs: list[str]
certainty: float
evidence_level: str
status: str
version: int
idempotency_key: str
payload_schema_version: str
payload: dict[str, Any]
def envelope(self) -> dict[str, Any]:
return {
"record_id": self.record_id,
"memory_domain": self.memory_domain,
"memory_type": self.memory_type,
"subject": self.subject,
"date": self.date,
"window": self.window,
"window_date": self.window_date,
"occurred_at": self.occurred_at,
"created_at": self.created_at,
"updated_at": self.updated_at,
"source_kind": self.source_kind,
"source_refs": list(self.source_refs),
"certainty": self.certainty,
"evidence_level": self.evidence_level,
"status": self.status,
"version": self.version,
"idempotency_key": self.idempotency_key,
"payload_schema_version": self.payload_schema_version,
"payload": deepcopy(self.payload),
}
def build_bot_personal_dto(
*,
memory_type: str,
kind: str = "",
namespace: str = "",
payload: dict[str, Any],
idempotency_key: str,
occurred_at: str,
now: datetime | None = None,
version: int = 1,
) -> BotPersonalArchiveDTO:
del kind, namespace
if memory_type not in BOT_PERSONAL_MEMORY_TYPES:
raise ValueError(f"invalid_memory_type:{memory_type}")
validate_bot_personal_payload(payload)
validate_bot_personal_key(idempotency_key)
current = now or datetime.now().astimezone()
safe = _safe_value(payload) or {}
occurred = _text(occurred_at, 80) or current.isoformat(timespec="seconds")
date_key = _derive_date(safe.get("date") or safe.get("window_date"), occurred, current)
window = _derive_window(safe.get("window"), occurred, current)
if not window:
raise ValueError("invalid_window")
source_refs: list[str] = []
for item in safe.get("source_refs") or []:
ref = _text(item, 240)
if ref and ref not in source_refs:
source_refs.append(ref)
if not source_refs:
source_refs = [f"archive:{_text(idempotency_key, 240)}"]
contract = TYPE_CONTRACTS[memory_type]
source_kind, default_evidence, default_status = contract
evidence = "L0" if memory_type == "bot_schedule_plan" else (_text(safe.get("evidence_level"), 8).upper() or default_evidence)
if evidence not in {"L0", "L1", "L2", "L3"}:
evidence = default_evidence
created_at = _text(safe.get("created_at"), 80) or current.isoformat(timespec="seconds")
updated_at = _text(safe.get("updated_at"), 80) or created_at
record_id = _text(safe.get("record_id"), 160) or f"local:{_text(idempotency_key, 240)}"
return BotPersonalArchiveDTO(
record_id=record_id,
memory_domain=BOT_PERSONAL_MEMORY_DOMAIN,
memory_type=memory_type,
subject=BOT_PERSONAL_SUBJECT,
date=date_key,
window=window,
window_date=date_key,
occurred_at=occurred,
created_at=created_at,
updated_at=updated_at,
source_kind=source_kind,
source_refs=source_refs,
certainty=_certainty(safe.get("certainty"), 0.6),
evidence_level=evidence,
status=_text(safe.get("status"), 32) or default_status,
version=max(1, int(version or 1)),
idempotency_key=_text(idempotency_key, 240),
payload_schema_version=BOT_PERSONAL_PAYLOAD_SCHEMA_VERSION,
payload=deepcopy(safe),
)
def envelope_size_bytes(envelope: dict[str, Any]) -> int:
return len(json.dumps(envelope, ensure_ascii=False, separators=(",", ":")).encode("utf-8"))