@comate/zulu 1.4.1 → 1.4.2

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

@@ -1,23 +1,29 @@
 # 敏感信息硬编码漏洞修复流程
 
-修复漏洞分为以下三个步骤：
-1. 读取漏洞报告
-2. 修复硬编码漏洞
-3. 引入SDK（如果需要）
+修复漏洞分为以下三个步骤，**必须按序执行，每步完成后再进入下一步**：
 
-## 读取漏洞报告
+1. **读取配置数据**：解析 `poll_result.json`，提取 `deployment.platform`、`deployment.credential_id`、`files[].name`、`files[].vulList[]`（含 `line`、`extra.secret.credentialName`、`extra.secret.start/end`）；**禁止凭印象跳过读取**
+2. **修复硬编码漏洞**：按文件遍历，每个文件内按 `line` **降序**处理漏洞；同行多漏洞按 `start.col` **降序**替换；每个漏洞**独立**依据 `credentialName` 是否为空决定托管或删除方式；**仅替换 `[start.col, end.col]` 范围内字符**，行内其余内容一律不动；修复后重新读取文件逐项校验
+3. **【强制执行】引入 SDK**：显式检查 `deployment.platform` 的值——`== 4` 时按第 3 节引入 keyless-sdk（`credentialID` 必须与 `deployment.credential_id` 完全一致，已有则不重复引入）；`!= 4` 时明确跳过，**不得静默忽略此步骤**
+
+> **稳定性总原则**：
+> - **只改必要内容**：仅基于 `extra.secret.start` / `extra.secret.end` 精确定位敏感信息进行替换，禁止改动同一行其他字符（包括空格、引号、注释、分隔符）。
+> - **白名单修复**：只修复 `poll_result.json` 中明确列出的漏洞，禁止顺带"修复"其他疑似硬编码。
+> - **修复顺序**：同一文件内的多个漏洞，**按 `line` 降序处理**，避免前面的修改导致后续行号偏移；不同文件之间互不干扰。
+> - **每个漏洞独立判断**：必须依据各自的 `credentialName` 决定修复方式，禁止基于内容相似性批量推断。
+> - **修复后校验**：修复完毕重新读取文件，逐项确认（a）目标位置已替换；（b）非目标行/列未被改动；（c）文件整体语法/缩进合法。
+
+## 1. 读取漏洞修复配置数据
+
+基于凭证配置网页回传的 `poll_result.json` 数据获取漏洞修复配置，示例如下：
 
-基于凭证配置网页回传的数据获取漏洞报告，示例如下：
 ```json
 {
   "scanChatID": "从 credential_poll 返回的 chatUUID",
-  "repo": {
-    "language": "java",
-    "framework": "springboot"
-  },
   "deployment": {
     "platform": 2,
-    "platformName": "ipipe"
+    "platformName": "ipipe",
+    "credential_id": "appDemo_prod"
   },
   "files": [
     {
@@ -43,68 +49,119 @@
   "type": 4
 }
 ```
+
 各字段说明如下：
