1066 lines
38 KiB
Python
1066 lines
38 KiB
Python
import json
|
|
import math
|
|
import os
|
|
import re
|
|
import uuid
|
|
from datetime import datetime, timedelta
|
|
from typing import Any, Dict, List, Optional
|
|
|
|
from sqlalchemy import delete as sql_delete, func
|
|
from sqlmodel import Session, select
|
|
|
|
from core.database import engine
|
|
from core.settings import (
|
|
BOTS_WORKSPACE_ROOT,
|
|
DEFAULT_CHAT_PULL_PAGE_SIZE,
|
|
DEFAULT_COMMAND_AUTO_UNLOCK_SECONDS,
|
|
DEFAULT_PAGE_SIZE,
|
|
DEFAULT_STT_AUDIO_FILTER,
|
|
DEFAULT_STT_AUDIO_PREPROCESS,
|
|
DEFAULT_STT_DEFAULT_LANGUAGE,
|
|
DEFAULT_STT_FORCE_SIMPLIFIED,
|
|
DEFAULT_STT_INITIAL_PROMPT,
|
|
DEFAULT_STT_MAX_AUDIO_SECONDS,
|
|
DEFAULT_UPLOAD_MAX_MB,
|
|
DEFAULT_WORKSPACE_DOWNLOAD_EXTENSIONS,
|
|
STT_DEVICE,
|
|
STT_ENABLED_DEFAULT,
|
|
STT_MODEL,
|
|
)
|
|
from models.bot import BotInstance, NanobotImage
|
|
from models.platform import BotActivityEvent, BotRequestUsage, PlatformSetting
|
|
from schemas.platform import (
|
|
LoadingPageSettings,
|
|
PlatformActivityItem,
|
|
PlatformSettingsPayload,
|
|
PlatformUsageResponse,
|
|
PlatformUsageItem,
|
|
PlatformUsageSummary,
|
|
SystemSettingItem,
|
|
SystemSettingPayload,
|
|
)
|
|
|
|
DEFAULT_ALLOWED_ATTACHMENT_EXTENSIONS: tuple[str, ...] = ()
|
|
DEFAULT_ACTIVITY_EVENT_RETENTION_DAYS = 7
|
|
ACTIVITY_EVENT_RETENTION_SETTING_KEY = "activity_event_retention_days"
|
|
ACTIVITY_EVENT_PRUNE_INTERVAL = timedelta(minutes=10)
|
|
OPERATIONAL_ACTIVITY_EVENT_TYPES = {
|
|
"bot_created",
|
|
"bot_started",
|
|
"bot_stopped",
|
|
"bot_enabled",
|
|
"bot_disabled",
|
|
"bot_deactivated",
|
|
"command_submitted",
|
|
"command_failed",
|
|
"history_cleared",
|
|
}
|
|
SETTING_KEYS = (
|
|
"page_size",
|
|
"chat_pull_page_size",
|
|
"command_auto_unlock_seconds",
|
|
"upload_max_mb",
|
|
"allowed_attachment_extensions",
|
|
"workspace_download_extensions",
|
|
"speech_enabled",
|
|
)
|
|
PROTECTED_SETTING_KEYS = set(SETTING_KEYS) | {ACTIVITY_EVENT_RETENTION_SETTING_KEY}
|
|
DEPRECATED_SETTING_KEYS = {
|
|
"loading_page",
|
|
"speech_max_audio_seconds",
|
|
"speech_default_language",
|
|
"speech_force_simplified",
|
|
"speech_audio_preprocess",
|
|
"speech_audio_filter",
|
|
"speech_initial_prompt",
|
|
}
|
|
SYSTEM_SETTING_DEFINITIONS: Dict[str, Dict[str, Any]] = {
|
|
"page_size": {
|
|
"name": "分页大小",
|
|
"category": "ui",
|
|
"description": "平台各类列表默认每页条数。",
|
|
"value_type": "integer",
|
|
"value": DEFAULT_PAGE_SIZE,
|
|
"is_public": True,
|
|
"sort_order": 5,
|
|
},
|
|
"chat_pull_page_size": {
|
|
"name": "对话懒加载条数",
|
|
"category": "chat",
|
|
"description": "Bot 对话区向上懒加载时每次读取的消息条数。",
|
|
"value_type": "integer",
|
|
"value": DEFAULT_CHAT_PULL_PAGE_SIZE,
|
|
"is_public": True,
|
|
"sort_order": 8,
|
|
},
|
|
"command_auto_unlock_seconds": {
|
|
"name": "发送按钮自动恢复秒数",
|
|
"category": "chat",
|
|
"description": "对话发送后按钮保持停止态的最长秒数，超时后自动恢复为可发送状态。",
|
|
"value_type": "integer",
|
|
"value": DEFAULT_COMMAND_AUTO_UNLOCK_SECONDS,
|
|
"is_public": True,
|
|
"sort_order": 9,
|
|
},
|
|
"upload_max_mb": {
|
|
"name": "上传大小限制",
|
|
"category": "upload",
|
|
"description": "单文件上传大小限制，单位 MB。",
|
|
"value_type": "integer",
|
|
"value": DEFAULT_UPLOAD_MAX_MB,
|
|
"is_public": False,
|
|
"sort_order": 10,
|
|
},
|
|
"allowed_attachment_extensions": {
|
|
"name": "允许附件后缀",
|
|
"category": "upload",
|
|
"description": "允许上传的附件后缀列表，留空表示不限制。",
|
|
"value_type": "json",
|
|
"value": list(DEFAULT_ALLOWED_ATTACHMENT_EXTENSIONS),
|
|
"is_public": False,
|
|
"sort_order": 20,
|
|
},
|
|
"workspace_download_extensions": {
|
|
"name": "工作区下载后缀",
|
|
"category": "workspace",
|
|
"description": "命中后缀的工作区文件默认走下载模式。",
|
|
"value_type": "json",
|
|
"value": list(DEFAULT_WORKSPACE_DOWNLOAD_EXTENSIONS),
|
|
"is_public": False,
|
|
"sort_order": 30,
|
|
},
|
|
"speech_enabled": {
|
|
"name": "语音识别开关",
|
|
"category": "speech",
|
|
"description": "控制 Bot 语音转写功能是否启用。",
|
|
"value_type": "boolean",
|
|
"value": STT_ENABLED_DEFAULT,
|
|
"is_public": True,
|
|
"sort_order": 32,
|
|
},
|
|
ACTIVITY_EVENT_RETENTION_SETTING_KEY: {
|
|
"name": "活动事件保留天数",
|
|
"category": "maintenance",
|
|
"description": "bot_activity_event 运维事件的保留天数，超期记录会自动清理。",
|
|
"value_type": "integer",
|
|
"value": DEFAULT_ACTIVITY_EVENT_RETENTION_DAYS,
|
|
"is_public": False,
|
|
"sort_order": 34,
|
|
},
|
|
}
|
|
|
|
_last_activity_event_prune_at: Optional[datetime] = None
|
|
|
|
|
|
def _utcnow() -> datetime:
|
|
return datetime.utcnow()
|
|
|
|
|
|
def _normalize_activity_event_retention_days(raw: Any) -> int:
|
|
try:
|
|
value = int(raw)
|
|
except Exception:
|
|
value = DEFAULT_ACTIVITY_EVENT_RETENTION_DAYS
|
|
return max(1, min(3650, value))
|
|
|
|
|
|
def _normalize_extension(raw: Any) -> str:
|
|
text = str(raw or "").strip().lower()
|
|
if not text:
|
|
return ""
|
|
if text.startswith("*."):
|
|
text = text[1:]
|
|
if not text.startswith("."):
|
|
text = f".{text}"
|
|
if not re.fullmatch(r"\.[a-z0-9][a-z0-9._+-]{0,31}", text):
|
|
return ""
|
|
return text
|
|
|
|
|
|
def _normalize_extension_list(rows: Any) -> List[str]:
|
|
if not isinstance(rows, list):
|
|
return []
|
|
normalized: List[str] = []
|
|
for item in rows:
|
|
ext = _normalize_extension(item)
|
|
if ext and ext not in normalized:
|
|
normalized.append(ext)
|
|
return normalized
|
|
|
|
|
|
def _legacy_env_int(name: str, default: int, min_value: int, max_value: int) -> int:
|
|
raw = os.getenv(name)
|
|
if raw is None:
|
|
return default
|
|
try:
|
|
value = int(str(raw).strip())
|
|
except Exception:
|
|
value = default
|
|
return max(min_value, min(max_value, value))
|
|
|
|
|
|
def _legacy_env_bool(name: str, default: bool) -> bool:
|
|
raw = os.getenv(name)
|
|
if raw is None:
|
|
return default
|
|
return str(raw).strip().lower() in {"1", "true", "yes", "on"}
|
|
|
|
|
|
def _legacy_env_extensions(name: str, default: List[str]) -> List[str]:
|
|
raw = os.getenv(name)
|
|
if raw is None:
|
|
return list(default)
|
|
source = re.split(r"[,;\s]+", str(raw))
|
|
normalized: List[str] = []
|
|
for item in source:
|
|
ext = _normalize_extension(item)
|
|
if ext and ext not in normalized:
|
|
normalized.append(ext)
|
|
return normalized
|
|
|
|
|
|
def _bootstrap_platform_setting_values() -> Dict[str, Any]:
|
|
return {
|
|
"page_size": _legacy_env_int("PAGE_SIZE", DEFAULT_PAGE_SIZE, 1, 100),
|
|
"chat_pull_page_size": _legacy_env_int(
|
|
"CHAT_PULL_PAGE_SIZE",
|
|
DEFAULT_CHAT_PULL_PAGE_SIZE,
|
|
10,
|
|
500,
|
|
),
|
|
"command_auto_unlock_seconds": _legacy_env_int(
|
|
"COMMAND_AUTO_UNLOCK_SECONDS",
|
|
DEFAULT_COMMAND_AUTO_UNLOCK_SECONDS,
|
|
1,
|
|
600,
|
|
),
|
|
"upload_max_mb": _legacy_env_int("UPLOAD_MAX_MB", DEFAULT_UPLOAD_MAX_MB, 1, 2048),
|
|
"allowed_attachment_extensions": _legacy_env_extensions(
|
|
"ALLOWED_ATTACHMENT_EXTENSIONS",
|
|
list(DEFAULT_ALLOWED_ATTACHMENT_EXTENSIONS),
|
|
),
|
|
"workspace_download_extensions": _legacy_env_extensions(
|
|
"WORKSPACE_DOWNLOAD_EXTENSIONS",
|
|
list(DEFAULT_WORKSPACE_DOWNLOAD_EXTENSIONS),
|
|
),
|
|
"speech_enabled": _legacy_env_bool("STT_ENABLED", STT_ENABLED_DEFAULT),
|
|
}
|
|
|
|
|
|
def _bot_workspace_root(bot_id: str) -> str:
|
|
return os.path.abspath(os.path.join(BOTS_WORKSPACE_ROOT, bot_id, ".nanobot", "workspace"))
|
|
|
|
|
|
def _bot_data_root(bot_id: str) -> str:
|
|
return os.path.abspath(os.path.join(BOTS_WORKSPACE_ROOT, bot_id, ".nanobot"))
|
|
|
|
|
|
def _calc_dir_size_bytes(path: str) -> int:
|
|
total = 0
|
|
if not os.path.isdir(path):
|
|
return 0
|
|
for root, _, files in os.walk(path):
|
|
for name in files:
|
|
target = os.path.join(root, name)
|
|
try:
|
|
if os.path.islink(target):
|
|
continue
|
|
total += int(os.path.getsize(target))
|
|
except OSError:
|
|
continue
|
|
return total
|
|
|
|
|
|
def _read_bot_resources(bot_id: str) -> Dict[str, Any]:
|
|
path = os.path.join(_bot_data_root(bot_id), "resources.json")
|
|
raw: Dict[str, Any] = {}
|
|
if os.path.isfile(path):
|
|
try:
|
|
with open(path, "r", encoding="utf-8") as f:
|
|
loaded = json.load(f)
|
|
if isinstance(loaded, dict):
|
|
raw = loaded
|
|
except Exception:
|
|
raw = {}
|
|
|
|
def _safe_float(value: Any, default: float) -> float:
|
|
try:
|
|
return float(value)
|
|
except Exception:
|
|
return default
|
|
|
|
def _safe_int(value: Any, default: int) -> int:
|
|
try:
|
|
return int(value)
|
|
except Exception:
|
|
return default
|
|
|
|
cpu = _safe_float(raw.get("cpuCores", raw.get("cpu_cores", 1.0)), 1.0)
|
|
memory = _safe_int(raw.get("memoryMB", raw.get("memory_mb", 1024)), 1024)
|
|
storage = _safe_int(raw.get("storageGB", raw.get("storage_gb", 10)), 10)
|
|
cpu = 0.0 if cpu == 0 else min(16.0, max(0.1, cpu))
|
|
memory = 0 if memory == 0 else min(65536, max(256, memory))
|
|
storage = 0 if storage == 0 else min(1024, max(1, storage))
|
|
return {
|
|
"cpu_cores": cpu,
|
|
"memory_mb": memory,
|
|
"storage_gb": storage,
|
|
}
|
|
|
|
|
|
def estimate_tokens(text: str) -> int:
|
|
content = str(text or "").strip()
|
|
if not content:
|
|
return 0
|
|
pieces = re.findall(r"[\u4e00-\u9fff]|[A-Za-z0-9_]+|[^\s]", content)
|
|
total = 0
|
|
for piece in pieces:
|
|
if re.fullmatch(r"[\u4e00-\u9fff]", piece):
|
|
total += 1
|
|
elif re.fullmatch(r"[A-Za-z0-9_]+", piece):
|
|
total += max(1, math.ceil(len(piece) / 4))
|
|
else:
|
|
total += 1
|
|
return max(1, total)
|
|
|
|
|
|
def default_platform_settings() -> PlatformSettingsPayload:
|
|
bootstrap = _bootstrap_platform_setting_values()
|
|
return PlatformSettingsPayload(
|
|
page_size=int(bootstrap["page_size"]),
|
|
chat_pull_page_size=int(bootstrap["chat_pull_page_size"]),
|
|
command_auto_unlock_seconds=int(bootstrap["command_auto_unlock_seconds"]),
|
|
upload_max_mb=int(bootstrap["upload_max_mb"]),
|
|
allowed_attachment_extensions=list(bootstrap["allowed_attachment_extensions"]),
|
|
workspace_download_extensions=list(bootstrap["workspace_download_extensions"]),
|
|
speech_enabled=bool(bootstrap["speech_enabled"]),
|
|
speech_max_audio_seconds=DEFAULT_STT_MAX_AUDIO_SECONDS,
|
|
speech_default_language=DEFAULT_STT_DEFAULT_LANGUAGE,
|
|
speech_force_simplified=DEFAULT_STT_FORCE_SIMPLIFIED,
|
|
speech_audio_preprocess=DEFAULT_STT_AUDIO_PREPROCESS,
|
|
speech_audio_filter=DEFAULT_STT_AUDIO_FILTER,
|
|
speech_initial_prompt=DEFAULT_STT_INITIAL_PROMPT,
|
|
loading_page=LoadingPageSettings(),
|
|
)
|
|
|
|
|
|
def _normalize_setting_key(raw: Any) -> str:
|
|
text = str(raw or "").strip()
|
|
return re.sub(r"[^a-zA-Z0-9_.-]+", "_", text).strip("._-").lower()
|
|
|
|
|
|
def _normalize_setting_value(value: Any, value_type: str) -> Any:
|
|
normalized_type = str(value_type or "json").strip().lower() or "json"
|
|
if normalized_type == "integer":
|
|
return int(value or 0)
|
|
if normalized_type == "float":
|
|
return float(value or 0)
|
|
if normalized_type == "boolean":
|
|
if isinstance(value, bool):
|
|
return value
|
|
return str(value or "").strip().lower() in {"1", "true", "yes", "on"}
|
|
if normalized_type == "string":
|
|
return str(value or "")
|
|
if normalized_type == "json":
|
|
return value
|
|
raise ValueError(f"Unsupported value_type: {normalized_type}")
|
|
|
|
|
|
def _read_setting_value(row: PlatformSetting) -> Any:
|
|
try:
|
|
value = json.loads(row.value_json or "null")
|
|
except Exception:
|
|
value = None
|
|
return _normalize_setting_value(value, row.value_type)
|
|
|
|
|
|
def _setting_item_from_row(row: PlatformSetting) -> Dict[str, Any]:
|
|
return SystemSettingItem(
|
|
key=row.key,
|
|
name=row.name,
|
|
category=row.category,
|
|
description=row.description,
|
|
value_type=row.value_type,
|
|
value=_read_setting_value(row),
|
|
is_public=bool(row.is_public),
|
|
sort_order=int(row.sort_order or 100),
|
|
created_at=row.created_at.isoformat() + "Z",
|
|
updated_at=row.updated_at.isoformat() + "Z",
|
|
).model_dump()
|
|
|
|
|
|
def _upsert_setting_row(
|
|
session: Session,
|
|
key: str,
|
|
*,
|
|
name: str,
|
|
category: str,
|
|
description: str,
|
|
value_type: str,
|
|
value: Any,
|
|
is_public: bool,
|
|
sort_order: int,
|
|
) -> PlatformSetting:
|
|
normalized_key = _normalize_setting_key(key)
|
|
if not normalized_key:
|
|
raise ValueError("Setting key is required")
|
|
normalized_type = str(value_type or "json").strip().lower() or "json"
|
|
normalized_value = _normalize_setting_value(value, normalized_type)
|
|
now = _utcnow()
|
|
row = session.get(PlatformSetting, normalized_key)
|
|
if row is None:
|
|
row = PlatformSetting(
|
|
key=normalized_key,
|
|
name=str(name or normalized_key),
|
|
category=str(category or "general"),
|
|
description=str(description or ""),
|
|
value_type=normalized_type,
|
|
value_json=json.dumps(normalized_value, ensure_ascii=False),
|
|
is_public=bool(is_public),
|
|
sort_order=int(sort_order or 100),
|
|
created_at=now,
|
|
updated_at=now,
|
|
)
|
|
else:
|
|
row.name = str(name or row.name or normalized_key)
|
|
row.category = str(category or row.category or "general")
|
|
row.description = str(description or row.description or "")
|
|
row.value_type = normalized_type
|
|
row.value_json = json.dumps(normalized_value, ensure_ascii=False)
|
|
row.is_public = bool(is_public)
|
|
row.sort_order = int(sort_order or row.sort_order or 100)
|
|
row.updated_at = now
|
|
session.add(row)
|
|
return row
|
|
|
|
|
|
def ensure_default_system_settings(session: Session) -> None:
|
|
bootstrap_values = _bootstrap_platform_setting_values()
|
|
legacy_row = session.get(PlatformSetting, "global")
|
|
if legacy_row is not None:
|
|
try:
|
|
legacy_data = json.loads(legacy_row.value_json or "{}")
|
|
except Exception:
|
|
legacy_data = {}
|
|
if isinstance(legacy_data, dict):
|
|
for key in SETTING_KEYS:
|
|
meta = SYSTEM_SETTING_DEFINITIONS[key]
|
|
_upsert_setting_row(
|
|
session,
|
|
key,
|
|
name=str(meta["name"]),
|
|
category=str(meta["category"]),
|
|
description=str(meta["description"]),
|
|
value_type=str(meta["value_type"]),
|
|
value=legacy_data.get(key, bootstrap_values.get(key, meta["value"])),
|
|
is_public=bool(meta["is_public"]),
|
|
sort_order=int(meta["sort_order"]),
|
|
)
|
|
session.delete(legacy_row)
|
|
session.commit()
|
|
|
|
dirty = False
|
|
for key in DEPRECATED_SETTING_KEYS:
|
|
legacy_row = session.get(PlatformSetting, key)
|
|
if legacy_row is not None:
|
|
session.delete(legacy_row)
|
|
dirty = True
|
|
|
|
for key, meta in SYSTEM_SETTING_DEFINITIONS.items():
|
|
row = session.get(PlatformSetting, key)
|
|
if row is None:
|
|
_upsert_setting_row(
|
|
session,
|
|
key,
|
|
name=str(meta["name"]),
|
|
category=str(meta["category"]),
|
|
description=str(meta["description"]),
|
|
value_type=str(meta["value_type"]),
|
|
value=bootstrap_values.get(key, meta["value"]),
|
|
is_public=bool(meta["is_public"]),
|
|
sort_order=int(meta["sort_order"]),
|
|
)
|
|
dirty = True
|
|
continue
|
|
changed = False
|
|
for field in ("name", "category", "description", "value_type"):
|
|
value = str(meta[field])
|
|
if not getattr(row, field):
|
|
setattr(row, field, value)
|
|
changed = True
|
|
if getattr(row, "sort_order", None) is None:
|
|
row.sort_order = int(meta["sort_order"])
|
|
changed = True
|
|
if getattr(row, "is_public", None) is None:
|
|
row.is_public = bool(meta["is_public"])
|
|
changed = True
|
|
if changed:
|
|
row.updated_at = _utcnow()
|
|
session.add(row)
|
|
dirty = True
|
|
if dirty:
|
|
session.commit()
|
|
|
|
|
|
def list_system_settings(session: Session, search: str = "") -> List[Dict[str, Any]]:
|
|
ensure_default_system_settings(session)
|
|
stmt = select(PlatformSetting).order_by(PlatformSetting.sort_order.asc(), PlatformSetting.key.asc())
|
|
rows = session.exec(stmt).all()
|
|
keyword = str(search or "").strip().lower()
|
|
items = [_setting_item_from_row(row) for row in rows]
|
|
if not keyword:
|
|
return items
|
|
return [
|
|
item
|
|
for item in items
|
|
if keyword in str(item["key"]).lower()
|
|
or keyword in str(item["name"]).lower()
|
|
or keyword in str(item["category"]).lower()
|
|
or keyword in str(item["description"]).lower()
|
|
]
|
|
|
|
|
|
def create_or_update_system_setting(session: Session, payload: SystemSettingPayload) -> Dict[str, Any]:
|
|
ensure_default_system_settings(session)
|
|
normalized_key = _normalize_setting_key(payload.key)
|
|
definition = SYSTEM_SETTING_DEFINITIONS.get(normalized_key, {})
|
|
row = _upsert_setting_row(
|
|
session,
|
|
payload.key,
|
|
name=payload.name or str(definition.get("name") or payload.key),
|
|
category=payload.category or str(definition.get("category") or "general"),
|
|
description=payload.description or str(definition.get("description") or ""),
|
|
value_type=payload.value_type or str(definition.get("value_type") or "json"),
|
|
value=payload.value if payload.value is not None else definition.get("value"),
|
|
is_public=payload.is_public,
|
|
sort_order=payload.sort_order or int(definition.get("sort_order") or 100),
|
|
)
|
|
if normalized_key == ACTIVITY_EVENT_RETENTION_SETTING_KEY:
|
|
prune_expired_activity_events(session, force=True)
|
|
session.commit()
|
|
session.refresh(row)
|
|
return _setting_item_from_row(row)
|
|
|
|
|
|
def delete_system_setting(session: Session, key: str) -> None:
|
|
normalized_key = _normalize_setting_key(key)
|
|
if normalized_key in PROTECTED_SETTING_KEYS:
|
|
raise ValueError("Core platform settings cannot be deleted")
|
|
row = session.get(PlatformSetting, normalized_key)
|
|
if row is None:
|
|
raise ValueError("Setting not found")
|
|
session.delete(row)
|
|
session.commit()
|
|
|
|
|
|
def get_platform_settings(session: Session) -> PlatformSettingsPayload:
|
|
defaults = default_platform_settings()
|
|
ensure_default_system_settings(session)
|
|
rows = session.exec(select(PlatformSetting).where(PlatformSetting.key.in_(SETTING_KEYS))).all()
|
|
data: Dict[str, Any] = {row.key: _read_setting_value(row) for row in rows}
|
|
|
|
merged = defaults.model_dump()
|
|
merged["page_size"] = max(1, min(100, int(data.get("page_size") or merged["page_size"])))
|
|
merged["chat_pull_page_size"] = max(10, min(500, int(data.get("chat_pull_page_size") or merged["chat_pull_page_size"])))
|
|
merged["command_auto_unlock_seconds"] = max(
|
|
1,
|
|
min(600, int(data.get("command_auto_unlock_seconds") or merged["command_auto_unlock_seconds"]))
|
|
)
|
|
merged["upload_max_mb"] = int(data.get("upload_max_mb") or merged["upload_max_mb"])
|
|
merged["allowed_attachment_extensions"] = _normalize_extension_list(
|
|
data.get("allowed_attachment_extensions", merged["allowed_attachment_extensions"])
|
|
)
|
|
merged["workspace_download_extensions"] = _normalize_extension_list(
|
|
data.get("workspace_download_extensions", merged["workspace_download_extensions"])
|
|
)
|
|
merged["speech_enabled"] = bool(data.get("speech_enabled", merged["speech_enabled"]))
|
|
loading_page = data.get("loading_page")
|
|
if isinstance(loading_page, dict):
|
|
current = dict(merged["loading_page"])
|
|
for key in ("title", "subtitle", "description"):
|
|
value = str(loading_page.get(key) or "").strip()
|
|
if value:
|
|
current[key] = value
|
|
merged["loading_page"] = current
|
|
return PlatformSettingsPayload.model_validate(merged)
|
|
|
|
|
|
def save_platform_settings(session: Session, payload: PlatformSettingsPayload) -> PlatformSettingsPayload:
|
|
normalized = PlatformSettingsPayload(
|
|
page_size=max(1, min(100, int(payload.page_size))),
|
|
chat_pull_page_size=max(10, min(500, int(payload.chat_pull_page_size))),
|
|
command_auto_unlock_seconds=max(1, min(600, int(payload.command_auto_unlock_seconds))),
|
|
upload_max_mb=payload.upload_max_mb,
|
|
allowed_attachment_extensions=_normalize_extension_list(payload.allowed_attachment_extensions),
|
|
workspace_download_extensions=_normalize_extension_list(payload.workspace_download_extensions),
|
|
speech_enabled=bool(payload.speech_enabled),
|
|
loading_page=LoadingPageSettings.model_validate(payload.loading_page.model_dump()),
|
|
)
|
|
payload_by_key = normalized.model_dump()
|
|
for key in SETTING_KEYS:
|
|
definition = SYSTEM_SETTING_DEFINITIONS[key]
|
|
_upsert_setting_row(
|
|
session,
|
|
key,
|
|
name=str(definition["name"]),
|
|
category=str(definition["category"]),
|
|
description=str(definition["description"]),
|
|
value_type=str(definition["value_type"]),
|
|
value=payload_by_key[key],
|
|
is_public=bool(definition["is_public"]),
|
|
sort_order=int(definition["sort_order"]),
|
|
)
|
|
session.commit()
|
|
return normalized
|
|
|
|
|
|
def get_platform_settings_snapshot() -> PlatformSettingsPayload:
|
|
with Session(engine) as session:
|
|
return get_platform_settings(session)
|
|
|
|
|
|
def get_upload_max_mb() -> int:
|
|
return get_platform_settings_snapshot().upload_max_mb
|
|
|
|
|
|
def get_allowed_attachment_extensions() -> List[str]:
|
|
return get_platform_settings_snapshot().allowed_attachment_extensions
|
|
|
|
|
|
def get_workspace_download_extensions() -> List[str]:
|
|
return get_platform_settings_snapshot().workspace_download_extensions
|
|
|
|
|
|
def get_page_size() -> int:
|
|
return get_platform_settings_snapshot().page_size
|
|
|
|
|
|
def get_chat_pull_page_size() -> int:
|
|
return get_platform_settings_snapshot().chat_pull_page_size
|
|
|
|
|
|
def get_speech_runtime_settings() -> Dict[str, Any]:
|
|
settings = get_platform_settings_snapshot()
|
|
return {
|
|
"enabled": bool(settings.speech_enabled),
|
|
"max_audio_seconds": int(DEFAULT_STT_MAX_AUDIO_SECONDS),
|
|
"default_language": str(DEFAULT_STT_DEFAULT_LANGUAGE or "zh").strip().lower() or "zh",
|
|
"force_simplified": bool(DEFAULT_STT_FORCE_SIMPLIFIED),
|
|
"audio_preprocess": bool(DEFAULT_STT_AUDIO_PREPROCESS),
|
|
"audio_filter": str(DEFAULT_STT_AUDIO_FILTER or "").strip(),
|
|
"initial_prompt": str(DEFAULT_STT_INITIAL_PROMPT or "").strip(),
|
|
"model": STT_MODEL,
|
|
"device": STT_DEVICE,
|
|
}
|
|
|
|
|
|
def get_activity_event_retention_days(session: Session) -> int:
|
|
row = session.get(PlatformSetting, ACTIVITY_EVENT_RETENTION_SETTING_KEY)
|
|
if row is None:
|
|
return DEFAULT_ACTIVITY_EVENT_RETENTION_DAYS
|
|
try:
|
|
value = _read_setting_value(row)
|
|
except Exception:
|
|
value = DEFAULT_ACTIVITY_EVENT_RETENTION_DAYS
|
|
return _normalize_activity_event_retention_days(value)
|
|
|
|
|
|
def create_usage_request(
|
|
session: Session,
|
|
bot_id: str,
|
|
command: str,
|
|
attachments: Optional[List[str]] = None,
|
|
channel: str = "dashboard",
|
|
metadata: Optional[Dict[str, Any]] = None,
|
|
provider: Optional[str] = None,
|
|
model: Optional[str] = None,
|
|
) -> str:
|
|
request_id = uuid.uuid4().hex
|
|
rows = [str(item).strip() for item in (attachments or []) if str(item).strip()]
|
|
input_tokens = estimate_tokens(command)
|
|
usage = BotRequestUsage(
|
|
bot_id=bot_id,
|
|
request_id=request_id,
|
|
channel=channel,
|
|
status="PENDING",
|
|
provider=(str(provider or "").strip() or None),
|
|
model=(str(model or "").strip() or None),
|
|
token_source="estimated",
|
|
input_tokens=input_tokens,
|
|
output_tokens=0,
|
|
total_tokens=input_tokens,
|
|
input_text_preview=str(command or "")[:400],
|
|
attachments_json=json.dumps(rows, ensure_ascii=False) if rows else None,
|
|
metadata_json=json.dumps(metadata or {}, ensure_ascii=False),
|
|
started_at=_utcnow(),
|
|
created_at=_utcnow(),
|
|
updated_at=_utcnow(),
|
|
)
|
|
session.add(usage)
|
|
session.flush()
|
|
return request_id
|
|
|
|
|
|
def bind_usage_message(
|
|
session: Session,
|
|
bot_id: str,
|
|
request_id: str,
|
|
message_id: Optional[int],
|
|
) -> Optional[BotRequestUsage]:
|
|
if not request_id or not message_id:
|
|
return None
|
|
usage_row = _find_pending_usage_by_request_id(session, bot_id, request_id)
|
|
if not usage_row:
|
|
return None
|
|
usage_row.message_id = int(message_id)
|
|
usage_row.updated_at = _utcnow()
|
|
session.add(usage_row)
|
|
return usage_row
|
|
|
|
|
|
def _find_latest_pending_usage(session: Session, bot_id: str) -> Optional[BotRequestUsage]:
|
|
stmt = (
|
|
select(BotRequestUsage)
|
|
.where(BotRequestUsage.bot_id == bot_id)
|
|
.where(BotRequestUsage.status == "PENDING")
|
|
.order_by(BotRequestUsage.started_at.desc(), BotRequestUsage.id.desc())
|
|
.limit(1)
|
|
)
|
|
return session.exec(stmt).first()
|
|
|
|
|
|
def _find_pending_usage_by_request_id(session: Session, bot_id: str, request_id: str) -> Optional[BotRequestUsage]:
|
|
if not request_id:
|
|
return None
|
|
stmt = (
|
|
select(BotRequestUsage)
|
|
.where(BotRequestUsage.bot_id == bot_id)
|
|
.where(BotRequestUsage.request_id == request_id)
|
|
.where(BotRequestUsage.status == "PENDING")
|
|
.order_by(BotRequestUsage.started_at.desc(), BotRequestUsage.id.desc())
|
|
.limit(1)
|
|
)
|
|
return session.exec(stmt).first()
|
|
|
|
|
|
def finalize_usage_from_packet(session: Session, bot_id: str, packet: Dict[str, Any]) -> Optional[BotRequestUsage]:
|
|
request_id = str(packet.get("request_id") or "").strip()
|
|
usage_row = _find_pending_usage_by_request_id(session, bot_id, request_id) or _find_latest_pending_usage(session, bot_id)
|
|
if not usage_row:
|
|
return None
|
|
|
|
raw_usage = packet.get("usage")
|
|
input_tokens: Optional[int] = None
|
|
output_tokens: Optional[int] = None
|
|
source = "estimated"
|
|
if isinstance(raw_usage, dict):
|
|
for key in ("input_tokens", "prompt_tokens", "promptTokens"):
|
|
if raw_usage.get(key) is not None:
|
|
try:
|
|
input_tokens = int(raw_usage.get(key) or 0)
|
|
except Exception:
|
|
input_tokens = None
|
|
break
|
|
for key in ("output_tokens", "completion_tokens", "completionTokens"):
|
|
if raw_usage.get(key) is not None:
|
|
try:
|
|
output_tokens = int(raw_usage.get(key) or 0)
|
|
except Exception:
|
|
output_tokens = None
|
|
break
|
|
if input_tokens is not None or output_tokens is not None:
|
|
source = "exact"
|
|
|
|
text = str(packet.get("text") or packet.get("content") or "").strip()
|
|
provider = str(packet.get("provider") or "").strip()
|
|
model = str(packet.get("model") or "").strip()
|
|
message_id = packet.get("message_id")
|
|
if input_tokens is None:
|
|
input_tokens = usage_row.input_tokens
|
|
if output_tokens is None:
|
|
output_tokens = estimate_tokens(text)
|
|
if source == "exact":
|
|
source = "mixed"
|
|
|
|
if provider:
|
|
usage_row.provider = provider[:120]
|
|
if model:
|
|
usage_row.model = model[:255]
|
|
if message_id is not None:
|
|
try:
|
|
usage_row.message_id = int(message_id)
|
|
except Exception:
|
|
pass
|
|
usage_row.output_tokens = max(0, int(output_tokens or 0))
|
|
usage_row.input_tokens = max(0, int(input_tokens or 0))
|
|
usage_row.total_tokens = usage_row.input_tokens + usage_row.output_tokens
|
|
usage_row.output_text_preview = text[:400] if text else usage_row.output_text_preview
|
|
usage_row.status = "COMPLETED"
|
|
usage_row.token_source = source
|
|
usage_row.completed_at = _utcnow()
|
|
usage_row.updated_at = _utcnow()
|
|
session.add(usage_row)
|
|
return usage_row
|
|
|
|
|
|
def fail_latest_usage(session: Session, bot_id: str, detail: str) -> Optional[BotRequestUsage]:
|
|
usage_row = _find_latest_pending_usage(session, bot_id)
|
|
if not usage_row:
|
|
return None
|
|
usage_row.status = "ERROR"
|
|
usage_row.error_text = str(detail or "")[:500]
|
|
usage_row.completed_at = _utcnow()
|
|
usage_row.updated_at = _utcnow()
|
|
session.add(usage_row)
|
|
return usage_row
|
|
|
|
|
|
def prune_expired_activity_events(session: Session, force: bool = False) -> int:
|
|
global _last_activity_event_prune_at
|
|
|
|
now = _utcnow()
|
|
if not force and _last_activity_event_prune_at and now - _last_activity_event_prune_at < ACTIVITY_EVENT_PRUNE_INTERVAL:
|
|
return 0
|
|
|
|
retention_days = get_activity_event_retention_days(session)
|
|
cutoff = now - timedelta(days=retention_days)
|
|
result = session.exec(
|
|
sql_delete(BotActivityEvent).where(BotActivityEvent.created_at < cutoff)
|
|
)
|
|
_last_activity_event_prune_at = now
|
|
return int(getattr(result, "rowcount", 0) or 0)
|
|
|
|
|
|
def record_activity_event(
|
|
session: Session,
|
|
bot_id: str,
|
|
event_type: str,
|
|
request_id: Optional[str] = None,
|
|
channel: str = "dashboard",
|
|
detail: Optional[str] = None,
|
|
metadata: Optional[Dict[str, Any]] = None,
|
|
) -> None:
|
|
normalized_event_type = str(event_type or "unknown").strip().lower() or "unknown"
|
|
if normalized_event_type not in OPERATIONAL_ACTIVITY_EVENT_TYPES:
|
|
return
|
|
prune_expired_activity_events(session, force=False)
|
|
row = BotActivityEvent(
|
|
bot_id=bot_id,
|
|
request_id=request_id,
|
|
event_type=normalized_event_type,
|
|
channel=str(channel or "dashboard").strip().lower() or "dashboard",
|
|
detail=(str(detail or "").strip() or None),
|
|
metadata_json=json.dumps(metadata or {}, ensure_ascii=False) if metadata else None,
|
|
created_at=_utcnow(),
|
|
)
|
|
session.add(row)
|
|
|
|
|
|
def list_usage(
|
|
session: Session,
|
|
bot_id: Optional[str] = None,
|
|
limit: int = 100,
|
|
offset: int = 0,
|
|
) -> Dict[str, Any]:
|
|
safe_limit = max(1, min(int(limit), 500))
|
|
safe_offset = max(0, int(offset or 0))
|
|
stmt = (
|
|
select(BotRequestUsage)
|
|
.order_by(BotRequestUsage.started_at.desc(), BotRequestUsage.id.desc())
|
|
.offset(safe_offset)
|
|
.limit(safe_limit)
|
|
)
|
|
summary_stmt = select(
|
|
func.count(BotRequestUsage.id),
|
|
func.coalesce(func.sum(BotRequestUsage.input_tokens), 0),
|
|
func.coalesce(func.sum(BotRequestUsage.output_tokens), 0),
|
|
func.coalesce(func.sum(BotRequestUsage.total_tokens), 0),
|
|
)
|
|
total_stmt = select(func.count(BotRequestUsage.id))
|
|
if bot_id:
|
|
stmt = stmt.where(BotRequestUsage.bot_id == bot_id)
|
|
summary_stmt = summary_stmt.where(BotRequestUsage.bot_id == bot_id)
|
|
total_stmt = total_stmt.where(BotRequestUsage.bot_id == bot_id)
|
|
else:
|
|
since = _utcnow() - timedelta(days=1)
|
|
summary_stmt = summary_stmt.where(BotRequestUsage.created_at >= since)
|
|
rows = session.exec(stmt).all()
|
|
count, input_sum, output_sum, total_sum = session.exec(summary_stmt).one()
|
|
total = int(session.exec(total_stmt).one() or 0)
|
|
items = [
|
|
PlatformUsageItem(
|
|
id=int(row.id or 0),
|
|
bot_id=row.bot_id,
|
|
message_id=int(row.message_id) if row.message_id is not None else None,
|
|
request_id=row.request_id,
|
|
channel=row.channel,
|
|
status=row.status,
|
|
provider=row.provider,
|
|
model=row.model,
|
|
token_source=row.token_source,
|
|
content=row.input_text_preview or row.output_text_preview,
|
|
input_tokens=int(row.input_tokens or 0),
|
|
output_tokens=int(row.output_tokens or 0),
|
|
total_tokens=int(row.total_tokens or 0),
|
|
input_text_preview=row.input_text_preview,
|
|
output_text_preview=row.output_text_preview,
|
|
started_at=row.started_at.isoformat() + "Z",
|
|
completed_at=row.completed_at.isoformat() + "Z" if row.completed_at else None,
|
|
).model_dump()
|
|
for row in rows
|
|
]
|
|
return PlatformUsageResponse(
|
|
summary=PlatformUsageSummary(
|
|
request_count=int(count or 0),
|
|
input_tokens=int(input_sum or 0),
|
|
output_tokens=int(output_sum or 0),
|
|
total_tokens=int(total_sum or 0),
|
|
),
|
|
items=[PlatformUsageItem.model_validate(item) for item in items],
|
|
total=total,
|
|
limit=safe_limit,
|
|
offset=safe_offset,
|
|
has_more=safe_offset + len(items) < total,
|
|
).model_dump()
|
|
|
|
|
|
def list_activity_events(
|
|
session: Session,
|
|
bot_id: Optional[str] = None,
|
|
limit: int = 100,
|
|
) -> List[Dict[str, Any]]:
|
|
deleted = prune_expired_activity_events(session, force=False)
|
|
if deleted > 0:
|
|
session.commit()
|
|
safe_limit = max(1, min(int(limit), 500))
|
|
stmt = select(BotActivityEvent).order_by(BotActivityEvent.created_at.desc(), BotActivityEvent.id.desc()).limit(safe_limit)
|
|
if bot_id:
|
|
stmt = stmt.where(BotActivityEvent.bot_id == bot_id)
|
|
rows = session.exec(stmt).all()
|
|
items: List[Dict[str, Any]] = []
|
|
for row in rows:
|
|
try:
|
|
metadata = json.loads(row.metadata_json or "{}")
|
|
except Exception:
|
|
metadata = {}
|
|
items.append(
|
|
PlatformActivityItem(
|
|
id=int(row.id or 0),
|
|
bot_id=row.bot_id,
|
|
request_id=row.request_id,
|
|
event_type=row.event_type,
|
|
channel=row.channel,
|
|
detail=row.detail,
|
|
metadata=metadata if isinstance(metadata, dict) else {},
|
|
created_at=row.created_at.isoformat() + "Z",
|
|
).model_dump()
|
|
)
|
|
return items
|
|
|
|
|
|
def build_platform_overview(session: Session, docker_manager: Any) -> Dict[str, Any]:
|
|
deleted = prune_expired_activity_events(session, force=False)
|
|
if deleted > 0:
|
|
session.commit()
|
|
bots = session.exec(select(BotInstance)).all()
|
|
images = session.exec(select(NanobotImage).order_by(NanobotImage.created_at.desc())).all()
|
|
settings = get_platform_settings(session)
|
|
|
|
running = 0
|
|
stopped = 0
|
|
disabled = 0
|
|
configured_cpu_total = 0.0
|
|
configured_memory_total = 0
|
|
configured_storage_total = 0
|
|
workspace_used_total = 0
|
|
workspace_limit_total = 0
|
|
live_cpu_percent_total = 0.0
|
|
live_memory_used_total = 0
|
|
live_memory_limit_total = 0
|
|
|
|
bot_rows: List[Dict[str, Any]] = []
|
|
for bot in bots:
|
|
enabled = bool(getattr(bot, "enabled", True))
|
|
runtime_status = docker_manager.get_bot_status(bot.id) if docker_manager else str(bot.docker_status or "STOPPED")
|
|
resources = _read_bot_resources(bot.id)
|
|
runtime = docker_manager.get_bot_resource_snapshot(bot.id) if docker_manager else {"usage": {}, "limits": {}, "docker_status": runtime_status}
|
|
workspace_root = _bot_workspace_root(bot.id)
|
|
workspace_used = _calc_dir_size_bytes(workspace_root)
|
|
workspace_limit = int(resources["storage_gb"] or 0) * 1024 * 1024 * 1024
|
|
|
|
configured_cpu_total += float(resources["cpu_cores"] or 0)
|
|
configured_memory_total += int(resources["memory_mb"] or 0) * 1024 * 1024
|
|
configured_storage_total += workspace_limit
|
|
workspace_used_total += workspace_used
|
|
workspace_limit_total += workspace_limit
|
|
live_cpu_percent_total += float((runtime.get("usage") or {}).get("cpu_percent") or 0.0)
|
|
live_memory_used_total += int((runtime.get("usage") or {}).get("memory_bytes") or 0)
|
|
live_memory_limit_total += int((runtime.get("usage") or {}).get("memory_limit_bytes") or 0)
|
|
|
|
if not enabled:
|
|
disabled += 1
|
|
elif runtime_status == "RUNNING":
|
|
running += 1
|
|
else:
|
|
stopped += 1
|
|
|
|
bot_rows.append(
|
|
{
|
|
"id": bot.id,
|
|
"name": bot.name,
|
|
"enabled": enabled,
|
|
"docker_status": runtime_status,
|
|
"image_tag": bot.image_tag,
|
|
"llm_provider": getattr(bot, "llm_provider", None),
|
|
"llm_model": getattr(bot, "llm_model", None),
|
|
"current_state": bot.current_state,
|
|
"last_action": bot.last_action,
|
|
"resources": resources,
|
|
"workspace_usage_bytes": workspace_used,
|
|
"workspace_limit_bytes": workspace_limit if workspace_limit > 0 else None,
|
|
}
|
|
)
|
|
|
|
usage = list_usage(session, limit=20)
|
|
events = list_activity_events(session, limit=20)
|
|
|
|
return {
|
|
"summary": {
|
|
"bots": {
|
|
"total": len(bots),
|
|
"running": running,
|
|
"stopped": stopped,
|
|
"disabled": disabled,
|
|
},
|
|
"images": {
|
|
"total": len(images),
|
|
"ready": len([row for row in images if row.status == "READY"]),
|
|
"abnormal": len([row for row in images if row.status != "READY"]),
|
|
},
|
|
"resources": {
|
|
"configured_cpu_cores": round(configured_cpu_total, 2),
|
|
"configured_memory_bytes": configured_memory_total,
|
|
"configured_storage_bytes": configured_storage_total,
|
|
"live_cpu_percent": round(live_cpu_percent_total, 2),
|
|
"live_memory_used_bytes": live_memory_used_total,
|
|
"live_memory_limit_bytes": live_memory_limit_total,
|
|
"workspace_used_bytes": workspace_used_total,
|
|
"workspace_limit_bytes": workspace_limit_total,
|
|
},
|
|
},
|
|
"images": [
|
|
{
|
|
"tag": row.tag,
|
|
"version": row.version,
|
|
"status": row.status,
|
|
"source_dir": row.source_dir,
|
|
"created_at": row.created_at.isoformat() + "Z",
|
|
}
|
|
for row in images
|
|
],
|
|
"bots": bot_rows,
|
|
"settings": settings.model_dump(),
|
|
"usage": usage,
|
|
"events": events,
|
|
}
|