@comate/zulu 1.4.0-beta.5 → 1.4.0-beta.6

package/comate-engine/assets/skills/code-security/scripts/ducc/open_browser.py

@@ -0,0 +1,191 @@
+#!/usr/bin/env python3
+"""
+在 DUCC 内嵌浏览器中打开硬编码风险治理网页。
+
+用法（凭证参数模式，与 credential_open_page.py 参数一致）:
+    python3 open_browser.py --chat-id <chatID> --username <用户名> \
+        [--ide-name <ideType>] [--repo <repo>] [--project-dir <目录>]
+
+用法（直接指定 URL 模式）:
+    python3 open_browser.py --url <url> [--title <标题>] [--pid <kernel_pid>]
+"""
+
+import argparse
+import glob
+import json
+import os
+import subprocess
+import socket
+import sys
+
+# 导入公共 URL 构建模块
+sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
+from credential_url import build_url_from_args
+
+
+def get_parent_pid(pid: int) -> int | None:
+    """获取进程的父进程 PID"""
+    try:
+        result = subprocess.run(
+            ["ps", "-p", str(pid), "-o", "ppid="],
+            capture_output=True, text=True, timeout=5
+        )
+        val = result.stdout.strip()
+        return int(val) if val else None
+    except Exception:
+        return None
+
+
+def find_kernel_socket() -> str | None:
+    """沿进程树向上追溯，找到有对应 comate-kernel socket 文件的祖先进程。
+
+    适用于 DUCC/Comate 两种环境：无论脚本由哪个父进程调用，
+    都能找到当前 VSCode 窗口对应的 kernel socket。
+    """
+    tmpdir = os.environ.get("TMPDIR", "/tmp").rstrip("/")
+    pid = os.getpid()
+    for _ in range(20):  # 最多向上追溯 20 层
+        pid = get_parent_pid(pid)
+        if not pid or pid == 1:
+            break
+        for sock_dir in [tmpdir, "/tmp"]:
+            sock_path = f"{sock_dir}/comate-kernel-{pid}.sock"
+            if os.path.exists(sock_path):
+                return sock_path
+    return None
+
+
+def open_url(url: str, pid: str = None, title: str = "网页") -> bool:
+    """在当前 DUCC 聊天框所在 VSCode 窗口的内嵌浏览器中打开 URL"""
+    tmpdir = os.environ.get("TMPDIR", "/tmp").rstrip("/")
+
+    body = json.dumps({
+        "action": "executeVirtualEditor",
+        "method": "openUrlInEditorWebview",
+        "payload": {"url": url, "title": title, "reuseExisting": True},
+    })
+    req = (
+        "POST /editor/command/ HTTP/1.1\r\n"
+        "Host: localhost\r\n"
+        "Content-Type: application/json\r\n"
+        f"Content-Length: {len(body.encode())}\r\n"
+        "Connection: close\r\n\r\n"
+        + body
+    )
+
+    def send_request(sock_path: str) -> bool:
+        try:
+            s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+            s.settimeout(3)
+            s.connect(sock_path)
+            s.send(req.encode())
+            resp = b""
+            while True:
+                chunk = s.recv(4096)
+                if not chunk:
+                    break
+                resp += chunk
+            s.close()
+            return b"ok" in resp
+        except Exception:
+            return False
+
+    # 如果指定了 PID，直接使用
+    if pid:
+        for sock_dir in [tmpdir, "/tmp"]:
+            sock_path = f"{sock_dir}/comate-kernel-{pid}.sock"
+            if os.path.exists(sock_path) and send_request(sock_path):
+                print(f"✅ 已在内嵌浏览器中打开 (PID: {pid})")
+                return True
+        print(f"❌ 连接失败 (PID: {pid})")
+        return False
+
+    # 优先使用 init_env.sh 在 shell 层检测到的 kernel PID
+    env_kernel_pid = os.environ.get("_KERNEL_PID", "").strip()
+    if env_kernel_pid:
+        for sock_dir in [tmpdir, "/tmp"]:
+            sock_path = f"{sock_dir}/comate-kernel-{env_kernel_pid}.sock"
+            if os.path.exists(sock_path) and send_request(sock_path):
+                print(f"✅ 已在内嵌浏览器中打开 (当前窗口 PID: {env_kernel_pid})")
+                return True
+
+    # 次选：Python 进程树向上查找
+    kernel_sock = find_kernel_socket()
+    if kernel_sock and send_request(kernel_sock):
+        k_pid = kernel_sock.rsplit("-", 1)[-1].replace(".sock", "")
+        print(f"✅ 已在内嵌浏览器中打开 (当前窗口 PID: {k_pid})")
+        return True
+
+    # 降级：用最新的活跃 socket（只考虑进程仍存在的）
+    def is_process_alive(pid_str: str) -> bool:
+        try:
+            subprocess.run(["ps", "-p", pid_str], capture_output=True, timeout=2, check=True)
+            return True
+        except Exception:
+            return False
+
+    socket_candidates = set(glob.glob(f"{tmpdir}/comate-kernel-*.sock") +
+                               glob.glob("/tmp/comate-kernel-*.sock"))
+
+    active_sockets = []
+    for sock_path in socket_candidates:
+        k_pid = sock_path.rsplit("-", 1)[-1].replace(".sock", "")
+        if is_process_alive(k_pid):
+            active_sockets.append((sock_path, k_pid))
+
+    # 先按访问时间排序尝试，再按修改时间排序
+    tried_pids = set()
+
+    for sort_key in [os.path.getatime, os.path.getmtime]:
+        sorted_sockets = sorted(active_sockets, key=lambda x: sort_key(x[0]), reverse=True)
+        for sock_path, k_pid in sorted_sockets:
+            if k_pid in tried_pids:
+                continue
+            if send_request(sock_path):
+                mode = "修改时间" if sort_key == os.path.getmtime else "访问时间"
+                print(f"✅ 已在内嵌浏览器中打开 (PID: {k_pid}, 降级模式 - 按{mode})")
+                return True
+            tried_pids.add(k_pid)
+
+    print("❌ 无法打开")
+    return False
+
+
+"""
+入口函数
+    python3 open_browser.py --chat-id <chatID> --username <用户名> \
+        [--ide-name <ideType>] [--repo <repo>] [--project-dir <目录>]
+    ducc打开硬编码风险治理页面。
+"""
+def main():
+    """入口函数：解析参数并在 DUCC 内嵌浏览器中打开硬编码风险治理网页。"""
+    parser = argparse.ArgumentParser(description="在 DUCC 内嵌浏览器中打开硬编码风险治理网页")
+
+    # 凭证参数模式（与 credential_open_page.py 一致）
+    parser.add_argument("--chat-id", help="会话 ID (_CHAT_ID)")
+    parser.add_argument("--username", help="用户名 (_USERNAME)")
+    parser.add_argument("--ide-name", default="ducc", help="IDE 类型")
+    parser.add_argument("--repo", default="", help="仓库标识，留空则自动从 git remote 获取")
+    parser.add_argument("--project-dir", default=".", help="项目目录，用于自动获取 repo")
+
+    # 直接指定 URL 模式
+    parser.add_argument("--url", help="直接指定要打开的 URL（与凭证参数模式二选一）")
+    parser.add_argument("--title", default="硬编码风险治理", help="页面标题")
+    parser.add_argument("--pid", help="指定 comate-kernel 进程 PID")
+
+    args = parser.parse_args()
+
+    if args.url:
+        url = args.url
+    elif args.chat_id and args.username:
+        url = build_url_from_args(args.chat_id, args.username, args.ide_name,
+                                   args.project_dir, args.repo)
+    else:
+        parser.error("必须提供 --url 或同时提供 --chat-id 和 --username")
+
+    success = open_url(url, args.pid, args.title)
+    sys.exit(0 if success else 1)
+
+
+if __name__ == "__main__":
+    main()

