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

package/comate-engine/assets/skills/code-security/references/vul_repair-go_sql_injection.md

@@ -9,7 +9,7 @@ go sqli 漏洞修复知识
 2. 污点数据拼接到 sql 语句时，是作为 sql 语句中 select、update、delete 等子句，且无法确定子句具体信息，也是不可修复场景，不进行漏洞修复。
 
 ### 可修复场景
-1. 漏洞修复必须在 **SQL 执行语句（sink 点）所在的文件和函数内**完成，不要创建新的代码文件。
+1. 漏洞修复必须在 **SQL 语句生成 或者 SQL 语句执行所在的文件和函数内以及数据流传递链路所在文件**完成，不要创建新的代码文件。
 2. 同个文件进行参数过滤时，可以在文件头定义过滤正则，如果定义已经存在，可以直接复用。
 3. 对于 where 列名（操作符）之后的 value、insert 的values、like 的 value，需要使用**预编译/参数绑定**的方式进行漏洞修复。**注意**：LIKE 子句的值虽然可以预编译，但 `%` 和 `_` 是 SQL 通配符，若用户输入包含这些字符可能导致非预期的模糊匹配。如需精确匹配，应先转义这些字符：
 
@@ -1018,4 +1018,4 @@ Beego ORM同样存在直接拼接SQL导致注入的风险。
 // 安全: 使用参数化查询
 o.Raw("SELECT * FROM users WHERE username = ?", username).QueryRow(&user)
 ```
-##
+## 

package/comate-engine/assets/skills/code-security/references/vul_repair-sca.md

@@ -0,0 +1,225 @@
+SCA（软件成分分析）漏洞修复知识
+
+## 概述
+
+SCA 类漏洞不是源码层面的代码缺陷，而是项目依赖了存在已知漏洞（CVE / 内部安全公告）的第三方组件。修复方式是 **升级依赖包到安全版本**，一般不需要改动业务源码。本文档只覆盖 **Go 和 Java** 两种生态。
+
+## 核心原则
+
+1. **只改依赖清单文件，不要改业务源码**。SCA 修复的本质是换版本，业务代码不应被触碰。
+2. **必须升到扫描结果里标注的 "安全版本" 或更高**，不能升到更低的补丁版本，否则复测仍会命中。
+3. **保持其他依赖不变**，只修改受影响的那一行，避免连锁破坏构建。
+4. **版本号格式必须符合该包管理器的约定**（Go 的 `v` 前缀、Maven 的 `<version>` 等），不要随意改变版本声明风格。
+
+## 从 `scan_result.json` 提取修复信息
+
+对于 SCA 类漏洞，`scan_result.json`（或解析出的 `parsed_result.json`）里通常包含以下关键字段（位置见 SARIF 的 `results[].properties` 或 `rules[]`）：
+
+| 字段 | 用途 |
+|------|------|
+| `importPath` | 漏洞组件的**引入路径 / 包名**（如 `github.com/baidubce/bce-sdk-go` 或 `org.apache.logging.log4j:log4j-core`）。如果为空字符串，说明该条结果不是 SCA 场景，应按源码类漏洞处理。 |
+| `description` / `suggestion` | 通常会写明受影响版本区间和建议升级到的安全版本（例如 "v0.9.263 及之前版本存在漏洞，升级到 v0.9.264 及以上版本"）。 |
+| `file` / `startLine` | 指向依赖声明所在的文件和行，一般就是 `go.mod`、`pom.xml`、`build.gradle` 等。 |
+
+**提取步骤**：
+1. 读取漏洞条目，取 `importPath` 作为待升级组件标识。
+2. 从 `description`、`suggestion`、`message` 中解析出安全版本号（关键词：安全版本 / 修复版本 / fixed in / upgrade to / >=）。若文本里同时出现"受影响版本上限"和"建议版本"，以**建议/安全版本**为准。
+3. 定位 `file` 指向的依赖清单文件中对应 `importPath` 的那一行。
+
+## 修复模式
+
+### Go (`go.mod`)
+
+#### 情况 1：漏洞组件是直接依赖，`go.mod` 里有对应行
+
+**修复前**：
+```go
+require (
+    github.com/baidubce/bce-sdk-go v0.9.263
+    github.com/gin-gonic/gin v1.9.1
+)
+```
+
+**修复后**（升级到安全版本 `v0.9.264` 或更高）：
+```go
+require (
+    github.com/baidubce/bce-sdk-go v0.9.266
+    github.com/gin-gonic/gin v1.9.1
+)
+```
+
+要点：
+- 只替换匹配 `importPath` 的那一行，保留空行/缩进/其他依赖顺序。
+- `v` 前缀不能省略。
+- 如果该组件同时出现在 `require (...)` 块和 `// indirect` 块里，两处都要改成同一版本。
+- `go.sum` 会在构建 / `go mod tidy` 时自动刷新，**本次修复不需要手动修改 `go.sum`**。
+
+#### 情况 2：漏洞组件是间接依赖，`go.mod` 里没有对应行
+
+出现条件：
+- 漏洞组件 C 没被你的源码直接 `import`；
+- `go.mod` 里也没有 `C ... // indirect`（因为上游直接依赖 B 的 `go.mod` 递归就能推导出 C 的当前版本，Go 不会重复写）；
+- 又不能/不想升级 B（B 尚未发布含安全 C 的新版，或升 B 会引入破坏性变更）。
+
+此时通过**新增一条 `// indirect`** 把 C 钉到安全版本。推荐用命令，不手改：
+
+```bash
+go get github.com/xxx/C@v1.3.0   # v1.3.0 为安全版本
+go mod tidy                       # 自动补 // indirect 注释、刷新 go.sum
+```
+
+效果等同于 `go.mod` 多出：
+
+```go
+require (
+    github.com/xxx/C v1.3.0 // indirect
+)
+```
+
+原理：MVS（Minimum Version Selection）取依赖图中该模块被要求过的**最大版本**。你手动声明的 `v1.3.0` 参与这次选择，且优先级不低于上游，于是最终选中 ≥ 安全版本的 C。
+
+必须核查的前置条件：
+1. **同一个 major 版本**。`v2+` 在 Go modules 中是**不同的模块路径**（`github.com/xxx/C/v2`），不能靠 MVS 自动升上去。若安全版本跨了 major，只能换上游依赖或自己 fork。
+2. **上游没有更高下限**。如果 B 的 `go.mod` 里写的是 `require C v1.4.0`，你钉 `v1.3.0` 无效，MVS 会选 `v1.4.0`；此时要钉到 `≥ v1.4.0 且 ≥ 安全版本`。
+3. **钉版本必须与 B 依赖的 C 保持 API 兼容**（同 major 号按语义化版本应兼容）。不兼容时上层代码会编译失败，需要改 B 或放弃此方案。
+
+修复后必须验证：
+
+```bash
+go mod why github.com/xxx/C     # 确认 C 仍在依赖图里
+go list -m github.com/xxx/C     # 打印最终选中版本，必须 ≥ 安全版本
+go build ./...                   # 构建通过
+```
+
+注意事项：
+- 间接依赖钉版本是**临时方案**，会带来后续维护成本（上游 B 升级时可能冲突）。长期建议推动 B 升级或自行 fork。
+- 不要只在 `go.mod` 手写一行 `// indirect` 而不跑 `go mod tidy`，这会让 `go.sum` 缺失校验信息，CI 构建会失败。
+
+### Java (Maven `pom.xml` / Gradle `build.gradle`)
+
+Java 的 `importPath` 通常形如 `groupId:artifactId`，例如 `org.apache.logging.log4j:log4j-core`。
+
+#### 情况 1：漏洞组件是直接依赖
+
+**Maven**：
+```xml
+<dependency>
+    <groupId>org.apache.logging.log4j</groupId>
+    <artifactId>log4j-core</artifactId>
+    <version>2.17.1</version>
+</dependency>
+```
+只替换 `<version>` 标签内的版本号。如果版本号通过 `<properties>` 变量引用（`${log4j.version}`），则改 `<properties>` 里的对应条目，不要在使用处硬改。
+
+**Gradle**：
+```groovy
+implementation "org.apache.logging.log4j:log4j-core:2.17.1"
+```
+替换冒号后第三段版本号即可。若版本通过 `ext` 变量定义，则改 `ext` 源头。
+
+#### 情况 2：漏洞组件是间接依赖（由某个直接依赖 B 传递引入）
+
+与 Go 的 MVS 不同，**Maven 默认使用"最近原则"（nearest-wins）**：依赖树中路径最短的声明优先。因此单纯在 `pom.xml` 里加一条高版本 `<dependency>` 通常可以覆盖掉 B 带来的旧版，但更稳妥、更符合主流实践的做法是 **先 `<exclusions>` 排除掉 B 里的旧版，再显式引入新版本**。这样依赖图干净，不会出现同一个 jar 被两次引入导致的 warning，也能抵御"路径变化导致覆盖失效"的问题。
+
+##### Maven：排除 + 引入新版本
+
+漏洞组件：`com.fasterxml.jackson.core:jackson-databind`，由直接依赖 `B` 间接引入，安全版本 `2.15.4`。
+
+修复前（只有对 B 的声明，jackson-databind 间接引入的是旧版）：
+```xml
+<dependencies>
+    <dependency>
+        <groupId>com.example</groupId>
+        <artifactId>B</artifactId>
+        <version>1.0.0</version>
+    </dependency>
+</dependencies>
+```
+
+修复后：
+```xml
+<dependencies>
+    <dependency>
+        <groupId>com.example</groupId>
+        <artifactId>B</artifactId>
+        <version>1.0.0</version>
+        <!-- 从 B 的依赖传递里排除旧版 jackson-databind -->
+        <exclusions>
+            <exclusion>
+                <groupId>com.fasterxml.jackson.core</groupId>
+                <artifactId>jackson-databind</artifactId>
+            </exclusion>
+        </exclusions>
+    </dependency>
+
+    <!-- 显式引入安全版本 -->
+    <dependency>
+        <groupId>com.fasterxml.jackson.core</groupId>
+        <artifactId>jackson-databind</artifactId>
+        <version>2.15.4</version>
+    </dependency>
+</dependencies>
+```
+
+要点：
+- `<exclusions>` 放在**传递来源 B** 的 `<dependency>` 内部，不是放在 jackson-databind 自身那条。
+- `<exclusion>` 里**只写 `groupId` 和 `artifactId`，不写 `<version>`**（Maven 语法要求）。
+- 如果漏洞组件由多条路径同时传递进来（多个直接依赖都间接用了它），需要在**每一个**直接依赖的 `<dependency>` 里都加 `<exclusions>`，否则任何一条没排除的路径都可能拉回旧版。
+- 排除之后务必新增一条显式的 `<dependency>` 指向安全版本，否则应用会因缺少 jackson-databind 编译/运行失败。
+- 使用 `dependencyManagement` 统一管理版本的项目，可以把安全版本加到 `<dependencyManagement>` 里，然后 `<dependency>` 不写版本；但 `<exclusions>` 仍然要写在 B 的声明里。
+
+##### Gradle：排除 + 引入新版本
+
+```groovy
+dependencies {
+    implementation("com.example:B:1.0.0") {
+        exclude group: "com.fasterxml.jackson.core", module: "jackson-databind"
+    }
+    implementation "com.fasterxml.jackson.core:jackson-databind:2.15.4"
+}
+```
+
+要点：
+- `exclude` 在 B 的 `implementation(...)` 闭包里；
+- 若多个直接依赖都传递了旧版 jackson-databind，每个都要加 `exclude`；
+- Gradle 也支持用 `resolutionStrategy.force` 或 `constraints` 强制版本，但排除 + 显式引入的语义更清晰，推荐作为首选。
+
+##### 如何确认排除是否生效
+
+```bash
+# Maven
+mvn dependency:tree -Dincludes=com.fasterxml.jackson.core:jackson-databind
+
+# Gradle
+./gradlew dependencies --configuration runtimeClasspath | grep jackson-databind
+```
+
+输出中应只剩你显式声明的安全版本，且不再出现从 B 传递来的旧版行（通常行尾会打 `(*)` 或 `omitted for conflict` 标记）。
+
+注意事项：
+- 同样需要确认安全版本与 B 内部使用 jackson-databind 的代码 **API 兼容**（Jackson 大多数 2.x 版本之间兼容，但个别版本移除了类/方法）。不兼容时要权衡改 B 或 fork。
+- `<exclusions>` 是长期解决方案，比 Go 的 indirect 钉版本稳定；但同样建议推动上游 B 升级以减少维护开销。
+
+## 修复流程清单
+
+1. 从 `parsed_result.json` 的漏洞条目里拿到 `importPath`（组件名）、`file`（依赖文件）、`description` / `suggestion`（包含安全版本）。
+2. 从描述文本里解析出**安全版本**：优先匹配 "升级到 X 及以上"、"fixed in X"、"safe version X"、">= X"。
+3. Read 对应依赖文件，定位到包含 `importPath` 的那一行；找不到 → 属于间接依赖，走对应语言的"情况 2"路径。
+4. 按语言和情况执行替换/新增：
+   - Go 直接依赖：改 `go.mod` 里的版本号；
+   - Go 间接且无行：`go get pkg@安全版本 && go mod tidy`；
+   - Java 直接依赖：改 `<version>` / Gradle 版本串；
+   - Java 间接依赖：在传递来源的 `<dependency>` 里加 `<exclusions>`，并新增安全版本的 `<dependency>`。
+5. 如果该组件在同一个文件中出现多次（如 Go 的 `require` + `indirect`，Java 多个直接依赖都传递了同一个间接依赖），全部处理一致。
+6. 不要新增、删除任何其他依赖，也不要对业务源码做改动。
+7. 修复完成后继续走复测扫描流程。
+
+## 常见坑
+
+- **升错方向**：安全版本通常**大于**受影响版本上限，不要把版本降到"受影响范围以下"，因为旧补丁可能仍有别的 CVE。
+- **Go 只改了 `require` 没改 `indirect`**：如果项目直接没依赖该组件、只在 `indirect` 中出现，建议改 `indirect` 行；或通过 `go get` 让它成为新的 indirect 条目，避免被间接依赖拉回旧版本。
+- **Java 只 exclude 没引入新版本**：排除之后如果没新增安全版本的 `<dependency>`，运行时会 `ClassNotFoundException`。两步必须都做。
+- **Java 只改一条路径的 exclude**：多条传递路径时，漏掉的那条会把旧版拉回来，`mvn dependency:tree` 可以定位哪些路径需要补排除。
+- **锁文件/校验文件未刷新**：`go.sum`、`poetry.lock` 等在下次构建时会自动更新，修复脚本不要手动改这些文件。
+- **版本号写成字符串被引用**：`pom.xml` 使用 `<properties>`、`build.gradle` 使用 `ext` 定义版本时，必须改源头定义处，不要在使用处硬改版本。
+- **多个依赖文件**：monorepo 或多模块项目中，同一组件可能在多个 `go.mod` / `pom.xml` 中出现。仅修复扫描结果 `file` 指向的那一个文件即可，不要主动扩散修改。

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

