Initial commit

This commit is contained in:
Alex committed 2026-11-02 22:54:14 +08:00
commit 57fc3525eb
7311 files changed
+1291398

No files matched your search

+667
View File
@@ -0,0 +1,667 @@
"""ConfigEngine 的一部分(R2-3 拆分):预设的解析、创建、改名、删除及引用同步。
方法原样从 engine.py 迁出,行为不变;通过 mixin 组合回 ConfigEngine,
实例状态都在 ConfigEngine.__init__(engine.py)里初始化。
"""
import json
import copy
from typing import Dict, Optional, List, Any
from .engine_common import DEFAULT_PRESET_NAME, DEFAULT_WORKFLOW, _MISSING, logger
class ConfigPresetsMixin:
"""预设的解析、创建、改名、删除及引用同步"""
def _resolve_default_preset_name(self, site: Dict[str, Any]) -> Optional[str]:
"""解析站点有效默认预设名(不修改原对象)"""
presets = site.get("presets", {})
if not presets:
return None
configured_default = site.get("default_preset")
if isinstance(configured_default, str):
configured_default = configured_default.strip()
else:
configured_default = None
if configured_default and configured_default in presets:
return configured_default
if DEFAULT_PRESET_NAME in presets:
return DEFAULT_PRESET_NAME
return next(iter(presets))
def _normalize_site_default_preset(self, domain: str, site: Dict[str, Any]) -> bool:
"""
规范化站点 default_preset 字段
Returns:
是否发生修改
"""
return self._sync_site_default_preset_state(domain, site)
def _get_site_data(self, domain: str, preset_name: str = None) -> Optional[Dict]:
"""
获取指定站点的预设配置数据(可变引用)
查找顺序:
- preset_name 显式提供时:只匹配该预设(含别名)
- preset_name 为空时:按站点默认预设 / 主预设 / 第一个可用预设回退
Args:
domain: 站点域名
preset_name: 预设名称,None 则使用默认
Returns:
预设配置字典的引用(可直接修改),或 None
"""
if domain not in self.sites:
return None
site = self.sites[domain]
presets = site.get("presets", {})
if not presets:
return None
requested_preset = str(preset_name or "").strip()
if requested_preset:
resolved_target = self._resolve_preset_alias_key(requested_preset, presets)
if resolved_target != requested_preset:
logger.debug(f"预设别名命中: '{requested_preset}' -> '{resolved_target}'")
if resolved_target in presets:
return presets[resolved_target]
return None
resolved_default = self._resolve_default_preset_name(site)
if resolved_default and resolved_default in presets:
return presets[resolved_default]
if DEFAULT_PRESET_NAME in presets:
return presets[DEFAULT_PRESET_NAME]
first_key = next(iter(presets))
logger.warning(f"默认预设不存在,使用第一个预设: '{first_key}'")
return presets[first_key]
@staticmethod
def _resolve_preset_alias_key(target: Any, presets: Dict[str, Any]) -> str:
"""兼容历史命名:允许不带“预设_”前缀的名字命中真实预设键。"""
normalized = str(target or "").strip()
if not normalized or not isinstance(presets, dict):
return normalized
if normalized in presets:
return normalized
candidates = []
if normalized.startswith("预设_"):
stripped = normalized[len("预设_"):].strip()
if stripped:
candidates.append(stripped)
else:
candidates.append(f"预设_{normalized}")
for candidate in candidates:
if candidate in presets:
return candidate
return normalized
def _get_site_data_readonly(self, domain: str, preset_name: str = None) -> Optional[Dict]:
"""获取预设配置的深拷贝(只读用途)"""
with self._io_lock:
data = self._get_site_data(domain, preset_name)
if data is None:
return None
return copy.deepcopy(data)
def _get_preset_data_exact(self, domain: str, preset_name: str = None) -> Optional[Dict]:
"""获取预设配置引用;显式预设不存在时不回退到默认预设。"""
site = self.sites.get(domain)
if not isinstance(site, dict):
return None
presets = site.get("presets", {})
if not isinstance(presets, dict) or not presets:
return None
if preset_name is None or not str(preset_name).strip():
target = self._resolve_default_preset_name(site)
else:
target = str(preset_name).strip()
resolved_target = self._resolve_preset_alias_key(target, presets)
if resolved_target and resolved_target in presets:
return presets[resolved_target]
return None
def list_presets(self, domain: str) -> List[str]:
"""获取指定站点的所有预设名称"""
self.refresh_if_changed()
if domain not in self.sites:
return []
site = self.sites[domain]
presets = site.get("presets", {})
return list(presets.keys())
def get_default_preset(self, domain: str) -> Optional[str]:
"""获取指定站点的默认预设名称(已解析回退)"""
self.refresh_if_changed()
cache_key = f"default_preset:{domain}"
cached = self._cache.get(cache_key, _MISSING)
if cached is not _MISSING:
return cached
site = self.sites.get(domain)
if not site:
self._cache.set(cache_key, None)
return None
result = self._resolve_default_preset_name(site)
self._cache.set(cache_key, result)
return result
def _assign_preset_field_and_save(
self,
preset_data: Dict[str, Any],
field_name: str,
value: Any,
) -> bool:
previous_value = preset_data.get(field_name, _MISSING)
if previous_value is not _MISSING:
previous_value = copy.deepcopy(previous_value)
preset_data[field_name] = value
if self._save_config():
return True
if previous_value is _MISSING:
preset_data.pop(field_name, None)
else:
preset_data[field_name] = previous_value
return False
def set_default_preset(self, domain: str, preset_name: str) -> bool:
"""设置指定站点的默认预设"""
self.refresh_if_changed()
site = self.sites.get(domain)
if not site:
return False
presets = site.get("presets", {})
if preset_name not in presets:
logger.warning(f"默认预设设置失败,预设不存在: {domain}/{preset_name}")
return False
previous_default = site.get("default_preset", _MISSING)
if previous_default is not _MISSING:
previous_default = copy.deepcopy(previous_default)
previous_default_maps = (
copy.deepcopy(getattr(self, "_global_default_presets", {})),
copy.deepcopy(getattr(self, "_local_default_presets", {})),
)
persisted_default = self._get_persisted_default_preset(domain, site)
if persisted_default == preset_name:
self._local_default_presets.pop(domain, None)
else:
self._local_default_presets[domain] = preset_name
site["default_preset"] = preset_name
if not self._save_local_site_overrides():
if previous_default is _MISSING:
site.pop("default_preset", None)
else:
site["default_preset"] = previous_default
self._global_default_presets, self._local_default_presets = previous_default_maps
return False
logger.info(f"✅ 站点 {domain} 默认预设已设置为: '{preset_name}'(仅本地覆盖)")
return True
def create_preset(self, domain: str, new_name: str,
source_name: str = None) -> bool:
"""
创建新预设(克隆自现有预设)
Args:
domain: 站点域名
new_name: 新预设名称
source_name: 要克隆的源预设名称,None 则克隆主预设
Returns:
是否成功
"""
self.refresh_if_changed()
if domain not in self.sites:
logger.warning(f"站点不存在: {domain}")
return False
site = self.sites[domain]
presets = site.get("presets", {})
if new_name in presets:
logger.warning(f"预设已存在: {new_name}")
return False
# 获取源预设
if source_name is not None and str(source_name or "").strip():
requested_source = str(source_name or "").strip()
source = self._resolve_preset_alias_key(requested_source, presets)
source_data = presets.get(source)
if not source_data:
logger.warning(f"源预设不存在: {requested_source}")
return False
else:
source = DEFAULT_PRESET_NAME
source_data = presets.get(source)
if not source_data:
# 未显式指定源时才尝试第一个可用预设
if presets:
source = next(iter(presets))
source_data = presets[source]
else:
logger.warning(f"没有可克隆的源预设")
return False
previous_default = site.get("default_preset", _MISSING)
if previous_default is not _MISSING:
previous_default = copy.deepcopy(previous_default)
previous_presets = copy.deepcopy(presets)
previous_global_default = copy.deepcopy(self._global_default_presets)
previous_local_default = copy.deepcopy(self._local_default_presets)
# 深拷贝创建新预设
presets[new_name] = copy.deepcopy(source_data)
self._normalize_site_default_preset(domain, site)
if not self._save_config():
site["presets"] = previous_presets
if previous_default is _MISSING:
site.pop("default_preset", None)
else:
site["default_preset"] = previous_default
self._global_default_presets = previous_global_default
self._local_default_presets = previous_local_default
return False
logger.info(f"✅ 站点 {domain} 创建预设: '{new_name}' (克隆自 '{source}')")
return True
@staticmethod
def _build_preset_rename_map(old_name: Any, new_name: Any) -> Dict[str, str]:
old_raw = str(old_name or "").strip()
new_raw = str(new_name or "").strip()
if not old_raw or not new_raw:
return {}
def _strip_prefix(value: str) -> str:
if value.startswith("预设_"):
return value[len("预设_"):].strip()
return value
def _add_prefix(value: str) -> str:
return value if value.startswith("预设_") else f"预设_{value}"
mapping: Dict[str, str] = {}
old_plain = _strip_prefix(old_raw)
new_plain = _strip_prefix(new_raw)
old_prefixed = _add_prefix(old_raw)
new_prefixed = _add_prefix(new_raw)
for src, dst in (
(old_raw, new_raw),
(old_plain, new_plain),
(old_prefixed, new_prefixed),
):
src_text = str(src or "").strip()
dst_text = str(dst or "").strip()
if src_text and dst_text:
mapping[src_text] = dst_text
return mapping
@staticmethod
def _command_targets_domain(command: Dict[str, Any], domain: str) -> bool:
normalized_domain = str(domain or "").strip().lower()
if not normalized_domain or not isinstance(command, dict):
return False
trigger = command.get("trigger", {}) or {}
command_domain = str(trigger.get("domain", "") or "").strip().lower()
if not command_domain:
return False
return (
command_domain == normalized_domain
or command_domain.endswith(f".{normalized_domain}")
or normalized_domain.endswith(f".{command_domain}")
)
def _rename_preset_references_in_commands(
self,
domain: str,
rename_map: Dict[str, str],
) -> int:
if not rename_map:
return 0
commands = self._load_commands_file()
if not commands:
return 0
updated = 0
for command in commands:
if not self._command_targets_domain(command, domain):
continue
actions = command.get("actions", [])
if not isinstance(actions, list):
continue
for action in actions:
if not isinstance(action, dict):
continue
current_preset = str(action.get("preset_name", "") or "").strip()
replacement = rename_map.get(current_preset)
if not replacement or replacement == current_preset:
continue
action["preset_name"] = replacement
updated += 1
if updated > 0:
self._save_commands_file(commands)
return updated
def _rename_preset_references_in_active_tabs(
self,
domain: str,
rename_map: Dict[str, str],
) -> int:
if not rename_map:
return 0
try:
from app.core import browser as browser_module
instance = getattr(browser_module, "_browser_instance", None)
if instance is None:
return 0
pool = getattr(instance, "_tab_pool", None)
if pool is None or not hasattr(pool, "get_sessions_snapshot"):
return 0
updated = 0
for session in pool.get_sessions_snapshot():
session_domain = str(getattr(session, "current_domain", "") or "").strip().lower()
if session_domain != str(domain or "").strip().lower():
continue
current_preset = str(getattr(session, "preset_name", "") or "").strip()
replacement = rename_map.get(current_preset)
if not replacement or replacement == current_preset:
continue
if hasattr(session, "set_preset"):
session.set_preset(replacement, source=getattr(session, "preset_override_source", None))
else:
session.preset_name = replacement
updated += 1
return updated
except Exception as e:
logger.debug(f"同步活动标签页预设引用失败(忽略): {e}")
return 0
def _clear_preset_references_in_active_tabs(self, domain: str, preset_name: str) -> int:
"""预设被删除后,把在用标签页里指向它的 preset_name 置为 None(回落站点默认预设)。"""
target = str(preset_name or "").strip()
if not target:
return 0
# 兼容历史命名:带/不带“预设_”前缀都视为命中同一个预设
targets = {target}
if target.startswith("预设_"):
stripped = target[len("预设_"):].strip()
if stripped:
targets.add(stripped)
else:
targets.add(f"预设_{target}")
try:
from app.core import browser as browser_module
instance = getattr(browser_module, "_browser_instance", None)
if instance is None:
return 0
pool = getattr(instance, "_tab_pool", None)
if pool is None or not hasattr(pool, "get_sessions_snapshot"):
return 0
cleared = 0
for session in pool.get_sessions_snapshot():
session_domain = str(getattr(session, "current_domain", "") or "").strip().lower()
if session_domain != str(domain or "").strip().lower():
continue
current_preset = str(getattr(session, "preset_name", "") or "").strip()
if current_preset not in targets:
continue
if hasattr(session, "set_preset"):
session.set_preset(None, source=None)
else:
session.preset_name = None
cleared += 1
return cleared
except Exception as e:
logger.debug(f"清理活动标签页预设引用失败(忽略): {e}")
return 0
def _sync_preset_overrides_file(self, domain: str, old_preset: str, new_preset: Optional[str] = None) -> int:
"""当预设重命名或删除时,同步清理/更新 preset_overrides.local.json"""
target = str(old_preset or "").strip()
if not target:
return 0
from pathlib import Path
config_path = Path("config/preset_overrides.local.json")
if not config_path.exists():
return 0
from app.utils.site_url import extract_remote_site_domain
import json
try:
with open(config_path, "r", encoding="utf-8-sig") as f:
payload = json.load(f)
if not isinstance(payload, dict):
return 0
urls = payload.get("urls", {})
if not isinstance(urls, dict):
return 0
domain_norm = str(domain or "").strip().lower()
changed = 0
keys_to_delete = []
for url_key, p_name in list(urls.items()):
url_domain = str(extract_remote_site_domain(url_key) or "").strip().lower()
if domain_norm and url_domain != domain_norm:
continue
if p_name == target or p_name == f"预设_{target}" or (target.startswith("预设_") and p_name == target[3:]):
if new_preset:
urls[url_key] = new_preset
changed += 1
else:
keys_to_delete.append(url_key)
changed += 1
for k in keys_to_delete:
urls.pop(k, None)
if changed > 0:
from app.core.config import atomic_write_json
atomic_write_json(config_path, payload)
try:
from app.core import browser as browser_module
instance = getattr(browser_module, "_browser_instance", None)
pool = getattr(instance, "_tab_pool", None)
if pool is not None and hasattr(pool, "apply_runtime_config"):
pool.apply_runtime_config(preset_overrides=payload)
except Exception:
pass
return changed
except Exception as e:
logger.debug(f"同步预设本地配置失败: {e}")
return 0
def delete_preset(self, domain: str, preset_name: str) -> bool:
"""
删除预设(不允许删除最后一个预设)
Args:
domain: 站点域名
preset_name: 要删除的预设名称
Returns:
是否成功
"""
self.refresh_if_changed()
if domain not in self.sites:
return False
site = self.sites[domain]
presets = site.get("presets", {})
resolved_preset_name = self._resolve_preset_alias_key(preset_name, presets)
if resolved_preset_name not in presets:
logger.warning(f"预设不存在: {preset_name}")
return False
if len(presets) <= 1:
logger.warning(f"不能删除最后一个预设")
return False
previous_default = site.get("default_preset", _MISSING)
if previous_default is not _MISSING:
previous_default = copy.deepcopy(previous_default)
removed_preset = copy.deepcopy(presets[resolved_preset_name])
previous_global_default = copy.deepcopy(self._global_default_presets)
previous_local_default = copy.deepcopy(self._local_default_presets)
del presets[resolved_preset_name]
self._normalize_site_default_preset(domain, site)
if not self._save_config():
presets[resolved_preset_name] = removed_preset
if previous_default is _MISSING:
site.pop("default_preset", None)
else:
site["default_preset"] = previous_default
self._global_default_presets = previous_global_default
self._local_default_presets = previous_local_default
return False
# 预设已删除并落盘:清理在用标签页对它的残留引用,否则 session.preset_name 会指向不存在的预设
cleared_tab_refs = 0
try:
cleared_tab_refs = self._clear_preset_references_in_active_tabs(domain, resolved_preset_name)
except Exception as e:
logger.warning(f"清理活动标签页预设引用失败(忽略): {e}")
# 同步清理持久化 preset_overrides.local.json
try:
self._sync_preset_overrides_file(domain, resolved_preset_name, new_preset=None)
except Exception as e:
logger.warning(f"清理本地预设记忆文件失败(忽略): {e}")
logger.info(
f"✅ 站点 {domain} 删除预设: '{resolved_preset_name}' "
f"(活动标签页同步 {cleared_tab_refs} 处)"
)
return True
def rename_preset(self, domain: str, old_name: str, new_name: str) -> bool:
"""重命名预设"""
self.refresh_if_changed()
if domain not in self.sites:
return False
site = self.sites[domain]
presets = site.get("presets", {})
resolved_old_name = self._resolve_preset_alias_key(old_name, presets)
if resolved_old_name not in presets:
return False
if new_name in presets:
logger.warning(f"预设名已存在: {new_name}")
return False
rename_map = self._build_preset_rename_map(resolved_old_name, new_name)
default_preset = site.get("default_preset")
previous_default = site.get("default_preset", _MISSING)
if previous_default is not _MISSING:
previous_default = copy.deepcopy(previous_default)
previous_presets = copy.deepcopy(presets)
previous_global_default = copy.deepcopy(self._global_default_presets)
previous_local_default = copy.deepcopy(self._local_default_presets)
local_default = str(self._local_default_presets.get(domain, "") or "").strip()
# 保持顺序:创建有序副本
new_presets = {}
for key, value in presets.items():
if key == resolved_old_name:
new_presets[new_name] = value
else:
new_presets[key] = value
site["presets"] = new_presets
if default_preset == resolved_old_name:
site["default_preset"] = new_name
if local_default:
local_replacement = rename_map.get(local_default)
if local_replacement:
self._local_default_presets[domain] = local_replacement
self._normalize_site_default_preset(domain, site)
if not self._save_config():
site["presets"] = previous_presets
if previous_default is _MISSING:
site.pop("default_preset", None)
else:
site["default_preset"] = previous_default
self._global_default_presets = previous_global_default
self._local_default_presets = previous_local_default
return False
updated_command_refs = self._rename_preset_references_in_commands(domain, rename_map)
updated_tab_refs = self._rename_preset_references_in_active_tabs(domain, rename_map)
try:
self._sync_preset_overrides_file(domain, resolved_old_name, new_preset=new_name)
except Exception as e:
logger.warning(f"同步本地预设记忆文件失败(忽略): {e}")
logger.info(
f"站点 {domain} 重命名预设: '{resolved_old_name}' → '{new_name}' "
f"(命令引用同步 {updated_command_refs} 处, 活动标签页同步 {updated_tab_refs} 处)"
)
return True
def get_preset_selectors(self, domain: str, preset_name: str = None) -> Dict:
"""获取指定预设的选择器配置"""
data = self._get_site_data_readonly(domain, preset_name)
return data.get("selectors", {}) if data else {}
def set_preset_selectors(self, domain: str, selectors: Dict,
preset_name: str = None) -> bool:
"""设置指定预设的选择器配置"""
self.refresh_if_changed()
data = self._get_site_data(domain, preset_name)
if data is None:
return False
if not self._assign_preset_field_and_save(data, "selectors", selectors):
return False
logger.info(f"站点 {domain} [{preset_name or DEFAULT_PRESET_NAME}] 选择器已更新")
return True
def get_preset_workflow(self, domain: str, preset_name: str = None) -> List:
"""获取指定预设的工作流配置"""
data = self._get_site_data_readonly(domain, preset_name)
return data.get("workflow", DEFAULT_WORKFLOW) if data else DEFAULT_WORKFLOW
def set_preset_workflow(self, domain: str, workflow: List,
preset_name: str = None) -> bool:
"""设置指定预设的工作流配置"""
from app.core.workflow.flow_runtime import has_control_flow, validate_workflow
if has_control_flow(workflow):
validate_workflow(workflow)
self.refresh_if_changed()
data = self._get_site_data(domain, preset_name)
if data is None:
return False
if not self._assign_preset_field_and_save(data, "workflow", workflow):
return False
logger.info(f"站点 {domain} [{preset_name or DEFAULT_PRESET_NAME}] 工作流已更新")
return True