@bangdao-ai/zentao-mcp 2.0.5 → 2.0.7

package/main.py

@@ -14,15 +14,24 @@ from dingtalk_stream import DingTalkStreamClient, Credential, ChatbotMessage
 
 from zenbot.config import JsonFormatter
 from zenbot.dingtalk_handler import ZentaoBotHandler
+from zenbot.logging_utils import struct_log
 
 load_dotenv()
 
-_stderr_handler = logging.StreamHandler(sys.stderr)
-_stderr_handler.setFormatter(JsonFormatter())
+def _setup_structured_logging() -> None:
+    fmt = JsonFormatter()
+    h = logging.StreamHandler(sys.stderr)
+    h.setFormatter(fmt)
+    for name in ("zentaoagent", "zentao_audit", "zentao_security"):
+        lg = logging.getLogger(name)
+        lg.handlers.clear()
+        lg.propagate = False
+        lg.addHandler(h)
+        lg.setLevel(logging.INFO)
 
+
+_setup_structured_logging()
 logger = logging.getLogger("zentaoagent")
-logger.addHandler(_stderr_handler)
-logger.setLevel(logging.INFO)
 
 
 def main():
@@ -36,7 +45,7 @@ def main():
     bot_handler = ZentaoBotHandler()
     client = DingTalkStreamClient(credential, logger)
     client.register_callback_handler(ChatbotMessage.TOPIC, bot_handler)