@@ -12,19 +12,23 @@
 """
 
 import argparse
+from utils import make_user_id, HOST, build_headers
 import json
 import logging
 import sys
+import uuid
 
 import http_client  # noqa: F401 (triggers shared logging config)
-import utils
+
+USER_ID = ""
+USERNAME = ""
 
 logger = logging.getLogger("credential_hosting")
 
 
-def hosting_credentials(chat_id, platform, credentials, username, user_id):
+def hosting_credentials(chat_id, platform, credentials):
     """将凭证托管到指定平台。"""
-    url = "{}/api/v1/deployments/{}/credentials".format(utils.HOST, platform)
+    url = "{}/api/v1/deployments/{}/credentials".format(HOST, platform)
     payload = {
         "configs": credentials,
         "scanChatID": chat_id,
@@ -33,14 +37,11 @@ def hosting_credentials(chat_id, platform, credentials, username, user_id):
     logger.info("credential_hosting: chat_id=%s, platform=%s, credentials_count=%d",
                 chat_id, platform, len(credentials))
     print("正在托管凭证到 {} 平台...".format(platform), file=sys.stderr)
-    return http_client.post(
-        url,
-        headers=utils.build_headers(username, user_id, chat_id),
-        json_body=payload,
-    )
+    return http_client.post(url, headers=build_headers(USERNAME, USER_ID, chat_id), json_body=payload)
 
 
 def main():
+    global USER_ID, USERNAME
     parser = argparse.ArgumentParser(description="凭证托管工具")
     parser.add_argument("--poll-result", default=None, help="credential_poll.py 输出的结果文件路径，自动提取所需参数")
     parser.add_argument("--chat-id", default=None, help="scanChatID（使用 --poll-result 时可省略）")
@@ -49,7 +50,8 @@ def main():
     parser.add_argument("--credentials", default=None, help="凭证配置 JSON（使用 --poll-result 时可省略）")
     args = parser.parse_args()
 
-    user_id = utils.make_user_id(args.username)
+    USERNAME = args.username
+    USER_ID = make_user_id(args.username)
 
     chat_id = args.chat_id
     platform = args.platform
@@ -79,7 +81,7 @@ def main():
         print("错误: 缺少必要参数。使用 --poll-result 或同时提供 --chat-id、--platform、--credentials", file=sys.stderr)
         sys.exit(1)
 
-    result = hosting_credentials(chat_id, platform, credentials, args.username, user_id)
+    result = hosting_credentials(chat_id, platform, credentials)
     print(json.dumps(result, ensure_ascii=False, indent=2))
 
 

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

@@ -0,0 +1,125 @@
+#!/usr/bin/env python3
+"""
+打开硬编码风险治理界面 - 构建凭证配置网页 URL 并在 IDE 内嵌浏览器中打开。
+
+用法:
+    python3 credential_open_page.py --chat-id <chatID> --username <用户名> \
+        [--ide-name <ideType>] [--repo <repo>] [--project-dir <目录>]
+
+输出:
+    1. 可点击的 Markdown 链接（供用户手动打开）
+    2. 通过 comate-kernel socket 在 IDE 内嵌浏览器中自动打开网页
+"""
+
+import argparse
+import glob
+import json
+import os
+import socket
+import subprocess
+import sys
+
+# 导入公共 URL 构建模块
+sys.path.insert(0, os.path.dirname(__file__))
+from credential_url import build_url_from_args, build_markdown_link
+
+
+def open_in_ide(url: str) -> bool:
+    """通过 comate-kernel Unix Socket HTTP API 在 IDE 内嵌浏览器中打开网页。
+
+    传入 reuseExisting=True，若相同 URL 已在内嵌浏览器中打开则复用现有页签，不新建。
+    """
+    body = json.dumps({
+        "action": "executeVirtualEditor",
+        "method": "openUrlInEditorWebview",
+        "payload": {"url": url, "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
+    )
+
+    tmpdir = os.environ.get("TMPDIR", "/tmp").rstrip("/")
+    ppid_sock = f"{tmpdir}/comate-kernel-{os.getppid()}.sock"
+    others = sorted(
+        set(
+            glob.glob(f"{tmpdir}/comate-kernel-*.sock")
+            + glob.glob("/tmp/comate-kernel-*.sock")
+        ),
+        key=os.path.getmtime,
+        reverse=True,
+    )
+    socks = ([ppid_sock] if os.path.exists(ppid_sock) else []) + [
+        s for s in others if s != ppid_sock
+    ]
+
+    for sock_path in socks:
+        try:
+            s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+            s.settimeout(2)
+            s.connect(sock_path)
+            s.send(req.encode())
+            resp = b""
+            while True:
+                chunk = s.recv(4096)
+                if not chunk:
+                    break
+                resp += chunk
+            s.close()
+            if b"ok" in resp:
+                return True
+        except Exception:
+            pass
+
+    return False
+
+
+def open_via_cli(url: str) -> bool:
+    """降级方案：通过 IDE CLI --open-url 触发 SimpleBrowser。"""
+    import urllib.parse
+    enc = urllib.parse.quote(json.dumps([url]))
+    for cli in ["comate", "code"]:
+        try:
+            subprocess.run(
+                [cli, "--open-url", f"command:simpleBrowser.api.open?{enc}"],
+                timeout=3,
+                capture_output=True,
+            )
+            return True
+        except Exception:
+            pass
+    return False
+
+
+def main():
+    """入口函数：解析参数、构建 URL、输出链接并尝试在 IDE 内嵌浏览器中打开。"""
+    parser = argparse.ArgumentParser(description="打开硬编码风险治理界面")
+    parser.add_argument("--chat-id", required=True, help="会话 ID (_CHAT_ID)")
+    parser.add_argument("--username", required=True, help="用户名 (_USERNAME)")
+    parser.add_argument("--ide-name", default=os.environ.get("COMATE_IDE_NAME", "comate"), help="IDE 类型")
+    parser.add_argument("--repo", default="", help="仓库标识，留空则自动从 git remote 获取")
+    parser.add_argument("--project-dir", default=".", help="项目目录，用于自动获取 repo")
+    args = parser.parse_args()
+
+    url = build_url_from_args(args.chat_id, args.username, args.ide_name,
+                               args.project_dir, args.repo)
+
+    # 输出可点击链接（在 IDE 内嵌浏览器中打开）
+    print("请点击以下链接打开硬编码风险治理网页，配置凭证信息：")
+    print()
+    print(build_markdown_link(url))
+    print()
+    print("配置完成后请在网页中点击「生成代码」按钮，我会自动检测到配置完成并继续执行修复。")
+    print()
+
+    # 自动在 IDE 内嵌浏览器中打开
+    if not open_in_ide(url):
+        open_via_cli(url)
+
+
+if __name__ == "__main__":
+    main()

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

@@ -14,7 +14,7 @@
 """
 
 import argparse