package/comate-engine/assets/skills/code-security/scripts/parse_scan_result.py

@@ -35,6 +35,7 @@ parsed_result.json 格式:
         "startLine": 12,
         "endLine": 12,
         "hash": "abc123...",
+        "importPath": "com.example:foo:1.2.3",
         "is_sensitive": false,
         "aiAnalysisStatus": 0,
         "aiAnalysisStatusText": "无需分析",
@@ -43,9 +44,10 @@ parsed_result.json 格式:
 
 aiAnalysisStatus 说明:
     0 - 无需分析
-    1 - 分析中
+    1 - 分析中（脚本会单独归类到 analyzing_vuls；后续工作流会通过本地兜底分析判定，
+        被判定为真实漏洞的会重新合入修复列表）
     2 - 真实漏洞
-    3 - 误报（不进入修复流程）
+    3 - 误报（始终不进入修复流程）
 """
 
 import argparse
@@ -83,10 +85,13 @@ def parse_scan_result(scan_result):
     # type: (dict) -> dict
     """解析扫描结果，返回结构化漏洞数据。
 
-    aiAnalysisStatus=3 (误报) 和 aiAnalysisStatus=1 (分析中) 的漏洞会被单独归类，不进入修复流程。
+    aiAnalysisStatus=3（误报）和 aiAnalysisStatus=1（分析中）的漏洞会被单独归类。
+    误报永远不进入修复流程；分析中漏洞需先经工作流的「本地兜底分析」复核，
+    被判定为真实漏洞的会被合并回修复列表。
     """
-    data = scan_result.get("data", {})
-    runs = data.get("sarif", {}).get("runs", []) or data.get("runs", [])
+    data = scan_result.get("data", {}) or {}
+    sarif = data.get("sarif") or {}
+    runs = sarif.get("runs") or data.get("runs") or []
 
     # 提取 bundleHash（由 scan_vulnerability.py 写入顶层）
     bundle_hash = scan_result.get("bundleHash", "")
@@ -122,6 +127,8 @@ def parse_scan_result(scan_result):
             level = level_config.get("level", "NONE") if level_config else "NONE"
             level_cn = LEVEL_MAP.get(level, "低危")
             vul_hash = result.get("properties", {}).get("hash", "")
+            # SCA 类漏洞会带有非空 importPath（依赖引入路径），用于后续判定是否走 SCA 本地修复
+            import_path = result.get("properties", {}).get("importPath", "") or ""
 
             # AI 分析状态
             ai_status = result.get("properties", {}).get("aiAnalysisStatus", 0)
@@ -172,6 +179,7 @@ def parse_scan_result(scan_result):
                 "startLine": start_line,
                 "endLine": end_line,
                 "hash": vul_hash,
+                "importPath": import_path,
                 "is_sensitive": is_sensitive,
                 "aiAnalysisStatus": ai_status,
                 "aiAnalysisStatusText": ai_status_text,
@@ -197,6 +205,23 @@ def parse_scan_result(scan_result):
     false_positive_vuls.sort(key=sort_key)
     analyzing_vuls.sort(key=sort_key)
 
+    # 去重：仅当 hash 相同（即扫描端认定为同一漏洞）时才合并；
+    # 不能仅按 (file, startLine, endLine, is_sensitive) 去重——多条来源不同的漏洞
+    # 可能共享同一个 sink 点（例如多个数据流汇入同一行），它们的 hash 各不相同，
+    # 必须各自保留以便后续修复完整覆盖。
+    def deduplicate(vuls):
+        seen = set()
+        result = []
+        for v in vuls:
+            key = v.get("hash") or (v["file"], v["startLine"], v["endLine"], v["is_sensitive"])
+            if key not in seen:
+                seen.add(key)
+                result.append(v)
+        return result
+
+    common_vuls = deduplicate(common_vuls)
+    sensitive_vuls = deduplicate(sensitive_vuls)
+
     return {
         "total": len(common_vuls) + len(sensitive_vuls) + len(false_positive_vuls) + len(analyzing_vuls),
         "common_count": len(common_vuls),
@@ -263,6 +288,11 @@ def format_vul_report(vuls, title="漏洞报告", project_dir=""):
             loc_link = _make_file_link(vul["file"], vul["startLine"], project_dir)
             lines.append("    - {}".format(loc_link))
 
+            # SCA 漏洞展示依赖引入路径（importPath），便于定位需要升级的依赖链
+            import_path = vul.get("importPath", "")
+            if import_path:
+                lines.append("      - **依赖引入路径**：`{}`".format(import_path))
+
             # 数据流折叠展示
             if vul["codeFlows"]:
                 lines.append("      <details><summary>数据流</summary>\n")
@@ -303,30 +333,32 @@ def format_full_report(parsed, project_dir=""):
     if false_positive_count > 0:
         summary_parts.append("**{}** 个误报（已由 AI 分析确认，无需修复）".format(false_positive_count))
 
+    if analyzing_count > 0:
+        summary_parts.append("**{}** 个漏洞正在 AI 分析中（暂未判定）".format(analyzing_count))
+
     if summary_parts:
         parts.append("扫描发现 {}。\n".format("，".join(summary_parts)))
     else:
-        if analyzing_count > 0:
-            parts.append("扫描完成，**{}** 个漏洞正在 AI 分析中，暂未发现已确认的漏洞。\n".format(analyzing_count))
-        else:
-            parts.append("扫描完成，未发现漏洞。\n")
+        parts.append("扫描完成，未发现漏洞。\n")
         return "\n".join(parts)
 
-    if analyzing_count > 0:
-        parts.append("另有 **{}** 个漏洞正在 AI 分析中，分析完成后可能会被判定为误报而排除，分析期间暂不处理。\n".format(analyzing_count))
-
-    # 只有误报没有真实漏洞的情况
-    if real_vul_count == 0 and false_positive_count > 0:
+    # 只有误报没有真实漏洞、且没有分析中的情况（才能断言“全部为误报”）
+    if real_vul_count == 0 and false_positive_count > 0 and analyzing_count == 0:
         parts.append("所有检测到的漏洞均已被 AI 分析确认为误报，无需进行修复。\n")
         if parsed.get("false_positive_vuls"):
             parts.append(format_vul_report(parsed["false_positive_vuls"], "误报漏洞列表（仅供参考）", project_dir))
         return "\n".join(parts)
 
+    # 仅剩分析中的情况（无真实漏洞、无误报）
+    if real_vul_count == 0 and false_positive_count == 0 and analyzing_count > 0:
+        parts.append("当前暂无已确认的漏洞，需等待 AI 分析完成后再评估。\n")
+        return "\n".join(parts)
+
     if parsed["common_vuls"]:
         parts.append(format_vul_report(parsed["common_vuls"], "普通漏洞报告", project_dir))
 
     if parsed["sensitive_vuls"]:
-        parts.append(format_vul_report(parsed["sensitive_vuls"], "硬编码漏洞报告", project_dir))
+        parts.append(format_sensitive_table(parsed["sensitive_vuls"], 10, project_dir))
 
     # 误报漏洞折叠展示
     if false_positive_count > 0:
@@ -346,6 +378,42 @@ def format_full_report(parsed, project_dir=""):
 
     return "\n".join(parts)
 
+def format_sensitive_table(vuls, collapse_threshold=5, project_dir=""):
+    # type: (list, int, str) -> str
+    """将硬编码漏洞列表格式化为 Markdown 表格。
+
+    当漏洞数量超过 collapse_threshold 时，使用 <details> 标签折叠展示，
+    点击可展开或收起；否则直接展示完整表格。
+
+    Args:
+        vuls: 漏洞列表
+        collapse_threshold: 超过该行数时触发折叠（默认 5）
+        project_dir: 项目根目录，用于生成可点击的绝对路径链接。若为空，则相对路径链接。
+
+    Returns:
+        Markdown 
+    """
+    if not vuls:
+        return "未发现硬编码漏洞。\n"
+
+    total = len(vuls)
+    header = "| 序号 | 漏洞名称 | 漏洞位置 | 漏洞等级 |\n| --- | --- | --- | --- |"
+    rows = []
+    for idx, vul in enumerate(vuls, 1):
+        loc_link = _make_file_link(vul["file"], vul["startLine"], project_dir)
+        rows.append("| {} | {} | {} | {} |".format(idx, vul["name"], loc_link, vul["level_cn"]))
+
+    if total <= collapse_threshold:
+        return "{}\n{}\n".format(header, "\n".join(rows))
+
+    # 前 collapse_threshold 条直接展示，超出部分用 <details> 折叠
+    visible = "{}\n{}".format(header, "\n".join(rows[:collapse_threshold]))
+    hidden_rows = rows[collapse_threshold:]
+    hidden_table = "{}\n{}".format(header, "\n".join(hidden_rows))
+    collapsed = "<details>\n<summary>展开查看剩余 {} 条漏洞</summary>\n\n{}\n\n</details>".format(
+        len(hidden_rows), hidden_table
+    )
+    return "{}\n\n{}\n".format(visible, collapsed)
 
 def main():
     """
