Initial commit
This commit is contained in:
commit
57fc3525eb
7311 files changed
+1291398
No files matched your search
@@ -0,0 +1,882 @@
|
||||
"""
|
||||
app/api/cmd_routes.py - 命令系统 API 路由
|
||||
|
||||
职责:
|
||||
- 命令 CRUD 接口
|
||||
- 元信息查询
|
||||
- 手动触发(调试用)
|
||||
"""
|
||||
|
||||
import base64
|
||||
import binascii
|
||||
import json
|
||||
import time
|
||||
import uuid
|
||||
from pathlib import Path
|
||||
from typing import Optional, List
|
||||
|
||||
from fastapi import APIRouter, HTTPException, Depends
|
||||
from pydantic import BaseModel, Field
|
||||
|
||||
from app.core.config import get_logger
|
||||
from app.api.deps import verify_dashboard_auth as verify_auth
|
||||
from app.services.command_engine import command_engine
|
||||
from app.services.command_result_store import clear_command_results, list_command_results
|
||||
from app.services.request_manager import request_manager, RequestStatus
|
||||
|
||||
logger = get_logger("API.CMD")
|
||||
|
||||
router = APIRouter(tags=["commands"])
|
||||
|
||||
_PROJECT_ROOT = Path(__file__).resolve().parents[2]
|
||||
_COMMAND_IMAGE_DIR = _PROJECT_ROOT / "temp" / "command_images"
|
||||
_MAX_COMMAND_IMAGE_BYTES = 25 * 1024 * 1024
|
||||
|
||||
|
||||
SECRET_PLACEHOLDER = "__SECRET_REDACTED__"
|
||||
NON_SENSITIVE_KEY_HINTS = {
|
||||
"claude_required_token",
|
||||
}
|
||||
SENSITIVE_KEY_HINTS = {
|
||||
"access_token",
|
||||
"authorization",
|
||||
"auth_token",
|
||||
"api_key",
|
||||
"apikey",
|
||||
"client_credentials",
|
||||
"credential",
|
||||
"credentials",
|
||||
"credentials_json",
|
||||
"csrf",
|
||||
"github_token",
|
||||
"password",
|
||||
"passwd",
|
||||
"private_key",
|
||||
"private_pem",
|
||||
"refresh_token",
|
||||
"secret",
|
||||
"service_account",
|
||||
"service_account_json",
|
||||
"session",
|
||||
"token",
|
||||
"x_api_key",
|
||||
"x_github_token",
|
||||
}
|
||||
SENSITIVE_KEY_SUFFIXES = (
|
||||
"_access_token",
|
||||
"_auth_token",
|
||||
"_token",
|
||||
"_api_key",
|
||||
"_apikey",
|
||||
"_credential",
|
||||
"_credentials",
|
||||
"_credentials_json",
|
||||
"_github_token",
|
||||
"_password",
|
||||
"_passwd",
|
||||
"_private_key",
|
||||
"_private_pem",
|
||||
"_secret",
|
||||
"_service_account",
|
||||
"_service_account_json",
|
||||
)
|
||||
|
||||
|
||||
def _normalize_secret_key(key: object) -> str:
|
||||
return str(key or "").strip().lower().replace("-", "_")
|
||||
|
||||
|
||||
def _is_command_secret_key(key: object) -> bool:
|
||||
normalized = _normalize_secret_key(key)
|
||||
if normalized in NON_SENSITIVE_KEY_HINTS:
|
||||
return False
|
||||
return normalized in SENSITIVE_KEY_HINTS or normalized.endswith(SENSITIVE_KEY_SUFFIXES)
|
||||
|
||||
|
||||
def _try_parse_json_text(value: object):
|
||||
if not isinstance(value, str):
|
||||
return None
|
||||
stripped = value.strip()
|
||||
if not stripped or stripped[:1] not in "{[":
|
||||
return None
|
||||
try:
|
||||
return json.loads(stripped)
|
||||
except (TypeError, ValueError, RecursionError):
|
||||
return None
|
||||
|
||||
|
||||
def _restore_list_item_key(item: object) -> str:
|
||||
if not isinstance(item, dict):
|
||||
return ""
|
||||
for key in ("id", "action_id", "command_id", "name"):
|
||||
value = str(item.get(key) or "").strip()
|
||||
if value:
|
||||
return f"{key}:{value}"
|
||||
return ""
|
||||
|
||||
|
||||
def _redact_command_secrets(data):
|
||||
if isinstance(data, dict):
|
||||
result = {}
|
||||
for key, value in data.items():
|
||||
if _is_command_secret_key(key) and value not in (None, ""):
|
||||
result[key] = SECRET_PLACEHOLDER
|
||||
else:
|
||||
result[key] = _redact_command_secrets(value)
|
||||
return result
|
||||
if isinstance(data, list):
|
||||
return [_redact_command_secrets(item) for item in data]
|
||||
parsed = _try_parse_json_text(data)
|
||||
if isinstance(parsed, (dict, list)):
|
||||
redacted = _redact_command_secrets(parsed)
|
||||
return json.dumps(redacted, ensure_ascii=False, indent=2)
|
||||
return data
|
||||
|
||||
|
||||
def _restore_secret_placeholders(updates, existing):
|
||||
if isinstance(updates, dict) and isinstance(existing, dict):
|
||||
result = {}
|
||||
for key, value in updates.items():
|
||||
existing_value = existing.get(key)
|
||||
if _is_command_secret_key(key) and value == SECRET_PLACEHOLDER:
|
||||
result[key] = existing_value
|
||||
else:
|
||||
result[key] = _restore_secret_placeholders(value, existing_value)
|
||||
return result
|
||||
if isinstance(updates, list) and isinstance(existing, list):
|
||||
result = []
|
||||
existing_by_key = {
|
||||
key: value
|
||||
for value in existing
|
||||
for key in [_restore_list_item_key(value)]
|
||||
if key
|
||||
}
|
||||
for idx, value in enumerate(updates):
|
||||
item_key = _restore_list_item_key(value)
|
||||
if item_key and item_key in existing_by_key:
|
||||
existing_value = existing_by_key[item_key]
|
||||
elif item_key:
|
||||
existing_value = None
|
||||
else:
|
||||
existing_value = existing[idx] if idx < len(existing) else None
|
||||
result.append(_restore_secret_placeholders(value, existing_value))
|
||||
return result
|
||||
parsed_updates = _try_parse_json_text(updates)
|
||||
parsed_existing = _try_parse_json_text(existing)
|
||||
if isinstance(parsed_updates, (dict, list)) and isinstance(parsed_existing, type(parsed_updates)):
|
||||
restored = _restore_secret_placeholders(parsed_updates, parsed_existing)
|
||||
return json.dumps(restored, ensure_ascii=False, indent=2)
|
||||
return updates
|
||||
|
||||
|
||||
def _find_unresolved_secret_placeholders(data, path: str = "") -> List[str]:
|
||||
found: List[str] = []
|
||||
if isinstance(data, dict):
|
||||
for key, value in data.items():
|
||||
key_path = str(key or "")
|
||||
next_path = f"{path}.{key_path}" if path else key_path
|
||||
if _is_command_secret_key(key) and value == SECRET_PLACEHOLDER:
|
||||
found.append(next_path)
|
||||
continue
|
||||
found.extend(_find_unresolved_secret_placeholders(value, next_path))
|
||||
return found
|
||||
if isinstance(data, list):
|
||||
for index, value in enumerate(data):
|
||||
next_path = f"{path}[{index}]" if path else f"[{index}]"
|
||||
found.extend(_find_unresolved_secret_placeholders(value, next_path))
|
||||
return found
|
||||
|
||||
parsed = _try_parse_json_text(data)
|
||||
if isinstance(parsed, (dict, list)):
|
||||
json_path = f"{path}<json>" if path else "<json>"
|
||||
found.extend(_find_unresolved_secret_placeholders(parsed, json_path))
|
||||
return found
|
||||
|
||||
|
||||
def _reject_unresolved_secret_placeholders(data) -> None:
|
||||
unresolved = _find_unresolved_secret_placeholders(data)
|
||||
if not unresolved:
|
||||
return
|
||||
preview = ", ".join(unresolved[:5])
|
||||
if len(unresolved) > 5:
|
||||
preview = f"{preview}, ... (+{len(unresolved) - 5})"
|
||||
raise HTTPException(
|
||||
status_code=400,
|
||||
detail=f"unresolved_secret_placeholder: {preview}",
|
||||
)
|
||||
|
||||
|
||||
def _raise_command_save_failed() -> None:
|
||||
raise HTTPException(status_code=500, detail="命令保存失败")
|
||||
|
||||
|
||||
def _finish_manual_command_request(ctx, success: bool) -> None:
|
||||
try:
|
||||
request_manager.finish_request(ctx, success=success)
|
||||
except Exception as exc:
|
||||
logger.debug(f"manual command request finish failed: {exc}")
|
||||
|
||||
|
||||
def _release_manual_command_session(
|
||||
pool,
|
||||
session,
|
||||
*,
|
||||
expected_task_id: str,
|
||||
rollback_request_count: bool = False,
|
||||
) -> None:
|
||||
try:
|
||||
kwargs = {
|
||||
"check_triggers": False,
|
||||
"expected_task_id": expected_task_id,
|
||||
}
|
||||
if rollback_request_count:
|
||||
kwargs["rollback_request_count"] = True
|
||||
pool.release(session.id, **kwargs)
|
||||
except Exception as release_error:
|
||||
logger.debug(f"manual command release failed: {release_error}")
|
||||
|
||||
|
||||
def _coerce_tab_index(value) -> Optional[int]:
|
||||
try:
|
||||
return int(value)
|
||||
except (TypeError, ValueError):
|
||||
return None
|
||||
|
||||
|
||||
def _manual_command_session_route_excluded(pool, session) -> bool:
|
||||
checker = getattr(pool, "_is_session_excluded_from_dynamic_routing", None)
|
||||
if callable(checker):
|
||||
try:
|
||||
return bool(checker(session))
|
||||
except Exception as exc:
|
||||
logger.debug(f"manual command route-exclusion session check failed: {exc}")
|
||||
|
||||
current_url = ""
|
||||
try:
|
||||
current_url, _domain = session.get_cached_route_snapshot()
|
||||
except Exception:
|
||||
current_url = str(getattr(session, "url", "") or "").strip()
|
||||
|
||||
if not current_url:
|
||||
try:
|
||||
info = session.get_info(use_cached_url=True)
|
||||
if isinstance(info, dict):
|
||||
current_url = str(info.get("url") or "").strip()
|
||||
except Exception:
|
||||
current_url = ""
|
||||
|
||||
if not current_url:
|
||||
return False
|
||||
|
||||
url_checker = getattr(pool, "is_url_excluded", None)
|
||||
if callable(url_checker):
|
||||
try:
|
||||
return bool(url_checker(current_url))
|
||||
except Exception as exc:
|
||||
logger.debug(f"manual command route-exclusion URL check failed: {exc}")
|
||||
return False
|
||||
|
||||
|
||||
def _manual_command_tab_item_route_excluded(pool, item) -> bool:
|
||||
if not isinstance(item, dict):
|
||||
return False
|
||||
if item.get("route_excluded"):
|
||||
return True
|
||||
|
||||
current_url = str(item.get("url") or item.get("current_url") or "").strip()
|
||||
if not current_url:
|
||||
return False
|
||||
|
||||
url_checker = getattr(pool, "is_url_excluded", None)
|
||||
if callable(url_checker):
|
||||
try:
|
||||
return bool(url_checker(current_url))
|
||||
except Exception as exc:
|
||||
logger.debug(f"manual command route-exclusion status check failed: {exc}")
|
||||
return False
|
||||
|
||||
|
||||
def _idle_tabs_for_manual_command(pool) -> List[dict]:
|
||||
items: List[dict] = []
|
||||
snapshot_failed = False
|
||||
if hasattr(pool, "get_sessions_snapshot"):
|
||||
try:
|
||||
sessions = pool.get_sessions_snapshot()
|
||||
except Exception:
|
||||
sessions = []
|
||||
snapshot_failed = True
|
||||
for session in sessions or []:
|
||||
if getattr(getattr(session, "status", None), "value", "") != "idle":
|
||||
continue
|
||||
tab_index = _coerce_tab_index(getattr(session, "persistent_index", None))
|
||||
if tab_index is None:
|
||||
continue
|
||||
if _manual_command_session_route_excluded(pool, session):
|
||||
continue
|
||||
items.append({"tab_index": tab_index, "session": session})
|
||||
if not hasattr(pool, "get_sessions_snapshot") or snapshot_failed:
|
||||
status = pool.get_status()
|
||||
for item in status.get("tabs", []) if isinstance(status, dict) else []:
|
||||
if item.get("status") != "idle":
|
||||
continue
|
||||
tab_index = _coerce_tab_index(item.get("persistent_index"))
|
||||
if tab_index is None:
|
||||
continue
|
||||
if _manual_command_tab_item_route_excluded(pool, item):
|
||||
continue
|
||||
items.append({"tab_index": tab_index, "session": None})
|
||||
|
||||
items.sort(key=lambda item: item["tab_index"])
|
||||
return items
|
||||
|
||||
|
||||
def _manual_command_matches_scope(cmd, session) -> bool:
|
||||
return command_engine._matches_scope(cmd, session)
|
||||
|
||||
|
||||
# ================= 请求模型 =================
|
||||
|
||||
class CommandCreateRequest(BaseModel):
|
||||
name: str = Field(default="新命令", max_length=100)
|
||||
enabled: bool = Field(default=True)
|
||||
log_enabled: bool = Field(default=True)
|
||||
log_level: str = Field(default="GLOBAL")
|
||||
mode: str = Field(default="simple")
|
||||
stop_on_error: bool = Field(default=False)
|
||||
trigger: dict = Field(default_factory=lambda: {
|
||||
"type": "request_count", "value": 10,
|
||||
"command_id": "",
|
||||
"action_ref": "",
|
||||
"match_rule": "equals",
|
||||
"expected_value": "",
|
||||
"match_mode": "keyword",
|
||||
"status_codes": "403,429,500,502,503,504",
|
||||
"abort_on_match": True,
|
||||
"scope": "all", "domain": "", "tab_index": None,
|
||||
"priority": 2,
|
||||
"stable_for_sec": 0,
|
||||
"check_while_busy_workflow": True
|
||||
})
|
||||
actions: list = Field(default_factory=lambda: [
|
||||
{"type": "clear_cookies"},
|
||||
{"type": "refresh_page"},
|
||||
])
|
||||
group_name: str = Field(default="")
|
||||
script: str = Field(default="")
|
||||
script_lang: str = Field(default="javascript")
|
||||
advanced_ui: dict = Field(default_factory=dict)
|
||||
|
||||
|
||||
class CommandUpdateRequest(BaseModel):
|
||||
name: Optional[str] = None
|
||||
enabled: Optional[bool] = None
|
||||
log_enabled: Optional[bool] = None
|
||||
log_level: Optional[str] = None
|
||||
mode: Optional[str] = None
|
||||
stop_on_error: Optional[bool] = None
|
||||
trigger: Optional[dict] = None
|
||||
actions: Optional[list] = None
|
||||
group_name: Optional[str] = None
|
||||
script: Optional[str] = None
|
||||
script_lang: Optional[str] = None
|
||||
advanced_ui: Optional[dict] = None
|
||||
|
||||
|
||||
class CommandReorderRequest(BaseModel):
|
||||
command_ids: List[str]
|
||||
|
||||
|
||||
class CommandGroupAssignRequest(BaseModel):
|
||||
command_ids: List[str]
|
||||
group_name: str = Field(default="", max_length=100)
|
||||
|
||||
|
||||
class CommandBatchEnabledRequest(BaseModel):
|
||||
command_ids: List[str]
|
||||
enabled: bool = Field(default=True)
|
||||
|
||||
|
||||
class CommandGroupEnabledRequest(BaseModel):
|
||||
enabled: bool = Field(default=True)
|
||||
|
||||
|
||||
class CommandGroupRenameRequest(BaseModel):
|
||||
new_group_name: str = Field(default="", max_length=100)
|
||||
|
||||
|
||||
class CommandGroupExecuteRequest(BaseModel):
|
||||
include_disabled: bool = Field(default=False)
|
||||
acquire_policy: str = Field(default="inherit_session")
|
||||
|
||||
|
||||
class CommandImageUploadRequest(BaseModel):
|
||||
filename: str = Field(default="image.png", max_length=255)
|
||||
data_url: str = Field(min_length=1)
|
||||
|
||||
|
||||
# ================= 路由 =================
|
||||
|
||||
@router.post("/api/commands/assets/image")
|
||||
async def upload_command_image(
|
||||
request: CommandImageUploadRequest,
|
||||
authenticated: bool = Depends(verify_auth),
|
||||
):
|
||||
encoded = str(request.data_url or "")
|
||||
if "," in encoded:
|
||||
encoded = encoded.split(",", 1)[1]
|
||||
try:
|
||||
payload = base64.b64decode(encoded, validate=True)
|
||||
except (ValueError, binascii.Error) as error:
|
||||
raise HTTPException(status_code=400, detail="图片数据不是有效的 Base64") from error
|
||||
if not payload or len(payload) > _MAX_COMMAND_IMAGE_BYTES:
|
||||
raise HTTPException(status_code=400, detail="图片必须小于 25 MB")
|
||||
|
||||
try:
|
||||
from PIL import Image
|
||||
|
||||
from io import BytesIO
|
||||
|
||||
with Image.open(BytesIO(payload)) as image:
|
||||
image.verify()
|
||||
image_format = str(image.format or "").lower()
|
||||
except Exception as error:
|
||||
raise HTTPException(status_code=400, detail="上传内容不是有效图片") from error
|
||||
|
||||
suffixes = {"png": ".png", "jpeg": ".jpg", "webp": ".webp", "gif": ".gif"}
|
||||
suffix = suffixes.get(image_format)
|
||||
if not suffix:
|
||||
raise HTTPException(status_code=400, detail=f"不支持的图片格式: {image_format or 'unknown'}")
|
||||
|
||||
_COMMAND_IMAGE_DIR.mkdir(parents=True, exist_ok=True)
|
||||
destination = _COMMAND_IMAGE_DIR / f"{uuid.uuid4().hex}{suffix}"
|
||||
destination.write_bytes(payload)
|
||||
return {"path": str(destination.resolve()), "filename": Path(request.filename).name, "size": len(payload)}
|
||||
|
||||
|
||||
@router.get("/api/commands")
|
||||
async def list_commands(authenticated: bool = Depends(verify_auth)):
|
||||
commands = command_engine.list_commands()
|
||||
return {"commands": _redact_command_secrets(commands), "count": len(commands)}
|
||||
|
||||
|
||||
@router.get("/api/commands/meta")
|
||||
async def get_meta(authenticated: bool = Depends(verify_auth)):
|
||||
return {
|
||||
"trigger_types": command_engine.get_trigger_types(),
|
||||
"action_types": command_engine.get_action_types(),
|
||||
}
|
||||
|
||||
|
||||
@router.get("/api/commands/states")
|
||||
async def get_trigger_states(authenticated: bool = Depends(verify_auth)):
|
||||
return {"states": command_engine.get_trigger_states()}
|
||||
|
||||
|
||||
@router.get("/api/commands/{command_id}/results")
|
||||
async def get_persistent_command_results(command_id: str, authenticated: bool = Depends(verify_auth)):
|
||||
if not command_engine.get_command(command_id):
|
||||
raise HTTPException(status_code=404, detail="命令不存在")
|
||||
records = list_command_results(command_id)
|
||||
return {"records": records, "count": len(records)}
|
||||
|
||||
|
||||
@router.delete("/api/commands/{command_id}/results")
|
||||
async def delete_persistent_command_results(
|
||||
command_id: str,
|
||||
rule_id: str = "",
|
||||
authenticated: bool = Depends(verify_auth),
|
||||
):
|
||||
if not command_engine.get_command(command_id):
|
||||
raise HTTPException(status_code=404, detail="命令不存在")
|
||||
return {"success": True, "removed": clear_command_results(command_id, rule_id=rule_id)}
|
||||
|
||||
|
||||
@router.get("/api/commands/{command_id}")
|
||||
async def get_command(command_id: str, authenticated: bool = Depends(verify_auth)):
|
||||
cmd = command_engine.get_command(command_id)
|
||||
if not cmd:
|
||||
raise HTTPException(status_code=404, detail="命令不存在")
|
||||
return _redact_command_secrets(cmd)
|
||||
|
||||
|
||||
@router.post("/api/commands")
|
||||
async def create_command(
|
||||
body: CommandCreateRequest,
|
||||
authenticated: bool = Depends(verify_auth)
|
||||
):
|
||||
cmd_data = body.model_dump()
|
||||
_reject_unresolved_secret_placeholders(cmd_data)
|
||||
cmd = command_engine.add_command(cmd_data)
|
||||
if not cmd:
|
||||
_raise_command_save_failed()
|
||||
return {"success": True, "command": _redact_command_secrets(cmd)}
|
||||
|
||||
|
||||
@router.post("/api/commands/{command_id}/duplicate")
|
||||
async def duplicate_command(command_id: str, authenticated: bool = Depends(verify_auth)):
|
||||
existing = command_engine.get_command_config(command_id)
|
||||
if not existing:
|
||||
raise HTTPException(status_code=404, detail="命令不存在")
|
||||
duplicated = command_engine.duplicate_command(command_id)
|
||||
if not duplicated:
|
||||
_raise_command_save_failed()
|
||||
return {"success": True, "command": _redact_command_secrets(duplicated)}
|
||||
|
||||
|
||||
@router.put("/api/commands/reorder")
|
||||
async def reorder_commands(
|
||||
body: CommandReorderRequest,
|
||||
authenticated: bool = Depends(verify_auth)
|
||||
):
|
||||
success = command_engine.reorder_commands(body.command_ids)
|
||||
if not success:
|
||||
_raise_command_save_failed()
|
||||
return {"success": success}
|
||||
|
||||
|
||||
@router.get("/api/command-groups")
|
||||
async def list_command_groups(authenticated: bool = Depends(verify_auth)):
|
||||
groups = command_engine.list_command_groups()
|
||||
return {"groups": groups, "count": len(groups)}
|
||||
|
||||
|
||||
@router.post("/api/command-groups/{group_name}/duplicate")
|
||||
async def duplicate_command_group(group_name: str, authenticated: bool = Depends(verify_auth)):
|
||||
normalized_name = (group_name or "").strip()
|
||||
existing_names = {item.get("name") for item in command_engine.list_command_groups()}
|
||||
if not normalized_name or normalized_name not in existing_names:
|
||||
raise HTTPException(status_code=404, detail="命令组不存在")
|
||||
result = command_engine.duplicate_group(normalized_name)
|
||||
if not result:
|
||||
_raise_command_save_failed()
|
||||
return {
|
||||
"success": True,
|
||||
"group_name": result["group_name"],
|
||||
"count": result["count"],
|
||||
"commands": _redact_command_secrets(result["commands"]),
|
||||
}
|
||||
|
||||
|
||||
@router.put("/api/command-groups")
|
||||
async def assign_command_group(
|
||||
body: CommandGroupAssignRequest,
|
||||
authenticated: bool = Depends(verify_auth)
|
||||
):
|
||||
updated = command_engine.set_commands_group(body.command_ids, body.group_name)
|
||||
if updated < 0:
|
||||
_raise_command_save_failed()
|
||||
return {"success": True, "updated": updated, "group_name": (body.group_name or "").strip()}
|
||||
|
||||
|
||||
@router.put("/api/commands/enabled")
|
||||
async def update_commands_enabled(
|
||||
body: CommandBatchEnabledRequest,
|
||||
authenticated: bool = Depends(verify_auth)
|
||||
):
|
||||
updated = command_engine.set_commands_enabled(body.command_ids, body.enabled)
|
||||
if updated < 0:
|
||||
_raise_command_save_failed()
|
||||
return {"success": True, "updated": updated, "enabled": body.enabled}
|
||||
|
||||
|
||||
@router.put("/api/command-groups/{group_name}/enabled")
|
||||
async def update_command_group_enabled(
|
||||
group_name: str,
|
||||
body: CommandGroupEnabledRequest,
|
||||
authenticated: bool = Depends(verify_auth)
|
||||
):
|
||||
normalized_name = (group_name or "").strip()
|
||||
updated = command_engine.set_group_enabled(normalized_name, body.enabled)
|
||||
if updated < 0:
|
||||
_raise_command_save_failed()
|
||||
return {
|
||||
"success": True,
|
||||
"updated": updated,
|
||||
"group_name": normalized_name,
|
||||
"enabled": body.enabled,
|
||||
}
|
||||
|
||||
|
||||
@router.put("/api/command-groups/{group_name}/rename")
|
||||
async def rename_command_group(
|
||||
group_name: str,
|
||||
body: CommandGroupRenameRequest,
|
||||
authenticated: bool = Depends(verify_auth)
|
||||
):
|
||||
source_name = (group_name or "").strip()
|
||||
target_name = (body.new_group_name or "").strip()
|
||||
if not source_name or not target_name:
|
||||
raise HTTPException(status_code=400, detail="命令组名称不能为空")
|
||||
if source_name == target_name:
|
||||
return {"success": True, "updated": 0, "group_name": source_name, "new_group_name": target_name}
|
||||
|
||||
existing_names = {item.get("name") for item in command_engine.list_command_groups()}
|
||||
if target_name in existing_names:
|
||||
raise HTTPException(status_code=400, detail=f"命令组已存在:{target_name}")
|
||||
|
||||
updated = command_engine.rename_group(source_name, target_name)
|
||||
if updated < 0:
|
||||
_raise_command_save_failed()
|
||||
return {
|
||||
"success": True,
|
||||
"updated": updated,
|
||||
"group_name": source_name,
|
||||
"new_group_name": target_name,
|
||||
}
|
||||
|
||||
|
||||
@router.delete("/api/command-groups/{group_name}")
|
||||
async def disband_command_group(
|
||||
group_name: str,
|
||||
authenticated: bool = Depends(verify_auth)
|
||||
):
|
||||
updated = command_engine.disband_group(group_name)
|
||||
if updated < 0:
|
||||
_raise_command_save_failed()
|
||||
return {"success": True, "updated": updated, "group_name": group_name}
|
||||
|
||||
|
||||
@router.put("/api/commands/{command_id}")
|
||||
async def update_command(
|
||||
command_id: str,
|
||||
body: CommandUpdateRequest,
|
||||
authenticated: bool = Depends(verify_auth)
|
||||
):
|
||||
updates = body.model_dump(exclude_none=True)
|
||||
existing = command_engine.get_command_config(command_id)
|
||||
if not existing:
|
||||
raise HTTPException(status_code=404, detail="命令不存在")
|
||||
updates = _restore_secret_placeholders(updates, existing)
|
||||
_reject_unresolved_secret_placeholders(updates)
|
||||
cmd = command_engine.update_command(command_id, updates)
|
||||
if not cmd:
|
||||
_raise_command_save_failed()
|
||||
return {"success": True, "command": _redact_command_secrets(cmd)}
|
||||
|
||||
|
||||
@router.delete("/api/commands/{command_id}")
|
||||
async def delete_command(command_id: str, authenticated: bool = Depends(verify_auth)):
|
||||
existing = command_engine.get_command_config(command_id)
|
||||
if not existing:
|
||||
raise HTTPException(status_code=404, detail="命令不存在")
|
||||
success = command_engine.delete_command(command_id)
|
||||
if not success:
|
||||
_raise_command_save_failed()
|
||||
return {"success": True}
|
||||
|
||||
|
||||
@router.post("/api/commands/{command_id}/test")
|
||||
async def test_command(command_id: str, authenticated: bool = Depends(verify_auth)):
|
||||
"""Manual trigger command test on all idle tabs that match command scope."""
|
||||
cmd = command_engine.get_command(command_id)
|
||||
if not cmd:
|
||||
raise HTTPException(status_code=404, detail="command_not_found")
|
||||
|
||||
try:
|
||||
from app.core.browser import get_browser
|
||||
|
||||
browser = get_browser(auto_connect=False)
|
||||
pool = browser.tab_pool
|
||||
|
||||
idle_tabs = _idle_tabs_for_manual_command(pool)
|
||||
|
||||
if not idle_tabs:
|
||||
raise HTTPException(status_code=409, detail="no_idle_tabs")
|
||||
|
||||
scheduled_tabs: List[int] = []
|
||||
skipped_tabs: List[int] = []
|
||||
failed_tabs: List[dict] = []
|
||||
|
||||
def _run_command_in_background(target_session, target_ctx):
|
||||
try:
|
||||
setattr(target_session, "_command_request_id", target_ctx.request_id)
|
||||
request_manager.start_request(target_ctx, tab_id=target_session.id)
|
||||
with command_engine._command_logging_context(cmd):
|
||||
execution_result = command_engine._execute_command(cmd, target_session)
|
||||
result_text = str((execution_result or {}).get("result") or "").strip()
|
||||
if result_text:
|
||||
request_manager.update_request_metadata(
|
||||
target_ctx.request_id,
|
||||
response_text=result_text,
|
||||
has_response_text=True,
|
||||
)
|
||||
if not target_ctx.should_stop() and target_ctx.status == RequestStatus.RUNNING:
|
||||
target_ctx.mark_completed()
|
||||
except Exception as e:
|
||||
logger.error(f"manual command test worker failed(tab={getattr(target_session, 'persistent_index', '?')}): {e}")
|
||||
target_ctx.mark_failed(str(e))
|
||||
finally:
|
||||
try:
|
||||
_finish_manual_command_request(
|
||||
target_ctx,
|
||||
success=(target_ctx.status == RequestStatus.COMPLETED),
|
||||
)
|
||||
finally:
|
||||
setattr(target_session, "_command_request_id", None)
|
||||
_release_manual_command_session(
|
||||
pool,
|
||||
target_session,
|
||||
expected_task_id=target_ctx.request_id,
|
||||
)
|
||||
|
||||
for tab_info in idle_tabs:
|
||||
tab_index = tab_info["tab_index"]
|
||||
candidate_session = tab_info.get("session")
|
||||
ctx = None
|
||||
session = None
|
||||
try:
|
||||
# Respect command scope even in manual test mode.
|
||||
if candidate_session is not None and not _manual_command_matches_scope(cmd, candidate_session):
|
||||
skipped_tabs.append(tab_index)
|
||||
continue
|
||||
|
||||
ctx = request_manager.create_request()
|
||||
session = pool.acquire_by_index(tab_index, ctx.request_id, timeout=3)
|
||||
if not session:
|
||||
ctx.mark_failed("acquire_failed")
|
||||
_finish_manual_command_request(ctx, success=False)
|
||||
failed_tabs.append({"tab_index": tab_index, "error": "acquire_failed"})
|
||||
continue
|
||||
|
||||
if not _manual_command_matches_scope(cmd, session):
|
||||
skipped_tabs.append(tab_index)
|
||||
_release_manual_command_session(
|
||||
pool,
|
||||
session,
|
||||
expected_task_id=ctx.request_id,
|
||||
rollback_request_count=True,
|
||||
)
|
||||
_finish_manual_command_request(ctx, success=False)
|
||||
continue
|
||||
|
||||
command_engine.submit_background_task(_run_command_in_background, session, ctx)
|
||||
scheduled_tabs.append(tab_index)
|
||||
except Exception as e:
|
||||
if ctx is not None and not ctx.is_terminal():
|
||||
ctx.mark_failed(str(e))
|
||||
_finish_manual_command_request(ctx, success=False)
|
||||
if session is not None and getattr(getattr(session, "status", None), "value", "") == "busy":
|
||||
_release_manual_command_session(
|
||||
pool,
|
||||
session,
|
||||
expected_task_id=ctx.request_id,
|
||||
rollback_request_count=True,
|
||||
)
|
||||
failed_tabs.append({"tab_index": tab_index, "error": str(e)})
|
||||
|
||||
if not scheduled_tabs:
|
||||
if skipped_tabs and not failed_tabs:
|
||||
raise HTTPException(
|
||||
status_code=409,
|
||||
detail=f"no_idle_tabs_match_scope, skipped={skipped_tabs}",
|
||||
)
|
||||
raise HTTPException(
|
||||
status_code=500,
|
||||
detail=f"command_test_failed, failed={failed_tabs}, skipped={skipped_tabs}",
|
||||
)
|
||||
|
||||
return {
|
||||
"success": True,
|
||||
"message": f"command scheduled on tabs: {scheduled_tabs}",
|
||||
"executed_tabs": scheduled_tabs,
|
||||
"skipped_tabs": skipped_tabs,
|
||||
"failed_tabs": failed_tabs,
|
||||
"executed_count": len(scheduled_tabs),
|
||||
}
|
||||
|
||||
except HTTPException:
|
||||
raise
|
||||
except Exception as e:
|
||||
logger.error(f"manual command test failed: {e}")
|
||||
raise HTTPException(status_code=500, detail=str(e))
|
||||
|
||||
|
||||
@router.post("/api/command-groups/{group_name}/execute")
|
||||
async def execute_command_group(
|
||||
group_name: str,
|
||||
body: Optional[CommandGroupExecuteRequest] = None,
|
||||
authenticated: bool = Depends(verify_auth)
|
||||
):
|
||||
normalized_name = (group_name or "").strip()
|
||||
if not normalized_name:
|
||||
raise HTTPException(status_code=400, detail="命令组名称不能为空")
|
||||
|
||||
include_disabled = bool(body.include_disabled) if body else False
|
||||
acquire_policy = str(body.acquire_policy or "inherit_session").strip() if body else "inherit_session"
|
||||
|
||||
try:
|
||||
from app.core.browser import get_browser
|
||||
browser = get_browser(auto_connect=False)
|
||||
pool = browser.tab_pool
|
||||
|
||||
idle_tabs = _idle_tabs_for_manual_command(pool)
|
||||
|
||||
if not idle_tabs:
|
||||
raise HTTPException(status_code=409, detail="没有空闲标签页可用于执行命令组")
|
||||
|
||||
skipped_tabs: List[dict] = []
|
||||
acquire_failures: List[int] = []
|
||||
|
||||
for tab_info in idle_tabs:
|
||||
tab_index = tab_info["tab_index"]
|
||||
group_task_id = f"group_test_{normalized_name}_{tab_index}_{time.time_ns()}"
|
||||
session = pool.acquire_by_index(tab_index, group_task_id, timeout=5)
|
||||
if not session:
|
||||
acquire_failures.append(tab_index)
|
||||
continue
|
||||
|
||||
try:
|
||||
plan = command_engine.preview_command_group(
|
||||
group_name=normalized_name,
|
||||
session=session,
|
||||
include_disabled=include_disabled,
|
||||
)
|
||||
if int(plan.get("runnable_count", 0) or 0) <= 0:
|
||||
skipped_tabs.append({
|
||||
"tab_index": tab_index,
|
||||
"runnable_count": plan.get("runnable_count", 0),
|
||||
"scope_skipped": plan.get("scope_skipped", 0),
|
||||
})
|
||||
continue
|
||||
|
||||
effective_acquire_policy = (
|
||||
"inherit_session" if acquire_policy == "require_acquire" else acquire_policy
|
||||
)
|
||||
result = command_engine.execute_command_group(
|
||||
group_name=normalized_name,
|
||||
session=session,
|
||||
include_disabled=include_disabled,
|
||||
acquire_policy=effective_acquire_policy,
|
||||
prepared_plan=plan,
|
||||
)
|
||||
if not result.get("ok") and not result.get("partial_ok"):
|
||||
raise HTTPException(status_code=400, detail=result.get("error", "命令组执行失败"))
|
||||
result["requested_acquire_policy"] = acquire_policy
|
||||
message = f"命令组已在标签页 #{tab_index} 执行"
|
||||
if result.get("partial_ok") and not result.get("ok"):
|
||||
message += "(部分命令被跳过或执行失败)"
|
||||
return {
|
||||
"success": True,
|
||||
"message": message,
|
||||
"tab_index": tab_index,
|
||||
**result,
|
||||
}
|
||||
finally:
|
||||
_release_manual_command_session(
|
||||
pool,
|
||||
session,
|
||||
expected_task_id=group_task_id,
|
||||
)
|
||||
|
||||
detail = {
|
||||
"error": "no_idle_tabs_match_group_scope",
|
||||
"skipped_tabs": skipped_tabs,
|
||||
"acquire_failures": acquire_failures,
|
||||
}
|
||||
raise HTTPException(status_code=409, detail=detail)
|
||||
|
||||
except HTTPException:
|
||||
raise
|
||||
except Exception as e:
|
||||
logger.error(f"执行命令组失败: {e}")
|
||||
raise HTTPException(status_code=500, detail=str(e))
|
||||
Reference in new issue
Block a user