-import base64
+from utils import make_user_id, WS_HOST
 import json
 import logging
 import os
@@ -23,15 +23,16 @@ import struct
 import sys
 import time
 
+# 触发共享日志配置
+import http_client  # noqa: F401
+
 try:
     import ssl
     _SSL_AVAILABLE = True
 except ImportError:
     _SSL_AVAILABLE = False
 
-# 触发共享日志配置
-import http_client  # noqa: F401
-import utils
+USER_ID = ""
 
 logger = logging.getLogger("credential_poll")
 
@@ -49,6 +50,7 @@ OP_PONG = 0xA
 
 def _generate_ws_key():
     """生成随机的 Sec-WebSocket-Key。"""
+    import base64
     return base64.b64encode(os.urandom(16)).decode("ascii")
 
 
@@ -221,15 +223,15 @@ def _parse_ws_url(url):
     return host, port, path, use_ssl
 
 
-def poll_credential_config(chat_id, user_id):
+def poll_credential_config(chat_id):
     """通过 WebSocket 监听凭证配置，返回配置数据 dict 或 None。"""
-    url = "{}/api/v1/ws/credential/events".format(utils.WS_HOST)
+    url = "{}/api/v1/ws/credential/events".format(WS_HOST)
     host, port, path, use_ssl = _parse_ws_url(url)
     logger.info("credential_poll start: chat_id=%s", chat_id)
 
     ws_headers = {
         "SAST-Chat-ID": chat_id,
-        "Comate-User-Id": user_id,
+        "Comate-User-Id": USER_ID,
     }
 
     reconnect_attempts = 0