@@ -374,6 +442,21 @@ def main():
     # 解析
     parsed = parse_scan_result(scan_result)
 
+    # 紧凑统计行（必须优先打印，保证即使后续长报告被截断，计数仍可被模型读取）
+    stats_line = (
+        "STATS: total={total} common={common} sensitive={sensitive}"
+        " false_positive={fp} analyzing={analyzing}"
+    ).format(
+        total=parsed["total"],
+        common=parsed["common_count"],
+        sensitive=parsed["sensitive_count"],
+        fp=parsed["false_positive_count"],
+        analyzing=parsed["analyzing_count"],
+    )
+    print(stats_line)
+    print(stats_line, file=sys.stderr)
+    print("")
+
     # 输出 Markdown 报告到标准输出
     report = format_full_report(parsed, args.project_dir)
     print(report)
@@ -389,4 +472,4 @@ def main():
 
 
 if __name__ == "__main__":
-    main()
+    main()

package/comate-engine/assets/skills/code-security/scripts/repair_vulnerability.py

@@ -30,8 +30,8 @@ import utils
 
 logger = logging.getLogger("repair")
 
-# 修复轮询最大次数（每次间隔 3 秒，约 10 分钟）
-MAX_REPAIR_POLLS = 200
+# 修复轮询最大次数（每次间隔 3 秒，约 5 分钟）
+MAX_REPAIR_POLLS = 100
 REPAIR_POLL_INTERVAL = 3
 MAX_UPLOAD_RETRIES = 10
 