-* repo：代码库信息
-    * language：代码语言
-    * framework：代码框架
-* deployment：部署信息
-    * platform：部署平台，1 表示 cnap，2 表示 ipipe，3 表示 opera，4 表示 datamanage
-    * platformName：部署平台名称（如 ipipe、cnap、opera、datamanage）
-    * credential_id：凭证 ID（platform 为 4 时使用，用于引入 keyless-sdk）
-* files：文件信息
-    * name：漏洞文件的相对路径
-    * vulList：漏洞列表
-        * extra.secret.start：敏感信息的开始位置（行、列）
-        * extra.secret.end：敏感信息的结束位置（行、列）
-        * extra.secret.credentialName：建议使用的环境变量名称
-
-## 修复漏洞
-硬编码漏洞修复的本质就是改变原来在代码中的硬编码敏感信息写法，改为从环境变量中读取敏感信息。修复时遍历漏洞报告中的所有文件和漏洞，逐个修复，按以下流程进行处理。
-
-### 代码文件
-如果漏洞文件是代码文件，比如 java、go、php、py 等，则根据各语言的写法生成读取环境变量的代码，并替换掉原来的硬编码敏感信息，注意有以下几点要求：
-1. 与环境变量读取无关的其他代码和字符不要做任何改动
-2. 如果漏洞行是被引号包裹的纯字符串，输出时保留其结构不变，仍然可以直接执行字符串操作，但要避免空字符串的拼接
-3. 不要给出环境变量默认值
-4. 如果代码开头存在空格、tab等缩进，保留原始代码的缩进，不要清除两端的空白字符
-5. 如果是 python 语言，使用 os.environ 的方式获取环境变量，而不是 os.getenv
-6. 如果是 go 语言，不能在 const 中读取环境变量，在 const 下方重新定义读取代码，并删除 const 的硬编码的值
-7. 如果是 java 语言，且 platform 为 4 时，则采用 System.getProperty 的语法读取变量
-8. 如果原文件中缺失读取环境变量所需的第三方库，则自动引入，比如 python 的 os 库，go 的 os 库等
-
-### 配置文件
-如果漏洞文件是配置文件，比如 yml、properties、ini 等，则结合语言和框架共同决定如何修改代码，修改原则如下：
-1. 如果语言为 go，框架为 gdp，toml 后缀的文件直接使用特定的占位符替换敏感信息，占位符的环境变量名称根据 credential_name 命名，示例如下：
+
+* `deployment`：部署信息
+  * `platform`：部署平台，1 表示 cnap，2 表示 ipipe，3 表示 opera，4 表示 datamanage
+  * `platformName`：部署平台名称（如 ipipe、cnap、opera、datamanage）
+  * `credential_id`：凭证 ID（platform 为 4 时使用，用于引入 keyless-sdk）
+* `files`：文件信息
+  * `name`：漏洞文件的相对路径
+  * `vulList`：漏洞列表
+    * `line`：漏洞所在行号
+    * `extra.secret.start`：敏感信息的开始位置（行、列，列从 1 开始计数）
+    * `extra.secret.end`：敏感信息的结束位置（行、列）
+    * `extra.secret.credentialName`：建议使用的环境变量名称
+      * 不为空 → 修复方式为**托管**
+      * 为空 → 修复方式为**删除**
+
+## 2. 修复漏洞
+
+硬编码漏洞修复的本质是把代码中的硬编码敏感信息改为从环境变量读取（托管），或在不需要保留的场景下置空（删除）。
+
+### 2.1 通用修复流程
+
+1. **按文件聚合**：遍历 `files[]`，处理完一个文件再处理下一个。
+2. **按行倒序处理**：对当前文件的 `vulList[]` 按 `line` **降序**排序后再修复。
+3. **逐漏洞读取关键字段**：`line`、`extra.secret.credentialName`、`extra.secret.start`、`extra.secret.end`。
+4. **独立判断修复方式**：
+   - `credentialName` 不为空 → **托管方式**（参考 2.2 / 2.3）
+   - `credentialName` 为空 → **删除方式**（参考 2.4）
+5. **精确替换**：仅替换 `[start.col, end.col]` 范围内的字符，行内其余内容保持原样。
+6. **同行多漏洞**：若同一行存在多个漏洞，按 `start.col` **降序**依次替换，避免列偏移。
+7. **修复后校验**：重新读取文件，确认每个漏洞已按正确方式修复，且无误伤。
+
+> **重要**：即使多行内容完全相同，也必须逐行依据各自的 `credentialName` 判断修复方式；不得基于内容相似性批量推断。仅当确认所有目标行的 `credentialName` 都相同且非空时，才可使用 `replace_all`。
+
+> **白名单约束**：仅修复 `poll_result.json` 中列出的漏洞，文件中其他可疑硬编码一律不动。
+
+### 2.2 托管方式 - 代码文件
+
+如果漏洞文件是代码文件（如 java、go、php、py、js、c/c++ 等），根据语言生成读取环境变量的代码替换原硬编码值，注意：
+
+1. 与环境变量读取无关的其他代码、注释、空白字符**一律不动**。
+2. 如果漏洞行是被引号包裹的纯字符串字面量，输出时保留其结构与可执行语义，避免出现空字符串拼接（如 `"" + os.environ[...]`）。
+3. **不要给出环境变量默认值**。
+4. 保留原始代码的行首缩进（空格/Tab 数量与种类一致），不要清除两端空白字符。
+5. **Python**：使用 `os.environ['XXX']`，**不**使用 `os.getenv`。
+6. **Go**：不能在 `const` 中读取环境变量；将 `const` 中该值删除，并在 `const` 块下方用 `var` 重新定义并通过 `os.Getenv` 读取。
+7. **Java**：
+   - `platform == 4`：使用 `System.getProperty("XXX")`（与 keyless-sdk 注入方式一致）。
+   - 其他 platform：使用 `System.getenv("XXX")`。
+8. **依赖自动补齐**：若读取环境变量所需的标准库未引入，自动补全（如 Python 的 `os`、Go 的 `os`、C++ 的 `<cstdlib>` 等）。
+
+### 2.3 托管方式 - 配置文件
+
+> **修复配置文件前**：先读取 `references/framework_detection.md`，识别配置文件的宿主语言和框架，再选择对应的占位符格式。
+
+**占位符格式规则**（环境变量名取自 `credentialName`，**不写默认值**）：
+
+| 语言 / 框架 / 文件类型 | 占位符格式 | 示例 |
+|---|---|---|
+| Go + GDP 框架 + toml | `{env.XXX}` | `password={env.KL_PASSWORD}` |
+| 其他语言 / 框架 / 配置文件（yml、yaml、properties、ini、toml、xml 等） | `${XXX}` | `password=${KL_PASSWORD}` |
+
+修复示例：
+
 ```toml
-// 修复前
+# 修复前
 password=123123123
-// 修复后
-password=${env.KL_PASSWORD}
+# 修复后（Go + GDP）
+password={env.KL_PASSWORD}
 ```