@@ -318,15 +320,16 @@ def poll_credential_config(chat_id, user_id):
 
 
 def main():
+    global USER_ID
     parser = argparse.ArgumentParser(description="凭证配置轮询工具")
     parser.add_argument("--chat-id", required=True, help="scanChatID，用于关联扫描会话")
     parser.add_argument("--username", required=True, help="Comate 用户名")
     parser.add_argument("--output", default=None, help="将结果保存到指定文件路径（同时仍输出到标准输出）")
     args = parser.parse_args()
 
-    user_id = utils.make_user_id(args.username)
+    USER_ID = make_user_id(args.username)
 
-    result = poll_credential_config(args.chat_id, user_id)
+    result = poll_credential_config(args.chat_id)
     if result:
         output_json = json.dumps(result, ensure_ascii=False, indent=2)
         print(output_json)

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

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+"""
+凭证配置网页 URL 构建工具（公共模块）
+
+被 credential_open_page.py 和 ducc/open_browser.py 共同使用。
+"""
+
+import hashlib
+import os
+import subprocess
+import urllib.parse
+import json
+
+from utils import HOST
+
+BASE_URL = f"{HOST}/app/credential"
+VERSION = "2.9.1"
+
+
+def compute_uid(username: str) -> str:
+    """计算用户 UID：username 的 MD5 前 12 位。"""
+    return hashlib.md5(username.encode()).hexdigest()[:12]
+
+
+def get_repo(project_dir: str) -> str:
+    """从 git remote 获取仓库三级路径标识，失败则回退到目录名。
+
+    SSH 格式（git@icode.baidu.com:baidu/scan/cnap-test.git）：取 : 后的部分，去掉 .git 后缀。
+    HTTP 格式（https://icode.baidu.com/baidu/scan/cnap-test）：取域名后的路径，去掉 .git 后缀。
+    """
+    try:
+        result = subprocess.run(
+            ["git", "remote", "get-url", "origin"],
+            cwd=project_dir,
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        remote = result.stdout.strip()
+        if remote:
+            if ":" in remote and not remote.startswith("http"):
+                # SSH 格式
+                remote = remote.split(":", 1)[1]
+            else:
+                # HTTP 格式
+                from urllib.parse import urlparse
+                remote = urlparse(remote).path.lstrip("/")
+            return remote.removesuffix(".git")
+    except Exception:
+        pass
+    return os.path.basename(os.path.abspath(project_dir))
+
+
+def build_url(chat_id: str, uid: str, ide_name: str, repo: str) -> str:
+    """构建完整的凭证配置网页 URL（参数中的特殊字符均已 URL 编码）。"""
+    params = urllib.parse.urlencode({
+        "chatID": chat_id,
+        "comateUID": uid,
+        "version": VERSION,
+        "repo": repo,
+        "ideType": ide_name,
+    })
+    return f"{BASE_URL}?{params}"
+
+
+def build_markdown_link(url: str) -> str:
+    """构建可点击的 Markdown 链接，点击后在 IDE SimpleBrowser 中打开。
+
+    对 URL 做完整特殊字符转码（safe=''），确保 &、=、/、()、# 等字符
+    不破坏 Markdown 链接语法或 command 参数解析。
+    """
+    enc = urllib.parse.quote(json.dumps([url]), safe="")
+    return f"[打开硬编码风险治理界面](command:simpleBrowser.api.open?{enc})"
+
+
+def build_url_from_args(chat_id: str, username: str, ide_name: str,
+                         project_dir: str, repo: str = "") -> str:
+    """从原始参数一步构建 URL（便捷方法）。"""
+    uid = compute_uid(username)
+    repo = repo or get_repo(project_dir)
+    return build_url(chat_id, uid, ide_name, repo)

package/comate-engine/assets/skills/code-security/scripts/ducc/get_claude_session_id.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+# 获取当前 Claude Code 会话 ID
+
+# 获取当前工作目录的绝对路径
+CURRENT_DIR=$(pwd)
+
+# 将路径中的斜杠替换为连字符，构建项目目录名
+PROJECT_DIR_NAME=$(echo "$CURRENT_DIR" | sed 's/\//-/g')
+
+# Claude projects 目录路径
+PROJECTS_DIR="$HOME/.claude/projects"
+PROJECT_PATH="$PROJECTS_DIR/$PROJECT_DIR_NAME"
+
+# 检查项目目录是否存在
+if [ ! -d "$PROJECT_PATH" ]; then
+    echo "Error: Project directory not found: $PROJECT_PATH"
+    exit 1
+fi
+
+# 找到最新的 .jsonl 文件（按修改时间排序）
+LATEST_JSONL=$(ls -t "$PROJECT_PATH"/*.jsonl 2>/dev/null | head -1)
+
+# 检查是否找到文件
+if [ -z "$LATEST_JSONL" ]; then
+    echo "Error: No session JSONL file found in $PROJECT_PATH"
+    exit 1
+fi
+
+# 从文件名中提取会话 ID（去掉路径和 .jsonl 后缀）
+SESSION_ID=$(basename "$LATEST_JSONL" .jsonl)
+
+# 输出会话 ID
+echo "$SESSION_ID"