@@ -40,8 +40,10 @@ def diff_file_content(file_path, new_content):
     # type: (str, str) -> str
     """比较原文件与修复后内容，使用 difflib 生成精确 diff，返回 diff 列表 JSON。
 
-    每个不连续的变更区域（hunk）生成独立的 {from_content, to_content} 对，
-    确保每个 from_content 都是原文件中的连续子串，可以被 str.replace 精确匹配。
+    每个不连续的变更区域（hunk）生成独立的 {from_content, to_content} 对。
+    携带 n=3 上下文行，确保：
+    1. from_content 包含足够上下文在文件中唯一，str.replace 不会误匹配
+    2. 纯插入 hunk（只有 + 行）也有上下文锚点，from_content 不会为空字符串
     """
     with open(file_path, "r", encoding="utf-8") as f:
         old_content = f.read()
@@ -49,8 +51,8 @@ def diff_file_content(file_path, new_content):
     old_lines = old_content.splitlines(keepends=True)
     new_lines = new_content.splitlines(keepends=True)
 
-    # 使用 unified_diff 找出所有差异区域，n=0 不提供上下文行
-    diff = list(difflib.unified_diff(old_lines, new_lines, n=0))
+    # n=3 携带上下文行，避免 from_content 为空或匹配不唯一
+    diff = list(difflib.unified_diff(old_lines, new_lines, n=3))
 
     diffs = []  # type: list
     current_from = []  # type: list