-2. 除第一种情况之外，其他语言、框架、配置文件类型，使用常规的环境变量占位符替换敏感信息，占位符的环境变量名称根据 credential_name 命名。
-```toml
-// 修复前
-password=123123123
-// 修复后
-password=${KL_PASSWORD}
+
+```properties
+# 修复前
+spring.datasource.password=123123123
+# 修复后（Spring Boot 等）
+spring.datasource.password=${KL_SPRING_DATASOURCE_PASSWORD}
 ```
 
-漏洞报告可能涉及多个文件，修复时按文件进行聚合，优先将一个文件中的漏洞全部修复完成再修复其他漏洞。
+### 2.4 删除方式（credentialName 为空）
+
+按文件类型采用合适的"清空"策略，**避免破坏文件语法**：
+
+- **配置文件（properties/ini/yml/toml 等键值型）**：保留键和分隔符，仅清空值。
+  - 示例：`password=123123123` → `password=`
+  - YAML：`password: 123123123` → `password:`（或 `password: ""`，与文件原有空值风格一致）
+- **代码文件中的字符串字面量**：将值清空为对应语言的空字符串字面量，保留引号与上下文语法。
+  - 示例：`String pwd = "123";` → `String pwd = "";`
+- **代码文件中的非字符串字面量**：若直接置空会导致语法错误，则替换为该语言中合法的空值（如 Java 的 `""`、Go 的 `""`、Python 的 `""`），并附最小必要的类型保持。
+
+修复后必须确保文件可正常解析/编译。
+
+## 3. 引入 SDK（仅 platform == 4）
+
+仅当 `deployment.platform == 4` 时，才需要在项目中引入 keyless-sdk 并添加初始化代码——SDK 负责将凭证注入系统环境变量，使前面（步骤 2）的读取代码能取到值。其他 platform **不要**引入 SDK。
 
-## 引入SDK
-从第一个漏洞报告读取数据，如果 platform 为 4 时需要引入 keyless-sdk 并添加初始化代码。通过该 sdk 将凭证注入到环境变量中，然后其他位置的代码才能读取到环境变量。注意，只有平台为 4 时才需要引入 sdk，其他平台不需要。不同语言 sdk 及初始化代码添加方式如下。
+初始化代码中的 `credentialID` / `credential_id` / `CredentialID` 必须与 `deployment.credential_id` 完全一致。已有 SDK 依赖与初始化的项目，**不要重复引入**。
+
+### 3.1 Java
+
+`pom.xml` 中添加依赖（保留注释）：
 
-#### java 语言
-pom.xml 文件中添加 keyless-sdk 依赖，其中的注释需要保留。
 ```xml
 <!-- keyless-sdk dependency -->
 <dependency>
     <groupId>com.baidu.xbu-data</groupId>
     <artifactId>keyless-sdk</artifactId>