-    logger.info("ZenBot v2 启动中...")
+    struct_log(logger, logging.INFO, "zenbot_startup", component="main", version="v2")
     client.start_forever()
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bangdao-ai/zentao-mcp",
-  "version": "2.0.5",
+  "version": "2.0.7",
   "description": "禅道项目管理AI中枢 v2.0 — 35+MCP工具覆盖需求·任务·Bug·用例·发布·我的地盘全生命周期，原生API模式，Bug智能分类引擎+CSV批量用例导入+截图上传，一句话驱动禅道",
   "main": "index.js",
   "bin": {

package/src/core/zentao_nexus.py

@@ -15,6 +15,12 @@ import csv
 import shutil
 import requests
 
+try:
+    from zenbot.logging_utils import struct_log as _struct_log
+except ImportError:
+    def _struct_log(logger, level, event, msg=None, component=None, **ctx):
+        logger.log(level, f"{event} {ctx}")
+
 logger = logging.getLogger("zentaoagent")
 _security_logger = logging.getLogger("zentao_security")
 
@@ -26,7 +32,12 @@ def _init_allowed_dirs():
     if not _ALLOWED_WORK_DIRS:
         cwd = os.path.realpath(os.getcwd())
         tmp = os.path.realpath(os.getenv("TMPDIR", "/tmp"))
-        _ALLOWED_WORK_DIRS.extend([cwd, tmp])
+        home = os.path.realpath(os.path.expanduser("~"))
+        candidates = [cwd, tmp, home, "/tmp"]
+        for d in candidates:
+            real_d = os.path.realpath(d)
+            if real_d and real_d not in _ALLOWED_WORK_DIRS:
+                _ALLOWED_WORK_DIRS.append(real_d)
 
 
 def _safe_path(path: str, must_exist: bool = False) -> str:
@@ -128,7 +139,12 @@ class ZenTaoNativeClient:
             safe_form = {k: (v if k not in ('password',) else '***') for k, v in form_data.items()}
         else:
             safe_form = None
-        logger.info("禅道请求 m=%s&f=%s params=%s form=%s", module, action, safe_params, safe_form)
+        _struct_log(
+            logger, logging.INFO, "zentao_api_request",
+            component="zentao_api",
+            m=module, f=action, url_params=safe_params,
+            form_preview=safe_form,
+        )
 
         if not self.silent:
             self._log_request(url_params, form_data, files)
@@ -149,11 +165,22 @@ class ZenTaoNativeClient:
             resp_summary = json.dumps(result, ensure_ascii=False)
             if len(resp_summary) > 1000:
                 resp_summary = resp_summary[:1000] + f"...(truncated, total {len(resp_summary)} chars)"
-            logger.info("禅道响应 m=%s&f=%s http=%d body=%s", module, action, resp.status_code, resp_summary)
+            st = result.get("status")
+            info = result.get("info") or result.get("message") or ""
+            _struct_log(
+                logger, logging.INFO, "zentao_api_response",
+                component="zentao_api",
+                m=module, f=action, http_status=resp.status_code,
+                api_status=st, info_preview=str(info)[:400],
+                body_truncated=len(resp_summary) > 1000,
+            )
             return result
 
         except requests.exceptions.RequestException as e:
-            logger.error("禅道请求异常 m=%s&f=%s error=%s", module, action, e)
+            _struct_log(
+                logger, logging.ERROR, "zentao_api_transport_error",
+                component="zentao_api", m=module, f=action, error=str(e),
+            )
             return {"status": 0, "message": "fail", "info": f"请求失败: {e}", "data": {}}
 
     def _prepare_form_data(self, form_data: Optional[Dict]) -> Optional[list]:
@@ -831,6 +858,18 @@ class ZenTaoNativeClient:
 
 # ==================== 业务封装层 ====================
 
+
+class AmbiguousIdError(Exception):
+    """ID 同时匹配产品和项目，需要用户澄清"""
+    def __init__(self, numeric_id: str, product_name: str | None, project_name: str | None,
+                 product_projects: list | None = None):
+        self.numeric_id = numeric_id
+        self.product_name = product_name
+        self.project_name = project_name
+        self.product_projects = product_projects or []
+        super().__init__(f"ID {numeric_id} 同时是产品({product_name})和项目({project_name})")
+
+
 class ZenTaoNexus:
     """
     ZenTao Nexus v2.0 — 业务封装层
@@ -879,6 +918,72 @@ class ZenTaoNexus:
             return pid
         return self.product_id
 
+    def smart_resolve_product_id(self, user_input_id: Optional[str] = None) -> Dict:
+        """
+        智能解析用户给的数字 ID，判断它到底是 product 还是 project/execution。
+
+        DB 优先（1~2 条 SQL），API 兜底（2 次 HTTP）。
+
+        Returns:
+            {"product_id": str|None,   ← 最终可用的产品 ID
+             "input_type": "product"|"project"|"unknown",
+             "project_id": str|None,   ← 如果输入的是项目ID
+             "product_name": str|None,
+             "project_name": str|None,
+             "corrected": bool}        ← True 表示用户给的不是产品，做了纠正
+        """
+        uid = str(user_input_id or "").strip()
+        if not uid or uid == "0":
+            fallback = self.resolve_product_id()
+            return {"product_id": fallback if fallback != "0" else None,
+                    "input_type": "unknown", "project_id": None,
+                    "product_name": None, "project_name": None, "corrected": False}
+
+        # ── 1) DB 快速路径 ──
+        try:
+            from zenbot.db_resolver import identify_id_type_from_db
+            db_result = identify_id_type_from_db(uid)
+            if db_result:
+                if db_result["type"] == "product":
+                    _save_last_product_id(uid)
+                    return {"product_id": uid, "input_type": "product",
+                            "project_id": None, "product_name": db_result.get("product_name"),
+                            "project_name": None, "corrected": False}
+                else:
+                    real_pid = db_result.get("product_id")
+                    if real_pid:
+                        _save_last_product_id(real_pid)
+                    _struct_log(logger, logging.INFO, "smart_resolve_corrected",
+                                component="zentao_nexus",
+                                user_input=uid, actual_type="project",
+                                resolved_product_id=real_pid,
+                                project_name=db_result.get("project_name"))
+                    return {"product_id": real_pid, "input_type": "project",
+                            "project_id": uid,
+                            "product_name": db_result.get("product_name"),
+                            "project_name": db_result.get("project_name"),
+                            "corrected": True}
+        except Exception as e:
+            _struct_log(logger, logging.DEBUG, "smart_resolve_db_skip",
+                        component="zentao_nexus", error=str(e))
+
+        # ── 2) API 兜底 ──
+        id_info = self._identify_id_type(uid)
+        if id_info["type"] == "product":
+            _save_last_product_id(uid)
+            return {"product_id": uid, "input_type": "product",
+                    "project_id": None, "product_name": id_info.get("product_name"),
+                    "project_name": None, "corrected": False}
+        elif id_info["type"] == "project":
+            return {"product_id": None, "input_type": "project",
+                    "project_id": uid, "product_name": None,
+                    "project_name": None, "corrected": True}
+        else:
+            _save_last_product_id(uid)
+            return {"product_id": uid, "input_type": "unknown",
+                    "project_id": None, "product_name": None,
+                    "project_name": None, "corrected": False}
+
     def set_product_id(self, product_id: str) -> Dict:
         pid = str(product_id).strip()
         if not pid or pid == "0":
@@ -1104,6 +1209,19 @@ class ZenTaoNexus:
         return self.client.task_view(task_id)
 
     def create_task(self, task_data: Dict) -> Dict:
+        _TASK_ALIASES = {
+            "product_id": "product",
+            "project_id": "projectID",
+            "execution_id": "projectID",
+            "assigned_to": "assignedTo",
+            "est_started": "estStarted",
+        }
+        for alias, canonical in _TASK_ALIASES.items():
+            if alias in task_data and canonical not in task_data:
+                task_data[canonical] = task_data.pop(alias)
+            elif alias in task_data:
+                task_data.pop(alias)
+
         task_name = str(task_data.get('name', '') or '').strip()
         if task_data.get('assignedTo'):
             task_data['assignedTo'] = self.resolve_user_account(task_data['assignedTo']) or task_data['assignedTo']
@@ -1118,7 +1236,8 @@ class ZenTaoNexus:
 
         product_id = str(task_data.get('product') or self.product_id)
         requested_project_id = task_data.pop('project', task_data.pop('projectID', None))
-        project_id = self._resolve_project_id_for_product(product_id, requested_project_id)
+        project_id, product_id = self._resolve_project_and_product(
+            product_id, requested_project_id)
 
         # 1) 优先走稳定网关创建（可直接返回 taskID）
         gateway_payload = dict(task_data)
@@ -1218,27 +1337,135 @@ class ZenTaoNexus:
         """查询产品下可见项目列表。"""
         return self.client.product_project_pairs(product_id)
 
-    def _resolve_project_id_for_product(self, product_id, requested_project_id=None) -> str:
+    def _identify_id_type(self, unknown_id: str) -> Dict:
+        """
+        探测一个未知数字 ID 到底是 project(执行)、product(产品)、还是两者都是。
+
+        策略：同时检查 product 和 project，若两者都存在则返回 "both"。
+
+        Returns:
+            {"type": "product"|"project"|"both"|"unknown",
+             "product_id": str|None, "project_id": str|None,
+             "product_name": str|None, "project_name": str|None,
+             "projects": list}
+        """
+        uid = str(unknown_id).strip()
+        if not uid or uid == "0":
+            return {"type": "unknown", "product_id": None, "project_id": None,
+                    "product_name": None, "project_name": None, "projects": []}
+
+        is_product = False
+        product_name = None
+        product_projects = []
+
+        is_project = False
+        project_name = None
+        project_product_id = None
+        project_product_name = None
+
+        # ── 检查是否为 product ──
+        product_result = self.client.product_view(uid)
+        if product_result.get("status") in (1, "success"):
+            data = product_result.get("data", {})
+            if isinstance(data, dict) and data.get("id"):
+                is_product = True
+                product_name = data.get("name", "")
+                product_projects = self._get_projects_for_product(uid)
+
+        if not is_product:
+            proj_result = self.client.product_project_pairs(uid)
+            if proj_result.get("status") == 1:
+                projects = proj_result.get("data", {}).get("projects", [])
+                if projects:
+                    is_product = True
+                    product_projects = projects
+
+        # ── 检查是否为 project（查 zt_project 表或通过 task browse 探测） ──
+        try:
+            from zenbot.db_resolver import check_project_exists_from_db
+            proj_info = check_project_exists_from_db(uid)
+            if proj_info:
+                is_project = True
+                project_name = proj_info.get("project_name")
+                project_product_id = proj_info.get("product_id")
+                project_product_name = proj_info.get("product_name")
+        except Exception:
+            pass
+
+        if is_product and is_project:
+            return {"type": "both", "product_id": uid, "project_id": uid,
+                    "product_name": product_name, "project_name": project_name,
+                    "project_product_id": project_product_id,
+                    "project_product_name": project_product_name,
+                    "projects": product_projects}
+        elif is_product:
+            return {"type": "product", "product_id": uid,
+                    "project_id": product_projects[0]["id"] if product_projects else None,
+                    "product_name": product_name, "project_name": None,
+                    "projects": product_projects}
+        elif is_project:
+            return {"type": "project", "product_id": project_product_id,
+                    "project_id": uid,
+                    "product_name": project_product_name, "project_name": project_name,
+                    "projects": []}
+        else:
+            return {"type": "unknown", "product_id": None, "project_id": uid,
+                    "product_name": None, "project_name": None, "projects": []}
+
+    def _get_projects_for_product(self, product_id: str) -> list:
+        """获取产品下的项目列表，返回 [{"id": "...", "name": "..."}]"""
+        result = self.client.product_project_pairs(product_id)
+        if result.get("status") == 1:
+            return result.get("data", {}).get("projects", [])
+        return []
+
+    def _resolve_project_and_product(self, product_id, requested_project_id=None):
         """
-        解析任务创建所需 projectID：
-        1) 优先使用调用方显式传入的 project/projectID
-        2) 自动从产品下项目列表选择第一个可见项目
-        3) 兜底返回 "0"（由上层响应提示权限/关联问题）
+        智能解析任务创建所需的 (project_id, product_id)。
+
+        策略：
+        1) 用户显式传了 project_id → 探测真实类型
+           - "project" → 直接信任
+           - "both"（同时是产品和项目） → 抛 AmbiguousIdError，让上层追问用户
+           - "product"（纯产品） → 修正 product_id，从该产品下取第一个项目
+        2) 没有显式传入 → 从 product_id 的关联项目列表取第一个
+        3) 兜底 project_id="0"
+
+        Returns: (project_id: str, product_id: str)
+        Raises: AmbiguousIdError — 当 ID 同时是产品和项目时
         """
         if requested_project_id is not None:
             pid = str(requested_project_id).strip()
             if pid and pid != "0":
-                return pid
+                id_info = self._identify_id_type(pid)
+                _struct_log(logger, logging.INFO, "id_type_detection",
+                            component="zentao_nexus",
+                            input_id=pid, detected_type=id_info["type"],
+                            product_id=id_info.get("product_id"),
+                            project_id=id_info.get("project_id"),
+                            product_name=id_info.get("product_name"),
+                            project_name=id_info.get("project_name"))
+
+                if id_info["type"] == "both":
+                    raise AmbiguousIdError(
+                        numeric_id=pid,
+                        product_name=id_info.get("product_name"),
+                        project_name=id_info.get("project_name"),
+                        product_projects=id_info.get("projects", []),
+                    )
+                elif id_info["type"] == "product":
+                    real_product_id = id_info["product_id"] or pid
+                    real_project_id = id_info["project_id"]
+                    if real_project_id:
+                        return real_project_id, real_product_id
+                    product_id = real_product_id
+                else:
+                    return pid, product_id
 
-        projects_result = self.get_product_projects(product_id)
-        if projects_result.get("status") == 1:
-            projects = projects_result.get("data", {}).get("projects", [])
-            if projects:
-                pid = str(projects[0].get("id", "")).strip()
-                if pid:
-                    return pid
+        projects = self._get_projects_for_product(product_id)
+        if projects:
+            return projects[0]["id"], product_id
 
-        # 尝试从需求数据中推断项目（个别环境下 assignedProjectId/formProjectId 可用）
         stories = self.get_story_list(product_id)
         if stories.get("status") == 1 and isinstance(stories.get("data"), list):
             for story in stories["data"]:
@@ -1247,9 +1474,9 @@ class ZenTaoNexus:
                 for key in ("assignedProjectId", "formProjectId", "project", "projectID"):
                     val = str(story.get(key, "")).strip()
                     if val and val != "0":
-                        return val
+                        return val, product_id
 
-        return "0"
+        return "0", product_id
 
     def assign_task(self, task_id, assigned_to, comment=None) -> Dict:
         assigned_to = self.resolve_user_account(assigned_to) or assigned_to
@@ -1534,12 +1761,13 @@ class ZenTaoNexus:
         if not batch_cases:
             return [{"status": 0, "message": "CSV 中无有效用例行"}]
 
-        result = self.client.testcase_import_batch(self.product_id, batch_cases)
+        pid = self.resolve_product_id()
+        result = self.client.testcase_import_batch(pid, batch_cases)
         ok = result.get('status') == 1
 
         if ok:
             latest = self.client.testcase_browse(
-                self.product_id, orderBy='id_desc',
+                pid, orderBy='id_desc',
                 recPerPage=str(len(batch_cases) + 5))
             latest_cases = latest.get("data", {}).get("cases", [])
             if isinstance(latest_cases, dict):