@@ -68,6 +70,16 @@ def diff_file_content(file_path, new_content):
     for line in diff:
         if line.startswith("---") or line.startswith("+++"):
             continue
+        elif line.startswith("\\"):
+            # 防御性处理：兼容 git/POSIX 风格 diff 的 "" 标记。
+            # Python 标准库 difflib 当前版本不会输出该标记，但 splitlines(keepends=True)
+            # 已经天然保留了原文件是否以换行结尾的状态——若出现该标记，说明上一行实际无尾随换行，
+            # 此处主动剥掉可能被误加入的 "\n"，确保 from_content 能在原文件中精确匹配。
+            if current_from and current_from[-1].endswith("\n"):
+                current_from[-1] = current_from[-1][:-1]
+            if current_to and current_to[-1].endswith("\n"):
+                current_to[-1] = current_to[-1][:-1]
+            continue
         elif line.startswith("@@"):
             # 新 hunk 开始，先保存上一组
             _flush()
@@ -75,6 +87,11 @@ def diff_file_content(file_path, new_content):
             current_from.append(line[1:])
         elif line.startswith("+"):
             current_to.append(line[1:])
+        else:
+            # 上下文行（空格前缀），同时加入 from 和 to 作为锚点
+            context_line = line[1:]
+            current_from.append(context_line)
+            current_to.append(context_line)
 
     # 保存最后一组
     _flush()