-    <version>1.0.2</version>
+    <version>1.0.3</version>
 </dependency>
 ```
-项目启动的函数中添加以下初始化代码，注意其中的 credentialID 需要与漏洞报告中的 credential_id 保持一致。
+
+在项目启动函数中添加初始化代码：
+
 ```java
 import com.baidu.keyless.KeylessClient;
 
@@ -129,14 +186,19 @@ public class KeylessAppCredentialDemo {
 }
 ```
 
-#### go 语言
-go.mod 文件中添加 keyless-sdk 依赖，其中的注释需要保留。
+### 3.2 Go
+
+`go.mod` 中添加依赖（保留注释）：
+**require模块引入包和版本保持不变**
+
 ```mod
 require (
-    icode.baidu.com/baidu/xbu-data/things-go keyless-sdk-2.2.0 // keyless-sdk dependency
+    icode.baidu.com/baidu/xbu-data/things-go v2.3.0 // keyless-sdk dependency
 )
 ```
-项目启动的函数中添加以下初始化代码，注意其中的 CredentialID 需要与漏洞报告中的 credential_id 保持一致。
+
+在项目启动函数中添加初始化代码：
+
 ```go
 package main
 
@@ -163,17 +225,21 @@ func main() {
 }
 ```
 
-#### python 语言
-requirements.txt 文件中添加 keyless-sdk 依赖，其中的注释需要保留。
+### 3.3 Python
+
+`requirements.txt` 中添加依赖（保留注释）：
+
 ```txt
 // keyless-sdk dependency
-credential-vault-sdk>=0.1.12（Python3 版本添加此依赖）
-credential-vault-sdk-py2>=0.1.9（Python2 版本添加此依赖）
+credential-vault-sdk>=0.1.15（Python3 版本添加此依赖）
+credential-vault-sdk-py2>=0.1.12（Python2 版本添加此依赖）
 ```
-初始化代码如下，注意
-* 其中的 credential_id 需要与漏洞报告中的 credential_id 保持一致；
-* 如果是完整的服务或项目，初始化代码要添加在项目启动的函数中；
-* 如果是独立的 Python 脚本文件，每个独立的文件都要添加 keyless-sdk 依赖和初始化代码。
+
+初始化代码：
+- `credential_id` 必须与 `deployment.credential_id` 一致；
+- 完整服务/项目：初始化代码加在项目启动函数中；
+- 独立 Python 脚本：每个独立脚本都需添加依赖与初始化代码。
+
 ```python
 from credential_vault_sdk.keyless_client import KeylessClient
 
