Initial commit
This commit is contained in:
commit
57fc3525eb
7311 files changed
+1291398
No files matched your search
@@ -0,0 +1,553 @@
|
||||
"""CommandEngine 的一部分(R2-3 拆分):命令与分组的增删改查、分组执行与预览。
|
||||
|
||||
方法原样从 command_engine.py 迁出,行为不变;通过 mixin 组合回 CommandEngine,
|
||||
类属性与实例状态都在 CommandEngine(command_engine.py)里定义。
|
||||
"""
|
||||
|
||||
import copy
|
||||
import uuid
|
||||
from typing import Dict, List, Optional, Any, TYPE_CHECKING
|
||||
from app.services.command_defs import _new_command_id, get_default_command
|
||||
from app.services.command_engine_common import logger
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from app.core.tab_pool import TabSession # noqa: F401
|
||||
|
||||
|
||||
class CommandEngineCrudMixin:
|
||||
"""命令与分组的增删改查、分组执行与预览"""
|
||||
|
||||
def list_commands(self) -> List[Dict]:
|
||||
"""获取所有命令"""
|
||||
return self._merge_runtime_stats_into_commands(self._load_commands())
|
||||
def get_command(self, command_id: str) -> Optional[Dict]:
|
||||
command_key = str(command_id or "").strip()
|
||||
if not command_key:
|
||||
return None
|
||||
command = None
|
||||
with self._commands_lock:
|
||||
self._get_config_engine()
|
||||
self._refresh_commands_if_changed()
|
||||
for cmd in self._commands_cache:
|
||||
if not isinstance(cmd, dict):
|
||||
continue
|
||||
if str(cmd.get("id", "")).strip() == command_key:
|
||||
command = copy.deepcopy(cmd)
|
||||
break
|
||||
if command is None:
|
||||
return None
|
||||
return self._merge_runtime_stats_into_command(command)
|
||||
def get_command_config(self, command_id: str) -> Optional[Dict]:
|
||||
"""获取单条命令原始配置,不合并展示用运行态统计。"""
|
||||
command_key = str(command_id or "").strip()
|
||||
if not command_key:
|
||||
return None
|
||||
with self._commands_lock:
|
||||
self._get_config_engine()
|
||||
self._refresh_commands_if_changed()
|
||||
for cmd in self._commands_cache:
|
||||
if not isinstance(cmd, dict):
|
||||
continue
|
||||
if str(cmd.get("id", "")).strip() == command_key:
|
||||
return copy.deepcopy(cmd)
|
||||
return None
|
||||
def add_command(self, command: Dict = None) -> Optional[Dict]:
|
||||
if command is None:
|
||||
command = get_default_command()
|
||||
else:
|
||||
if not command.get("id"):
|
||||
command["id"] = _new_command_id()
|
||||
|
||||
with self._commands_lock:
|
||||
commands = self._load_commands()
|
||||
command["name"] = self._ensure_unique_command_name(command.get("name"), commands)
|
||||
command["group_name"] = self._normalize_group_name(command.get("group_name"))
|
||||
command["advanced_ui"] = self._normalize_advanced_ui(command.get("advanced_ui"))
|
||||
self._normalize_command_logging(command)
|
||||
commands.append(command)
|
||||
if not self._save_commands(commands):
|
||||
return None
|
||||
|
||||
logger.info(f"[OK] 命令已添加: {command.get('name')} ({command['id']})")
|
||||
return copy.deepcopy(command)
|
||||
def duplicate_command(self, command_id: str) -> Optional[Dict]:
|
||||
"""复制单条命令,并将副本紧跟在原命令之后。"""
|
||||
command_key = str(command_id or "").strip()
|
||||
if not command_key:
|
||||
return None
|
||||
|
||||
with self._commands_lock:
|
||||
commands = self._load_commands()
|
||||
source_index = next(
|
||||
(index for index, item in enumerate(commands) if item.get("id") == command_key),
|
||||
-1,
|
||||
)
|
||||
if source_index < 0:
|
||||
return None
|
||||
|
||||
duplicated = copy.deepcopy(commands[source_index])
|
||||
duplicated["id"] = _new_command_id()
|
||||
duplicated["name"] = self._ensure_unique_copy_name(
|
||||
duplicated.get("name"),
|
||||
{str(item.get("name") or "").strip() for item in commands},
|
||||
)
|
||||
self._normalize_command_logging(duplicated)
|
||||
commands.insert(source_index + 1, duplicated)
|
||||
if not self._save_commands(commands):
|
||||
return None
|
||||
|
||||
logger.info(f"[OK] 命令已复制: {command_key} -> {duplicated['id']}")
|
||||
return copy.deepcopy(duplicated)
|
||||
def duplicate_group(self, group_name: str) -> Optional[Dict[str, Any]]:
|
||||
"""复制整个命令组,并重映射副本组内的命令引用。"""
|
||||
source_group = self._normalize_group_name(group_name)
|
||||
if not source_group:
|
||||
return None
|
||||
|
||||
with self._commands_lock:
|
||||
commands = self._load_commands()
|
||||
source_commands = [
|
||||
item
|
||||
for item in commands
|
||||
if self._normalize_group_name(item.get("group_name")) == source_group
|
||||
]
|
||||
if not source_commands:
|
||||
return None
|
||||
|
||||
existing_group_names = {
|
||||
self._normalize_group_name(item.get("group_name"))
|
||||
for item in commands
|
||||
if self._normalize_group_name(item.get("group_name"))
|
||||
}
|
||||
target_group = self._ensure_unique_copy_name(source_group, existing_group_names)
|
||||
command_id_map = {
|
||||
str(item.get("id") or "").strip(): _new_command_id()
|
||||
for item in source_commands
|
||||
if str(item.get("id") or "").strip()
|
||||
}
|
||||
existing_command_names = {
|
||||
str(item.get("name") or "").strip()
|
||||
for item in commands
|
||||
if str(item.get("name") or "").strip()
|
||||
}
|
||||
duplicated_commands: List[Dict[str, Any]] = []
|
||||
|
||||
for source in source_commands:
|
||||
duplicated = copy.deepcopy(source)
|
||||
source_id = str(source.get("id") or "").strip()
|
||||
duplicated["id"] = command_id_map.get(source_id) or _new_command_id()
|
||||
duplicated["name"] = self._ensure_unique_copy_name(
|
||||
source.get("name"),
|
||||
existing_command_names,
|
||||
)
|
||||
existing_command_names.add(duplicated["name"])
|
||||
duplicated["group_name"] = target_group
|
||||
self._remap_duplicated_command_references(
|
||||
duplicated,
|
||||
command_id_map,
|
||||
source_group_name=source_group,
|
||||
target_group_name=target_group,
|
||||
)
|
||||
self._normalize_command_logging(duplicated)
|
||||
duplicated_commands.append(duplicated)
|
||||
|
||||
commands.extend(duplicated_commands)
|
||||
if not self._save_commands(commands):
|
||||
return None
|
||||
|
||||
logger.info(
|
||||
f"[OK] 命令组已复制: {source_group} -> {target_group} "
|
||||
f"({len(duplicated_commands)} 条命令)"
|
||||
)
|
||||
return {
|
||||
"group_name": target_group,
|
||||
"commands": copy.deepcopy(duplicated_commands),
|
||||
"count": len(duplicated_commands),
|
||||
}
|
||||
def update_command(self, command_id: str, updates: Dict) -> Optional[Dict]:
|
||||
updates = dict(updates or {})
|
||||
with self._commands_lock:
|
||||
commands = self._load_commands()
|
||||
|
||||
for i, cmd in enumerate(commands):
|
||||
if cmd.get("id") == command_id:
|
||||
updates.pop("id", None)
|
||||
if "name" in updates:
|
||||
updates["name"] = self._ensure_unique_command_name(
|
||||
updates.get("name"),
|
||||
commands,
|
||||
exclude_id=command_id,
|
||||
)
|
||||
if "group_name" in updates:
|
||||
updates["group_name"] = self._normalize_group_name(updates.get("group_name"))
|
||||
if "advanced_ui" in updates:
|
||||
updates["advanced_ui"] = self._normalize_advanced_ui(updates.get("advanced_ui"))
|
||||
cmd.update(updates)
|
||||
self._normalize_command_logging(cmd)
|
||||
commands[i] = cmd
|
||||
if not self._save_commands(commands):
|
||||
return None
|
||||
logger.debug(f"[OK] 命令已更新: {cmd.get('name')} ({command_id})")
|
||||
return copy.deepcopy(cmd)
|
||||
|
||||
return None
|
||||
def delete_command(self, command_id: str) -> bool:
|
||||
with self._commands_lock:
|
||||
commands = self._load_commands()
|
||||
new_commands = [c for c in commands if c.get("id") != command_id]
|
||||
|
||||
if len(new_commands) == len(commands):
|
||||
return False
|
||||
|
||||
if not self._save_commands(new_commands):
|
||||
return False
|
||||
|
||||
# 清理触发状态
|
||||
with self._lock:
|
||||
keys_to_remove = [k for k in self._trigger_states if k[0] == command_id]
|
||||
for k in keys_to_remove:
|
||||
del self._trigger_states[k]
|
||||
result_keys = [k for k in self._command_results if k[0] == command_id]
|
||||
for k in result_keys:
|
||||
del self._command_results[k]
|
||||
self._command_runtime_stats.pop(command_id, None)
|
||||
|
||||
logger.info(f"[OK] 命令已删除: {command_id}")
|
||||
return True
|
||||
def reorder_commands(self, command_ids: List[str]) -> bool:
|
||||
with self._commands_lock:
|
||||
commands = self._load_commands()
|
||||
cmd_map = {c["id"]: c for c in commands}
|
||||
new_commands = []
|
||||
|
||||
for cid in command_ids:
|
||||
if cid in cmd_map:
|
||||
new_commands.append(cmd_map.pop(cid))
|
||||
|
||||
for remaining in cmd_map.values():
|
||||
new_commands.append(remaining)
|
||||
|
||||
if len(new_commands) == len(commands) and all(
|
||||
current is updated for current, updated in zip(commands, new_commands)
|
||||
):
|
||||
return True
|
||||
|
||||
return self._save_commands(new_commands)
|
||||
return True
|
||||
def set_commands_group(self, command_ids: List[str], group_name: str) -> int:
|
||||
"""批量设置命令分组。group_name 为空时表示解散选中的命令。"""
|
||||
target_ids = {str(cid).strip() for cid in (command_ids or []) if str(cid).strip()}
|
||||
if not target_ids:
|
||||
return 0
|
||||
|
||||
normalized_group = self._normalize_group_name(group_name)
|
||||
updated = 0
|
||||
|
||||
with self._commands_lock:
|
||||
commands = self._load_commands()
|
||||
for cmd in commands:
|
||||
if cmd.get("id") not in target_ids:
|
||||
continue
|
||||
if self._normalize_group_name(cmd.get("group_name")) == normalized_group:
|
||||
continue
|
||||
cmd["group_name"] = normalized_group
|
||||
updated += 1
|
||||
if updated > 0 and not self._save_commands(commands):
|
||||
return -1
|
||||
|
||||
return updated
|
||||
def rename_group(self, old_group_name: str, new_group_name: str) -> int:
|
||||
"""重命名命令组。"""
|
||||
source_name = self._normalize_group_name(old_group_name)
|
||||
target_name = self._normalize_group_name(new_group_name)
|
||||
if not source_name or not target_name or source_name == target_name:
|
||||
return 0
|
||||
|
||||
updated = 0
|
||||
with self._commands_lock:
|
||||
commands = self._load_commands()
|
||||
for cmd in commands:
|
||||
if self._normalize_group_name(cmd.get("group_name")) != source_name:
|
||||
continue
|
||||
cmd["group_name"] = target_name
|
||||
updated += 1
|
||||
if updated > 0 and not self._save_commands(commands):
|
||||
return -1
|
||||
return updated
|
||||
def set_commands_enabled(self, command_ids: List[str], enabled: bool) -> int:
|
||||
"""批量更新命令启用状态。"""
|
||||
target_ids = {str(cid).strip() for cid in (command_ids or []) if str(cid).strip()}
|
||||
if not target_ids:
|
||||
return 0
|
||||
|
||||
desired_enabled = bool(enabled)
|
||||
updated = 0
|
||||
|
||||
with self._commands_lock:
|
||||
commands = self._load_commands()
|
||||
for cmd in commands:
|
||||
if cmd.get("id") not in target_ids:
|
||||
continue
|
||||
current_enabled = bool(cmd.get("enabled", True))
|
||||
if current_enabled == desired_enabled:
|
||||
continue
|
||||
cmd["enabled"] = desired_enabled
|
||||
updated += 1
|
||||
if updated > 0 and not self._save_commands(commands):
|
||||
return -1
|
||||
|
||||
return updated
|
||||
def disband_group(self, group_name: str) -> int:
|
||||
"""解散整个命令组。"""
|
||||
normalized_group = self._normalize_group_name(group_name)
|
||||
if not normalized_group:
|
||||
return 0
|
||||
|
||||
updated = 0
|
||||
with self._commands_lock:
|
||||
commands = self._load_commands()
|
||||
for cmd in commands:
|
||||
if self._normalize_group_name(cmd.get("group_name")) != normalized_group:
|
||||
continue
|
||||
cmd["group_name"] = ""
|
||||
updated += 1
|
||||
if updated > 0 and not self._save_commands(commands):
|
||||
return -1
|
||||
return updated
|
||||
def set_group_enabled(self, group_name: str, enabled: bool) -> int:
|
||||
"""直接更新整个命令组的启用状态。"""
|
||||
normalized_group = self._normalize_group_name(group_name)
|
||||
if not normalized_group:
|
||||
return 0
|
||||
|
||||
desired_enabled = bool(enabled)
|
||||
updated = 0
|
||||
with self._commands_lock:
|
||||
commands = self._load_commands()
|
||||
for cmd in commands:
|
||||
if self._normalize_group_name(cmd.get("group_name")) != normalized_group:
|
||||
continue
|
||||
current_enabled = bool(cmd.get("enabled", True))
|
||||
if current_enabled == desired_enabled:
|
||||
continue
|
||||
cmd["enabled"] = desired_enabled
|
||||
updated += 1
|
||||
if updated > 0 and not self._save_commands(commands):
|
||||
return -1
|
||||
return updated
|
||||
def list_command_groups(self) -> List[Dict[str, Any]]:
|
||||
groups: Dict[str, Dict[str, Any]] = {}
|
||||
for cmd in self._load_commands_for_checks():
|
||||
group_name = self._normalize_group_name(cmd.get("group_name"))
|
||||
if not group_name:
|
||||
continue
|
||||
bucket = groups.setdefault(group_name, {
|
||||
"name": group_name,
|
||||
"count": 0,
|
||||
"enabled_count": 0,
|
||||
"command_ids": [],
|
||||
})
|
||||
bucket["count"] += 1
|
||||
bucket["enabled_count"] += 1 if cmd.get("enabled", True) else 0
|
||||
bucket["command_ids"].append(cmd.get("id"))
|
||||
|
||||
return [groups[name] for name in sorted(groups.keys())]
|
||||
def execute_command_group(
|
||||
self,
|
||||
group_name: str,
|
||||
session: 'TabSession',
|
||||
include_disabled: bool = False,
|
||||
source_command_id: Optional[str] = None,
|
||||
ancestry_chain: Optional[List[str]] = None,
|
||||
acquire_policy: Optional[str] = None,
|
||||
prepared_plan: Optional[Dict[str, Any]] = None,
|
||||
) -> Dict[str, Any]:
|
||||
"""在当前会话中顺序执行命令组内的命令。"""
|
||||
normalized_group = self._normalize_group_name(group_name)
|
||||
if not normalized_group:
|
||||
return {"ok": False, "error": "empty_group_name"}
|
||||
effective_policy = self._normalize_group_acquire_policy(acquire_policy)
|
||||
|
||||
plan = dict(prepared_plan or {}) if isinstance(prepared_plan, dict) else {}
|
||||
if not plan:
|
||||
plan = self.preview_command_group(
|
||||
group_name=normalized_group,
|
||||
session=session,
|
||||
include_disabled=include_disabled,
|
||||
source_command_id=source_command_id,
|
||||
ancestry_chain=ancestry_chain,
|
||||
)
|
||||
candidates: List[Dict[str, Any]] = list(plan.pop("_candidate_commands", []))
|
||||
results: List[Dict[str, Any]] = []
|
||||
initial_scope_skipped = int(plan.get("scope_skipped", 0) or 0)
|
||||
|
||||
if not candidates:
|
||||
return {
|
||||
"ok": False,
|
||||
"error": "group_empty_or_no_runnable_commands",
|
||||
"group_name": normalized_group,
|
||||
"scope_skipped": initial_scope_skipped,
|
||||
"runnable_count": plan.get("runnable_count", 0),
|
||||
}
|
||||
|
||||
chain_seed = list(ancestry_chain or [])
|
||||
if not chain_seed and source_command_id:
|
||||
chain_seed = [source_command_id]
|
||||
group_acquired = False
|
||||
group_task_id = f"group_{normalized_group}_{uuid.uuid4().hex[:12]}"
|
||||
can_acquire = hasattr(session, "acquire_for_command")
|
||||
if effective_policy != "inherit_session":
|
||||
if not can_acquire:
|
||||
if effective_policy == "require_acquire":
|
||||
return {
|
||||
"ok": False,
|
||||
"error": "group_acquire_unavailable",
|
||||
"group_name": normalized_group,
|
||||
"acquire_policy": effective_policy,
|
||||
}
|
||||
else:
|
||||
group_acquired = bool(session.acquire_for_command(group_task_id))
|
||||
if not group_acquired and effective_policy == "require_acquire":
|
||||
return {
|
||||
"ok": False,
|
||||
"error": "group_acquire_failed",
|
||||
"group_name": normalized_group,
|
||||
"acquire_policy": effective_policy,
|
||||
}
|
||||
|
||||
try:
|
||||
for cmd in candidates:
|
||||
command_id = cmd.get("id")
|
||||
if not command_id:
|
||||
continue
|
||||
if not self._matches_scope(cmd, session):
|
||||
results.append({
|
||||
"id": command_id,
|
||||
"name": cmd.get("name", command_id),
|
||||
"ok": False,
|
||||
"error": "scope_mismatch",
|
||||
})
|
||||
continue
|
||||
exec_key = (command_id, session.id)
|
||||
with self._lock:
|
||||
if exec_key in self._executing:
|
||||
results.append({
|
||||
"id": command_id,
|
||||
"name": cmd.get("name", command_id),
|
||||
"ok": False,
|
||||
"error": "already_executing",
|
||||
})
|
||||
continue
|
||||
self._executing.add(exec_key)
|
||||
with self._command_logging_context(cmd):
|
||||
try:
|
||||
execution_result = self._execute_command(cmd, session, chain=chain_seed)
|
||||
command_ok = not self._execution_needs_page_check_retry(execution_result)
|
||||
results.append({
|
||||
"id": command_id,
|
||||
"name": cmd.get("name", command_id),
|
||||
"ok": command_ok,
|
||||
"result": execution_result,
|
||||
**({"error": "execution_not_ok"} if not command_ok else {}),
|
||||
})
|
||||
except Exception as e:
|
||||
logger.error(f"trigger check failed [{cmd.get('name')}]: {e}")
|
||||
results.append({
|
||||
"id": command_id,
|
||||
"name": cmd.get("name", command_id),
|
||||
"ok": False,
|
||||
"error": str(e),
|
||||
})
|
||||
finally:
|
||||
with self._lock:
|
||||
self._executing.discard(exec_key)
|
||||
finally:
|
||||
if group_acquired:
|
||||
try:
|
||||
browser = self._get_browser()
|
||||
pool = getattr(browser, "_tab_pool", None)
|
||||
if pool is not None and hasattr(pool, "release"):
|
||||
pool.release(
|
||||
session.id,
|
||||
check_triggers=False,
|
||||
expected_task_id=group_task_id,
|
||||
)
|
||||
else:
|
||||
session.release(
|
||||
clear_page=False,
|
||||
check_triggers=False,
|
||||
expected_task_id=group_task_id,
|
||||
)
|
||||
except Exception as e:
|
||||
logger.debug(f"[CMD] 命令组释放标签页失败(忽略): {e}")
|
||||
|
||||
success_count = sum(1 for item in results if item.get("ok"))
|
||||
failure_count = sum(1 for item in results if not item.get("ok"))
|
||||
return {
|
||||
"ok": len(results) > 0 and failure_count == 0,
|
||||
"partial_ok": success_count > 0,
|
||||
"group_name": normalized_group,
|
||||
"executed": success_count,
|
||||
"total": len(results),
|
||||
"failures": failure_count,
|
||||
"results": results,
|
||||
"acquire_policy": effective_policy,
|
||||
"acquired": group_acquired,
|
||||
"scope_skipped": sum(1 for item in results if item.get("error") == "scope_mismatch"),
|
||||
"runnable_count": plan.get("runnable_count", 0),
|
||||
}
|
||||
def preview_command_group(
|
||||
self,
|
||||
group_name: str,
|
||||
session: 'TabSession',
|
||||
include_disabled: bool = False,
|
||||
source_command_id: Optional[str] = None,
|
||||
ancestry_chain: Optional[List[str]] = None,
|
||||
) -> Dict[str, Any]:
|
||||
normalized_group = self._normalize_group_name(group_name)
|
||||
if not normalized_group:
|
||||
return {
|
||||
"ok": False,
|
||||
"error": "empty_group_name",
|
||||
"group_name": normalized_group,
|
||||
"_candidate_commands": [],
|
||||
"_scope_skipped_results": [],
|
||||
}
|
||||
|
||||
with self._commands_lock:
|
||||
commands = self._load_commands()
|
||||
|
||||
candidates: List[Dict[str, Any]] = []
|
||||
scope_skipped_results: List[Dict[str, Any]] = []
|
||||
total_candidates = 0
|
||||
ancestors = {str(item or "").strip() for item in (ancestry_chain or []) if str(item or "").strip()}
|
||||
if source_command_id:
|
||||
ancestors.add(str(source_command_id).strip())
|
||||
for cmd in commands:
|
||||
if self._normalize_group_name(cmd.get("group_name")) != normalized_group:
|
||||
continue
|
||||
if not include_disabled and not cmd.get("enabled", True):
|
||||
continue
|
||||
if str(cmd.get("id", "")).strip() in ancestors:
|
||||
continue
|
||||
total_candidates += 1
|
||||
candidates.append(cmd)
|
||||
if not self._matches_scope(cmd, session):
|
||||
scope_skipped_results.append({
|
||||
"id": cmd.get("id"),
|
||||
"name": cmd.get("name", cmd.get("id", "")),
|
||||
"ok": False,
|
||||
"error": "scope_mismatch",
|
||||
})
|
||||
continue
|
||||
|
||||
return {
|
||||
"ok": bool(candidates) and not scope_skipped_results,
|
||||
"fully_runnable": bool(candidates) and not scope_skipped_results,
|
||||
"group_name": normalized_group,
|
||||
"total_candidates": total_candidates,
|
||||
"runnable_count": total_candidates - len(scope_skipped_results),
|
||||
"scope_skipped": len(scope_skipped_results),
|
||||
"_candidate_commands": candidates,
|
||||
"_scope_skipped_results": scope_skipped_results,
|
||||
}
|
||||
Reference in new issue
Block a user