Files
2026-11-02 22:54:14 +08:00

883 lines
31 KiB
Python

"""
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))