@@ -188,8 +254,10 @@ def main():
     ... ...
 ```
 
-#### C++ 语言
-在文件开始引入头文件和命名空间，其中的注释需要保留：
+### 3.4 C++
+
+在文件开始引入头文件和命名空间（保留注释）：
+
 ```C++
 // keyless-sdk dependency
 #include "keyless/keyless_client.h"
@@ -197,7 +265,8 @@ def main():
 using namespace baidu::credentialvault::cppsdk;
 ```
 
-项目启动的函数中添加以下初始化代码，注意其中的 credentialID 需要与漏洞报告中的 credential_id 保持一致。
+在项目启动函数中添加初始化代码：
+
 ```C++
 #include "keyless/keyless_client.h"
 
@@ -216,4 +285,4 @@ int main(int argc, char *argv[]) {
     // 以下为其他原始代码
     ... ...
 }
-```
+```

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

@@ -12,7 +12,7 @@
 """
 
 import argparse
-from utils import make_user_id, HOST, build_headers
+from utils import make_user_id, build_url, build_headers
 import json
 import logging
 import sys
@@ -28,7 +28,7 @@ logger = logging.getLogger("credential_hosting")
 
 def hosting_credentials(chat_id, platform, credentials):
     """将凭证托管到指定平台。"""
-    url = "{}/api/v1/deployments/{}/credentials".format(HOST, platform)
+    url = build_url("/api/v1/deployments/{}/credentials".format(platform))
     payload = {
         "configs": credentials,
         "scanChatID": chat_id,
@@ -81,7 +81,16 @@ def main():
         print("错误: 缺少必要参数。使用 --poll-result 或同时提供 --chat-id、--platform、--credentials", file=sys.stderr)
         sys.exit(1)
 
-    result = hosting_credentials(chat_id, platform, credentials)
+    if platform == "datamanage" and isinstance(credentials, dict):
+        inner = credentials.get("credentials", [])
+        if isinstance(inner, list):
+            credentials["credentials"] = [
+                {("key" if k == "name" else k): v for k, v in item.items()}
+                for item in inner
+            ]
+        result = hosting_credentials(chat_id, platform, [credentials])
+    else:
+        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

@@ -18,6 +18,7 @@ import os
 import socket
 import subprocess
 import sys
+import tempfile
 
 # 导入公共 URL 构建模块
 sys.path.insert(0, os.path.dirname(__file__))
@@ -43,12 +44,11 @@ def open_in_ide(url: str) -> bool:
         + body
     )
 
-    tmpdir = os.environ.get("TMPDIR", "/tmp").rstrip("/")
+    tmpdir = tempfile.gettempdir()
     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,
@@ -113,7 +113,7 @@ def main():
     print()
     print(build_markdown_link(url))
     print()
-    print("配置完成后请在网页中点击「生成代码」按钮，我会自动检测到配置完成并继续执行修复。")
+    print("配置完成后请在网页中点击「修复代码」按钮，我会自动检测到配置完成并继续执行修复。")
     print()
 
     # 自动在 IDE 内嵌浏览器中打开

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

@@ -7,7 +7,7 @@
 
 流程:
     1. 连接 WebSocket 端点
-    2. 等待用户在网页完成凭证配置并点击「生成代码」
+    2. 等待用户在网页完成凭证配置并点击「修复代码」
     3. 收到 msgType=repair 消息后输出配置数据
 
 注意: 使用 Python 标准库实现 WebSocket 客户端，无需第三方依赖。

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

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+"""
+Dodo 环境专用：构建并输出硬编码风险治理网页 URL（标准 Markdown 超链接）。
+
+用法:
+    python3 scripts/credential_print_url.py \
+        --chat-id <chatID> --username <用户名> --ide <ideType> --project-dir <目录>
+
+输出:
+    输出可点击的 Markdown 超链接，用户点击后在本地浏览器打开（不使用 simpleBrowser）。
+"""
+
+import argparse
+import os
+import sys
+
+# 使用绝对路径确保无论从哪个目录调用都能正确 import
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from credential_url import build_url_from_args_raw
+
+
+def main():
+    """入口函数, 输出硬编码风险治理网页 Markdown 链接, 用于 Dodo 环境"""
+    parser = argparse.ArgumentParser(description="输出硬编码风险治理网页 Markdown 链接（Dodo 环境）")
+    parser.add_argument("--chat-id", required=True, help="会话 ID (_CHAT_ID)")
+    parser.add_argument("--username", required=True, help="用户名 (_USERNAME)")
+    parser.add_argument("--ide", required=True, help="IDE 类型 (_IDE)")
+    parser.add_argument("--project-dir", required=True, help="项目目录绝对路径")
+    parser.add_argument("--repo", default="", help="仓库标识，留空则自动从 git remote 获取")
+    args = parser.parse_args()
+
+    url = build_url_from_args_raw(args.chat_id, args.username, args.ide,
+                                   args.project_dir, args.repo)
+
+    print("请点击以下链接打开硬编码风险治理网页，配置凭证信息：")
+    print()
+    print(f"[打开硬编码风险治理界面]({url})")
+    print()
+    print("配置完成后请在网页中点击「修复代码」按钮，我会自动检测到配置完成并继续执行修复。")
+
+
+if __name__ == "__main__":
+    main()

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

@@ -11,9 +11,9 @@ import subprocess
 import urllib.parse
 import json
 
-from utils import HOST
+from utils import build_url
 
-BASE_URL = f"{HOST}/app/credential"
+BASE_URL = build_url("/app/credential")
 VERSION = "2.9.1"
 
 
@@ -63,6 +63,18 @@ def build_url(chat_id: str, uid: str, ide_name: str, repo: str) -> str:
     return f"{BASE_URL}?{params}"
 
 
+def build_url_raw(chat_id: str, uid: str, ide_name: str, repo: str) -> str:
+    """构建完整的凭证配置网页 URL（不对参数进行 URL 编码，适用于 Dodo 环境）。"""
+    params = "&".join([
+        f"chatID={chat_id}",
+        f"comateUID={uid}",
+        f"version={VERSION}",
+        f"repo={repo}",
+        f"ideType={ide_name}",
+    ])
+    return f"{BASE_URL}?{params}"
+
+
 def build_markdown_link(url: str) -> str:
     """构建可点击的 Markdown 链接，点击后在 IDE SimpleBrowser 中打开。
 