@@ -133,7 +150,7 @@ def repair_vulnerability(root_path, vulnerability_info, username, user_id, chat_
             if upload_retry_count > MAX_UPLOAD_RETRIES:
                 print("错误: 修复上传重试 {} 次后仍有缺失文件".format(MAX_UPLOAD_RETRIES), file=sys.stderr)
                 return {"status": -1, "message": "修复上传重试次数超限"}
-            print("上传缺失文件: {} 个 (重试 {}/{})".format(len(missing),
+            print("上传缺失文件: {} 个 (重试 {}/{})".format(len(missing), 
                                                    upload_retry_count, MAX_UPLOAD_RETRIES), file=sys.stderr)
             upload_files_for_repair(root_path, missing, username, user_id, chat_id)
             time.sleep(REPAIR_POLL_INTERVAL)
@@ -155,21 +172,39 @@ def repair_vulnerability(root_path, vulnerability_info, username, user_id, chat_
             return result
 
         poll_count += 1
-        print("修复中，等待结果... ({}/{})".format(poll_count, MAX_REPAIR_POLLS), file=sys.stderr)
+        progress = min(99, int(poll_count * 100 / MAX_REPAIR_POLLS))
+        print("修复中... {}%".format(progress), file=sys.stderr)
         time.sleep(REPAIR_POLL_INTERVAL)
 
-    print("错误: 修复超时，已轮询 {} 次仍未完成".format(MAX_REPAIR_POLLS), file=sys.stderr)
+    print("错误: 修复超时，已等待超过预期时间", file=sys.stderr)
     return {"status": -1, "message": "修复超时"}
 
 
+def is_sca_vuln(vul):
+    # type: (dict) -> bool
+    """判定是否为 SCA 类漏洞。
+
+    SCA 漏洞的修复方式是升级依赖版本，与代码改写无关，后端修复接口对其无能为力，
+    因此直接在本地参考修复手册（references/vul_repair-sca.md）处理，不发起后端请求。
+
+    判定规则：漏洞条目带有非空 `importPath` 字段即为 SCA 漏洞。
+    """
+    return bool(vul.get("importPath"))
+
+
 def build_vulnerability_info(parsed):
     # type: (dict) -> dict
-    """从 parsed_result.json 构建修复接口所需的 vulnerability-info。"""
+    """从 parsed_result.json 构建修复接口所需的 vulnerability-info。
+
+    SCA 类漏洞会被过滤掉，不进入后端修复请求，由 agent 在本地参考手册自行修复。
+    """
     bundle_hash = parsed.get("bundle_hash", "")
     common_vuls = parsed.get("common_vuls", [])
 
     file_map = {}  # type: dict
     for vul in common_vuls:
+        if is_sca_vuln(vul):
+            continue
         fname = vul.get("file", "")
         if not fname:
             continue
@@ -207,7 +242,7 @@ def main():
 
     user_id = utils.make_user_id(args.username)
 
-    logger.info("repair_vulnerability start: username=%s, chat_id=%s, root_path=%s", args.username,
+    logger.info("repair_vulnerability start: username=%s, chat_id=%s, root_path=%s", args.username, 
                 args.chat_id, args.root_path)
 
     root_path = os.path.realpath(args.root_path)
@@ -228,6 +263,23 @@ def main():
             print("无普通漏洞需要修复", file=sys.stderr)
             sys.exit(0)
         vulnerability_info = build_vulnerability_info(parsed)
+        # 全部为 SCA 漏洞时，后端 files 为空，直接走本地兜底，由 agent 参考
+        # references/vul_repair-sca.md 修复
+        if not vulnerability_info.get("files"):
+            sca_count = sum(1 for v in parsed.get("common_vuls", []) if is_sca_vuln(v))
+            result = {
+                "status": -3,
+                "message": "all_vulns_are_sca_use_local_fallback",
+                "fallback": True,
+                "sca_only": True,
+                "sca_count": sca_count,
+                "data": {"files": []},
+            }
+            output_file = os.path.join(output_dir, "repair_result.json")
+            with open(output_file, "w", encoding="utf-8") as f:
+                json.dump(result, f, ensure_ascii=False, indent=2)
+            print(output_file)
+            return
     else:
         try:
             vulnerability_info = json.loads(args.vulnerability_info)
@@ -235,7 +287,8 @@ def main():
             print("错误: 漏洞信息 JSON 解析失败: {}".format(e), file=sys.stderr)
             sys.exit(1)
 
-    result = repair_vulnerability(root_path, vulnerability_info, args.username, user_id, args.chat_id)
+    result = repair_vulnerability(
+        root_path, vulnerability_info, args.username, user_id, args.chat_id)
 
     output_file = os.path.join(output_dir, "repair_result.json")
     with open(output_file, "w", encoding="utf-8") as f:
@@ -244,4 +297,4 @@ def main():
 
 
 if __name__ == "__main__":
-    main()
+    main()

package/comate-engine/assets/skills/code-security/scripts/scan_vulnerability.py

@@ -244,16 +244,31 @@ def get_analyzing_count(result):
     return count
 
 
+def _has_valid_runs(result):
+    # type: (dict) -> bool
+    """检查结果中是否包含有效的 runs 数据（非空列表）。"""
+    data = result.get("data") or {}
+    sarif = data.get("sarif") or {}
+    runs = sarif.get("runs") or data.get("runs")
+    return bool(runs)
+
+
 def _poll_ai_analysis(scan_info, chat_id, username, user_id, ai_analysis_timeout):
     # type: (dict, str, str, str, int) -> dict
-    """轮询等待 AI 分析完成，返回最新结果。"""
+    """轮询等待 AI 分析完成，返回最新结果。
+
+    维护 last_valid_result：仅当响应 status != 1 且 runs 非空时更新。
+    超时或循环结束时返回 last_valid_result（而非最后一次可能为空的响应），
+    避免服务端中间态导致漏洞数据丢失。
+    """
     start_time = time.time()
     poll_interval = 10
+    last_valid_result = None  # type: dict | None
 
     while True:
         elapsed = time.time() - start_time
         if elapsed >= ai_analysis_timeout:
-            print("\nAI 分析等待超时（已等待 {} 分钟），将使用当前结果继续".format(
+            print("\nAI 分析等待超时（已等待 {} 分钟），将使用最近有效结果继续".format(
                 int(elapsed // 60)), file=sys.stderr)
             logger.warning("AI analysis timeout after %d seconds", int(elapsed))
             break
@@ -266,17 +281,29 @@ def _poll_ai_analysis(scan_info, chat_id, username, user_id, ai_analysis_timeout
             json_body=scan_info,
         )
 
+        # 记录有效结果：status != 1 且 runs 非空
+        if result.get("status") != 1 and _has_valid_runs(result):
+            last_valid_result = result
+
         analyzing_count = get_analyzing_count(result)
-        if analyzing_count == 0:
+        # status=1 表示服务端扫描/分析仍在进行中，此时 runs 通常为 null，
+        # 不能仅凭 analyzing_count == 0 就判定分析完成，需要 status != 1 才算真正完成
+        if result.get("status") != 1 and analyzing_count == 0:
             print("\nAI 分析完成！", file=sys.stderr)
             logger.info("AI analysis completed after %d seconds", int(time.time() - start_time))
             return result
 
-        elapsed_min = int(elapsed // 60)
-        elapsed_sec = int(elapsed % 60)
-        print("AI 分析中... 剩余 {} 个漏洞待分析（已等待 {}分{}秒）".format(
-            analyzing_count, elapsed_min, elapsed_sec), file=sys.stderr)
+        elapsed_progress = min(99, int(elapsed * 100 / ai_analysis_timeout)) if ai_analysis_timeout > 0 else 0
+        if result.get("status") == 1:
+            print("AI 分析中... {}%（服务端仍在处理）".format(elapsed_progress), file=sys.stderr)
+        else:
+            print("AI 分析中... {}%（剩余 {} 个漏洞待分析）".format(
+                elapsed_progress, analyzing_count), file=sys.stderr)
 
+    # 超时：优先返回最近一次有效结果，避免返回 runs 为空的中间态
+    if last_valid_result is not None:
+        return last_valid_result
+    # 兜底：如果从未拿到过有效结果，返回最后一次响应（调用方会做写入前校验）
     return result
 
 
@@ -325,11 +352,12 @@ def scan_vulnerability(root_path, chat_id="", username="", user_id="", wait_ai=T
         if result.get("status") != 1:
             break
         poll_count += 1
-        print("扫描中，等待结果... ({}/{})".format(poll_count, MAX_SCAN_POLLS), file=sys.stderr)
+        progress = min(99, int(poll_count * 100 / MAX_SCAN_POLLS))
+        print("扫描中... {}%".format(progress), file=sys.stderr)
         time.sleep(SCAN_POLL_INTERVAL)
 
     if result.get("status") == 1:
-        print("错误: 扫描超时，已轮询 {} 次仍未完成".format(MAX_SCAN_POLLS), file=sys.stderr)
+        print("错误: 扫描超时，已等待超过预期时间", file=sys.stderr)
         return {"status": -1, "message": "扫描超时"}, bundle_hash
 
     # 第二阶段：等待 AI 分析完成（可选）
@@ -417,10 +445,14 @@ def main():
             root_path, args.scan_result, chat_id=args.chat_id,
             username=args.username, user_id=user_id,
         )
-        # 原地更新 scan_result.json
+        # 原地更新 scan_result.json（仅当结果包含有效 runs 时才覆盖，防止超时中间态清空漏洞）
         output_file = os.path.realpath(args.scan_result)
-        with open(output_file, "w", encoding="utf-8") as f:
-            json.dump(result, f, ensure_ascii=False, indent=2)
+        if _has_valid_runs(result):
+            with open(output_file, "w", encoding="utf-8") as f:
+                json.dump(result, f, ensure_ascii=False, indent=2)
+        else:
+            print("警告: AI 分析结果中 runs 为空，保留原 scan_result.json 不覆盖", file=sys.stderr)
+            logger.warning("AI analysis result has empty runs, skip overwriting %s", output_file)
         print(output_file)
     else:
         # 正常扫描模式

package/comate-engine/assets/skills/create-automation/SKILL.md

@@ -7,6 +7,9 @@ description: |
   - "每天/每周/每月自动帮我做..."
   - 配置 webhook 触发任务
   不适用于普通的一次性任务请求，仅适用于需要周期性或事件驱动执行的自动化配置。
+metadata:
+    enableWhen:
+        - isComateIDE
 disable-model-invocation: true
 ---