@@ -79,3 +91,11 @@ def build_url_from_args(chat_id: str, username: str, ide_name: str,
     uid = compute_uid(username)
     repo = repo or get_repo(project_dir)
     return build_url(chat_id, uid, ide_name, repo)
+
+
+def build_url_from_args_raw(chat_id: str, username: str, ide_name: str,
+                             project_dir: str, repo: str = "") -> str:
+    """从原始参数一步构建不转码的 URL（Dodo 环境便捷方法）。"""
+    uid = compute_uid(username)
+    repo = repo or get_repo(project_dir)
+    return build_url_raw(chat_id, uid, ide_name, repo)

package/comate-engine/assets/skills/code-security/scripts/dodo/dodo_session.sh

@@ -0,0 +1,183 @@
+#!/bin/bash
+
+# Session Info Fetcher Script
+# 功能：检测环境并获取当前会话信息
+
+set -e
+
+# 颜色定义
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# 日志函数（全部输出到 stderr，避免污染 stdout 的 JSON 输出）
+log_info() {
+    echo -e "${GREEN}[INFO]${NC} $1" >&2
+}
+
+log_warn() {
+    echo -e "${YELLOW}[WARN]${NC} $1" >&2
+}
+
+log_error() {
+    echo -e "${RED}[ERROR]${NC} $1" >&2
+}
+
+# 检查环境变量是否存在
+if [ -z "$ANTHROPIC_CUSTOM_HEADERS" ]; then
+    log_warn "环境变量 ANTHROPIC_CUSTOM_HEADERS 未设置或为空"
+    echo "{}"
+    exit 0
+fi
+
+log_info "检测到 ANTHROPIC_CUSTOM_HEADERS 环境变量"
+
+# 提取 source 字段
+# 实际格式：HTTP Header 列表，如 "comate_custom_header: {\"source\": \"dodo\", ...}, other_header: val"
+# comate_custom_header 的值为转义 JSON（\" 表示引号），需先提取再去转义后解析
+SOURCE=$(python3 -c "
+import os, re, json, sys
+
+val = os.environ.get('ANTHROPIC_CUSTOM_HEADERS', '')
+
+# 尝试方式1：从 comate_custom_header 提取转义 JSON
+m = re.search(r'comate_custom_header:\s*(\{.+?\})(?:,[a-z_]+:|$)', val)
+if m:
+    raw = m.group(1).replace('\\\\\"', '\"')
+    try:
+        data = json.loads(raw)
+        print(data.get('source', ''))
+        sys.exit(0)
+    except Exception:
+        pass
+
+# 尝试方式2：直接当 JSON 解析（兼容旧格式）
+try:
+    data = json.loads(val)
+    print(data.get('source', ''))
+    sys.exit(0)
+except Exception:
+    pass
+
+# 尝试方式3：正则直接匹配 source 字段（支持转义和非转义引号）
+m = re.search(r'[\\\\]?\"source[\\\\]?\"\\s*:\\s*[\\\\]?\"([^\"\\\\]+)', val)
+if m:
+    print(m.group(1))
+    sys.exit(0)
+
+print('')
+" 2>/dev/null)
+
+if [ -z "$SOURCE" ]; then
+    log_warn "无法从 ANTHROPIC_CUSTOM_HEADERS 中提取 source 字段"
+    echo "{}"
+    exit 0
+fi
+
+log_info "提取到 source 值：$SOURCE"
+
+# 判断是否为 dodo 环境
+if [ "$SOURCE" != "dodo" ]; then
+    log_warn "当前环境为：$SOURCE (非 dodo 环境)"
+    # 非 dodo 环境仅记录日志，返回空对象
+    echo "{}"
+    exit 0
+fi
+
+log_info "当前环境为 dodo，开始获取会话信息..."
+
+# 从 ANTHROPIC_CUSTOM_HEADERS 提取聊天用户名（username 字段），取不到则降级用 whoami
+CURRENT_USERNAME=$(python3 -c "
+import os, re, json, sys
+
+val = os.environ.get('ANTHROPIC_CUSTOM_HEADERS', '')
+
+# 尝试方式1：从 comate_custom_header 提取转义 JSON，取 username 字段
+m = re.search(r'comate_custom_header:\s*(\{.+?\})(?:,[a-z_]+:|$)', val)
+if m:
+    raw = m.group(1).replace('\\\\\"', '\"')
+    try:
+        data = json.loads(raw)
+        username = data.get('username', '')
+        if username:
+            print(username)
+            sys.exit(0)
+    except Exception:
+        pass
+
+# 尝试方式2：直接当 JSON 解析（兼容旧格式）
+try:
+    data = json.loads(val)
+    username = data.get('username', '')
+    if username:
+        print(username)
+        sys.exit(0)
+except Exception:
+    pass
+
+# 尝试方式3：正则直接匹配 username 字段
+m = re.search(r'[\\\\]?\"username[\\\\]?\"\\s*:\\s*[\\\\]?\"([^\"\\\\]+)', val)
+if m:
+    print(m.group(1))
+    sys.exit(0)
+
+print('')
+" 2>/dev/null)
+
+# 降级：取不到聊天用户名则使用系统用户
+if [ -z "$CURRENT_USERNAME" ]; then
+    log_warn "无法从 ANTHROPIC_CUSTOM_HEADERS 提取 username，降级使用 whoami"
+    CURRENT_USERNAME=$(whoami 2>/dev/null || echo "unknown")
+fi
+
+# 获取当前会话 ID (从环境变量或生成)
+CURRENT_SESSION_ID="${SESSION_ID:-$(date +%s)}"
+
+# 获取当前任务 ID (从环境变量或生成)
+CURRENT_TASK_ID="${TASK_ID:-$(date +%s%N)}"
+
+# 预先生成 chat_id（随机 UUID，供调用方直接提取，避免多次调用 uuid4 产生不一致）
+CURRENT_CHAT_ID=$(python3 -c "import uuid; print(str(uuid.uuid4()))")
+
+# 使用 export 导出环境变量
+export CURRENT_ENV="dodo"
+export CURRENT_SOURCE="$SOURCE"
+export CURRENT_USERNAME="$CURRENT_USERNAME"
+export CURRENT_SESSION_ID="$CURRENT_SESSION_ID"
+export CURRENT_TASK_ID="$CURRENT_TASK_ID"
+export CURRENT_CHAT_ID="$CURRENT_CHAT_ID"
+export CURRENT_TIMESTAMP="$(date -Iseconds)"
+
+log_info "已导出以下环境变量:"
+log_info "  - CURRENT_ENV=$CURRENT_ENV"
+log_info "  - CURRENT_SOURCE=$CURRENT_SOURCE"
+log_info "  - CURRENT_USERNAME=$CURRENT_USERNAME"
+log_info "  - CURRENT_SESSION_ID=$CURRENT_SESSION_ID"
+log_info "  - CURRENT_TASK_ID=$CURRENT_TASK_ID"
+log_info "  - CURRENT_CHAT_ID=$CURRENT_CHAT_ID"
+log_info "  - CURRENT_TIMESTAMP=$CURRENT_TIMESTAMP"
+
+# 输出 JSON 格式结果
+cat <<EOF
+{
+  "environment": "$CURRENT_ENV",
+  "source": "$CURRENT_SOURCE",
+  "username": "$CURRENT_USERNAME",
+  "session_id": "$CURRENT_SESSION_ID",
+  "task_id": "$CURRENT_TASK_ID",
+  "chat_id": "$CURRENT_CHAT_ID",
+  "timestamp": "$CURRENT_TIMESTAMP",
+  "exported_vars": {
+    "CURRENT_ENV": "$CURRENT_ENV",
+    "CURRENT_SOURCE": "$CURRENT_SOURCE",
+    "CURRENT_USERNAME": "$CURRENT_USERNAME",
+    "CURRENT_SESSION_ID": "$CURRENT_SESSION_ID",
+    "CURRENT_TASK_ID": "$CURRENT_TASK_ID",
+    "CURRENT_CHAT_ID": "$CURRENT_CHAT_ID",
+    "CURRENT_TIMESTAMP": "$CURRENT_TIMESTAMP"
+  }
+}
+EOF
+
+log_info "dodo会话信息获取成功，环境变量已导出"

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

@@ -1,11 +1,15 @@
 #!/bin/bash
 # 获取当前 Claude Code 会话 ID
 
-# 获取当前工作目录的绝对路径
-CURRENT_DIR=$(pwd)
+# 优先使用 git 根目录来确定项目路径
+if git rev-parse --show-toplevel &>/dev/null; then
+    CURRENT_DIR=$(git rev-parse --show-toplevel)
+else
+    CURRENT_DIR=$(pwd)
+fi
 
-# 将路径中的斜杠替换为连字符，构建项目目录名
-PROJECT_DIR_NAME=$(echo "$CURRENT_DIR" | sed 's/\//-/g')
+# 将路径中的斜杠和下划线替换为连字符，构建项目目录名
+PROJECT_DIR_NAME=$(echo "$CURRENT_DIR" | sed 's/[\/_]/-/g')
 
 # Claude projects 目录路径
 PROJECTS_DIR="$HOME/.claude/projects"