sycommon-python-lib 0.2.7a55__tar.gz → 0.2.8a0__tar.gz

{sycommon_python_lib-0.2.7a55 → sycommon_python_lib-0.2.8a0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.7a55
+Version: 0.2.8a0
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -9,11 +9,11 @@ Requires-Dist: aiohttp==3.14.3
 Requires-Dist: aiomysql==0.3.2
 Requires-Dist: anyio==4.14.2
 Requires-Dist: decorator==5.3.1
-Requires-Dist: deepagents==0.7.1
-Requires-Dist: elasticsearch==9.4.1
+Requires-Dist: deepagents==0.7.4
+Requires-Dist: elasticsearch==9.5.0
 Requires-Dist: fastapi==0.141.1
 Requires-Dist: jinja2==3.1.6
-Requires-Dist: kafka-python==3.0.9
+Requires-Dist: kafka-python==3.0.10
 Requires-Dist: langchain==1.3.14
 Requires-Dist: langchain-core==1.5.3
 Requires-Dist: langchain-openai==1.4.1

{sycommon_python_lib-0.2.7a55 → sycommon_python_lib-0.2.8a0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.2.7a55"
+version = "0.2.8a0"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -10,11 +10,11 @@ dependencies = [
     "aiomysql==0.3.2",
     "anyio==4.14.2",
     "decorator==5.3.1",
-    "deepagents==0.7.1",
-    "elasticsearch==9.4.1",
+    "deepagents==0.7.4",
+    "elasticsearch==9.5.0",
     "fastapi==0.141.1",
     "jinja2==3.1.6",
-    "kafka-python==3.0.9",
+    "kafka-python==3.0.10",
     "langchain==1.3.14",
     "langchain-core==1.5.3",
     "langchain-openai==1.4.1",

{sycommon_python_lib-0.2.7a55 → sycommon_python_lib-0.2.8a0}/src/sycommon/agent/sandbox/file_ops.py

@@ -389,13 +389,15 @@ class FileOperationsMixin:
             )
             # 对齐 deepagents 0.7.1 ReadResult 分页字段：服务端按行切片后回传
             # start_line/end_line/total_lines/next_offset，框架据此渲染分页提示。
-            # no_lines_requested（limit<=0 早退）：服务端返回空 content 且无分页字段。
+            # no_lines_requested（limit<=0 早退）：服务端返回空 content + 该标志；
+            # 透传给 ReadResult，让 FilesystemMiddleware 区分「零行窗口」与「空文件」。
             return ReadResult(
                 file_data=file_data,
                 start_line=result.get("start_line"),
                 end_line=result.get("end_line"),
                 total_lines=result.get("total_lines"),
                 next_offset=result.get("next_offset"),
+                no_lines_requested=bool(result.get("no_lines_requested")),
             )
         except Exception as e:
             SYLogger.error(f"[Sandbox] 读取文件异常: {e}")
@@ -471,12 +473,14 @@ class FileOperationsMixin:
                 encoding=encoding,
             )
             # 对齐 deepagents 0.7.1 ReadResult 分页字段（与同步 read 一致）。
+            # no_lines_requested 透传：区分零行窗口与空文件（见同步版注释）。
             return ReadResult(
                 file_data=file_data,
                 start_line=result.get("start_line"),
                 end_line=result.get("end_line"),
                 total_lines=result.get("total_lines"),
                 next_offset=result.get("next_offset"),
+                no_lines_requested=bool(result.get("no_lines_requested")),
             )
         except Exception as e:
             SYLogger.error(f"[Sandbox] 异步读取文件异常: {e}")

{sycommon_python_lib-0.2.7a55 → sycommon_python_lib-0.2.8a0}/src/sycommon/agent/sandbox/http_sandbox_backend.py

@@ -60,8 +60,8 @@ class FileDownloadResult:
 from sycommon.logging.kafka_log import SYLogger
 from sycommon.agent.sandbox.file_ops import FileOperationsMixin, SANDBOX_API_PREFIX
 
+from deepagents.backends.sandbox import BaseSandbox
 from deepagents.backends.protocol import (
-    SandboxBackendProtocol,
     ExecuteResponse,
     FileDownloadResponse,
     FileUploadResponse,
@@ -219,10 +219,24 @@ def filter_instances_by_owner(instances: list, user_id: str, timeout: float = 3.
     return filtered
 
 
-class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
+class HTTPSandboxBackend(FileOperationsMixin, BaseSandbox):
     """
     通过 HTTP API 连接远程沙箱容器
 
+    继承 BaseSandbox（而非 SandboxBackendProtocol）以解锁 deepagents
+    capture-at-source offload：execute 大输出在沙箱源端截成 head/tail 预览，
+    完整结果落盘 /large_tool_results/<tool_call_id>，模型可经 read_file 翻页恢复，
+    不必重跑命令。落盘目录由 SandboxRecoveryManager/minio_sync cleanup 兜底清理。
+    FileOperationsMixin 在 MRO 最前，read/ls/grep/edit/delete 等仍走本类自定义
+    实现（HTTP 远程调用），BaseSandbox 的 shell 默认实现不会被触发。
+    """
+
+    # capture-at-source offload：opt-in，依赖沙箱镜像含 POSIX sh + head/tail/wc/cat。
+    # 生产 Linux 沙箱走 bash heredoc 执行命令（见 _build_execute_command），必然满足。
+    enable_capture_offload = True
+
+    """
+
     支持两种模式:
     1. 直接 URL: 直接指定沙箱服务地址
     2. Nacos 服务发现: 通过服务名从 Nacos 获取实例（支持自动故障转移）

{sycommon_python_lib-0.2.7a55 → sycommon_python_lib-0.2.8a0}/src/sycommon/auth/wecom_ldap_service.py

@@ -26,6 +26,7 @@ from pydantic import BaseModel
 
 from sycommon.config.Config import SingletonMeta
 from sycommon.logging.kafka_log import SYLogger
+from sycommon.tools.user_id import normalize_user_id
 
 
 # ─── 模型定义 ───
@@ -70,6 +71,16 @@ class LDAPFullUser(BaseModel):
     ou_chain: List[str] = []  # OU 层级路径
 
 
+# match_method -> 可信度（越大越可信）。用于域账号冲突时择优保留正确映射。
+# 中文名唯一命中(by_cn len==1)最可信；英文名前缀(by_sam_prefix)最易误命中。
+_MATCH_TRUST: dict = {
+    "chinese_name": 30,
+    "english_name_surname": 20,
+    "english_name_position": 15,
+    "english_name": 10,
+}
+
+
 class WeComLDAPUser(BaseModel):
     """企微-LDAP 关联用户（最终返回结果）"""
 
@@ -92,7 +103,7 @@ class _LDAPIndex:
 
     def __init__(self):
         # cn(中文名) -> LDAPFullUser
-        self.by_cn: Dict[str, LDAPFullUser] = {}
+        self.by_cn: Dict[str, List[LDAPFullUser]] = defaultdict(list)
         # sAMAccountName 前缀(小写) -> [LDAPFullUser]
         self.by_sam_prefix: Dict[str, List[LDAPFullUser]] = defaultdict(list)
         # "en_prefix.sn_pinyin" -> [LDAPFullUser]
@@ -130,8 +141,9 @@ class _LDAPIndex:
                 dn=dn or None,
                 ou_chain=ou_chain,
             )
-            # 中文名 key 小写化
-            self.by_cn[cn.lower()] = ldap_user
+            # 中文名 key 小写化；同名（如两个"张伟"、内地+香港重复账号）保留多候选，
+            # 由 lookup 做唯一性校验，避免后写覆盖前写导致同名两人 resolve 到同一域账号串会话。
+            self.by_cn[cn.lower()].append(ldap_user)
 
             # sAMAccountName 如 "sussie.xia" -> 前缀 "sussie"（小写）
             prefix = sam.split(".")[0].lower()
@@ -164,9 +176,13 @@ class _LDAPIndex:
         Returns:
             (LDAPFullUser | None, match_method | None)
         """
-        # 第一优先级：中文名直接匹配（小写化比较）
-        if chinese_name.lower() in self.by_cn:
-            return self.by_cn[chinese_name.lower()], "chinese_name"
+        # 第一优先级：中文名直接匹配（小写化比较）。
+        # 🔑 唯一性校验：LDAP 里同名（cn 相同）多人时返回 None，绝不让"后写覆盖前写"
+        # 把同名两人 resolve 到同一个域账号——那会导致企微 agent/沙箱/checkpoint 全维度串。
+        # 多候选时不命中，由调用方回退到各自原始 wecom_userid（独立、不串）。
+        cn_candidates = self.by_cn.get(chinese_name.lower(), [])
+        if len(cn_candidates) == 1:
+            return cn_candidates[0], "chinese_name"
 
         en_first = english_name.lower().split()[0] if english_name else ""
 
@@ -660,12 +676,74 @@ class WeComLDAPService(metaclass=SingletonMeta):
             result.employee_id = result.wecom_userid
             results.append(result)
 
+        # 3. 🔑 全量域账号唯一性校验（根治串会话）：
+        #   单看每个用户的匹配都没错，但多个企微用户可能因中文名/英文名交叉匹配撞到
+        #   同一 LDAP 域账号（实测 Derrick.zhang 被「张仲都」中文名匹配 +「Derrick Du」
+        #   英文名匹配同时占用）。扫一遍匹配结果，若同一域账号被 ≥2 个企微用户占用，
+        #   把这些人的 matched 全部降级为 False（回退各自工号，独立、不串）。
+        self._dedup_ldap_conflicts(results)
+
         matched = sum(1 for r in results if r.matched)
         logging.info(
-            f"[WeComLDAP] 全量匹配完成: {matched}/{len(results)} 已关联"
-        )
+            f"[WeComLDAP] 全量匹配完成: {matched}/{len(results)} 已关联")
         return results
 
+    @staticmethod
+    def _dedup_ldap_conflicts(results: List["WeComLDAPUser"]) -> None:
+        """就地消解「同一域账号被多个企微用户占用」的匹配，保证域账号唯一占用。
+
+        策略：按匹配可信度择优保留，只降级不可信者（而非全部降级）——这样既治串
+        （误命中者不再占用别人的域账号），又不误伤正确映射（保企微/Web 沙箱一致）。
+
+        可信度排序（match_method 决定）：
+          chinese_name(中文名唯一命中) > english_name_surname(英文名+姓拼音)
+          > english_name_position > english_name(英文名前缀,最易误命中)
+        冲突组内：保留可信度最高者；若最高者并列(如两人都是中文名，不可能——中文名
+        同名已被 by_cn 唯一性校验挡掉)或最高也是低可信(都是 english_name)，则全部降级。
+
+        为什么不全降级：企微与 Web 共用域账号体系，同一人企微/Web userid 必须一致
+        （沙箱目录、文件互通）。中文名唯一匹配者几乎确定是真主，降级他会破坏跨端一致性。
+        """
+        from collections import defaultdict
+        # match_method -> 可信度，复用模块级 _MATCH_TRUST（与 resolve_unified_user_id
+        # 单点校验用同一份，避免两条择优路径阈值漂移导致「实时降级、全量保留」抖动）
+        TRUST = _MATCH_TRUST
+        ldap_to_users: dict = defaultdict(list)
+        for r in results:
+            if r.matched and r.ldap_user and r.ldap_user.username:
+                ldap_to_users[r.ldap_user.username.lower()].append(r)
+        for ldap_uname, group in ldap_to_users.items():
+            if len(group) <= 1:
+                continue
+            # 计算每人可信度，找最高
+            scored = [(TRUST.get(r.match_method, 0), idx, r)
+                      for idx, r in enumerate(group)]
+            max_trust = max(s[0] for s in scored)
+            # 仅当「最高可信者唯一」且「最高可信度 >= chinese_name」才保留它
+            # （中文名唯一命中几乎确定真主；英文名前缀即使唯一也不足以独占，全降级）
+            winners = [s[2] for s in scored if s[0] == max_trust]
+            if len(winners) == 1 and max_trust >= TRUST["chinese_name"]:
+                keep = winners[0]
+                downgraded = [r for r in group if r is not keep]
+                owners = ", ".join(
+                    f"{r.wecom_userid}({r.wecom_name}/{r.match_method})" for r in group)
+                SYLogger.warning(
+                    f"[WeComLDAP] 🟡域账号冲突择优: ldap={ldap_uname} [{owners}]，"
+                    f"保留可信度最高 {keep.wecom_userid}({keep.match_method})，"
+                    f"降级其余 {len(downgraded)} 人回退工号")
+            else:
+                # 最高者并列、或最高也是低可信 → 全部降级（无法判断真主）
+                downgraded = list(group)
+                owners = ", ".join(
+                    f"{r.wecom_userid}({r.wecom_name}/{r.match_method})" for r in group)
+                SYLogger.warning(
+                    f"[WeComLDAP] 🔴域账号冲突全降级: ldap={ldap_uname} [{owners}]，"
+                    f"最高可信度={max_trust}不足，全部降级回退工号（不串）")
+            for r in downgraded:
+                r.matched = False
+                r.match_method = None
+                r.ldap_user = None
+
     async def refresh_cache(self):
         """手动刷新缓存（access_token + LDAP 索引 + 部门映射）"""
         self._access_token = None
@@ -732,6 +810,21 @@ class WeComLDAPService(metaclass=SingletonMeta):
             pass
         return None
 
+    async def _get_cached_mapping_reverse(self, unified_id: str) -> Optional[str]:
+        """从 Redis 反查 unified_id(域账号) -> 占用它的 wecom_userid(工号)。
+
+        用于 resolve_unified_user_id 的域账号唯一性校验：若某域账号已被别的企微工号
+        占用，说明多人撞到同一域账号（串会话风险），需降级。
+        """
+        try:
+            rs = self._get_redis()
+            val = await rs.get(f"{self._LDAP_TO_WECOM_PREFIX}{unified_id}")
+            if val:
+                return val
+        except Exception:
+            pass
+        return None
+
     async def _set_cached_mapping(self, wecom_userid: str, unified_id: str):
         """将 wecom_userid <-> unified_id 双向映射写入 Redis，同时保存工号"""
         try:
@@ -800,13 +893,17 @@ class WeComLDAPService(metaclass=SingletonMeta):
             # 2. 查企微 + LDAP
             unified_id = wecom_userid
             employee_id = wecom_userid  # 默认用工号就是原始 userid
+            matched_ldap_username = None  # 真正匹配到的域账号（用于唯一性校验）
+            match_method = None  # 匹配方法（决定可信度）
             try:
                 result = await self.get_user_info(wecom_userid)
                 employee_id = result.wecom_userid  # get_user_info 返回解码后的明文工号
                 if result.matched and result.ldap_user and result.ldap_user.username:
-                    unified_id = result.ldap_user.username
+                    matched_ldap_username = result.ldap_user.username
+                    match_method = result.match_method
+                    unified_id = matched_ldap_username
                     SYLogger.info(
-                        f"[WeComLDAP] 用户映射: wecom={wecom_userid} -> ldap={unified_id}")
+                        f"[WeComLDAP] 用户映射: wecom={wecom_userid} -> ldap={unified_id} ({match_method})")
                 else:
                     SYLogger.info(
                         f"[WeComLDAP] 用户映射: wecom={wecom_userid} -> 未匹配LDAP，回退={unified_id}")
@@ -814,9 +911,51 @@ class WeComLDAPService(metaclass=SingletonMeta):
                 SYLogger.warning(
                     f"[WeComLDAP] 解析统一 user_id 失败: wecom_userid={wecom_userid}, error={e}")
 
-            # 3. 写入 Redis 缓存（统一小写）
-            unified_id = unified_id.lower().replace(" ", "")
-            await self._set_cached_mapping(employee_id, unified_id)
+            # 3. 🔑 域账号唯一性校验（根治串会话，按可信度择优）：
+            #   多个企微用户可能因中文名/英文名交叉匹配撞到同一域账号。这里在写入缓存前
+            #   做反向校验：查 Redis 该域账号是否已被别的企微工号占用。若被占用，按可信度
+            #   择优——中文名唯一匹配(最可信)优先保留，英文名前缀(最易误命中)让步降级。
+            #   这样既治串又不误伤正确映射（保企微/Web 沙箱一致）。
+            if matched_ldap_username:
+                normalized_ldap = normalize_user_id(matched_ldap_username)
+                owner = await self._get_cached_mapping_reverse(normalized_ldap)
+                if owner and owner != employee_id:
+                    # 该域账号已被别的企微工号占用 → 冲突，按可信度择优
+                    my_trust = _MATCH_TRUST.get(match_method, 0)
+                    if my_trust >= _MATCH_TRUST["chinese_name"]:
+                        # 我是高可信(中文名唯一命中)→ 我才是真主，保留本次映射。
+                        # 🔑 必须同时 DEL 掉低可信者(owner)残留在 Redis 的【正向】映射
+                        #   wecom_uid_map:{owner}=ldap，否则 owner 下次 resolve 会 L2 正向命中
+                        #   直接返回 ldap、跳过本段反向校验 → 错误映射存活到次日定时任务才修
+                        #   → 期间两人共享 thread_id 串会话（最长 24h）。删后 owner 下次 L2 miss
+                        #   走慢路径自查、发现自己被高可信者占用而降级。
+                        try:
+                            rs = self._get_redis()
+                            await rs.delete(f"{self._UID_MAP_PREFIX}{owner}")
+                            # L1 是进程内、无法跨进程清，但 owner 多半是别的请求/进程；
+                            # 其 L1 5min TTL 自然过期即可。
+                        except Exception:
+                            pass
+                        SYLogger.warning(
+                            f"[WeComLDAP] 🟡域账号冲突择优: ldap={normalized_ldap} "
+                            f"已被 wecom={owner} 占用，但本次 wecom={employee_id} "
+                            f"可信度更高({match_method})，保留本次映射并清除 {owner} 的正向缓存")
+                    else:
+                        # 我是低可信(英文名前缀等)→ 让步降级，回退自己的工号
+                        SYLogger.warning(
+                            f"[WeComLDAP] 🔴域账号冲突降级: ldap={normalized_ldap} "
+                            f"已被 wecom={owner} 占用，本次 wecom={employee_id} "
+                            f"可信度不足({match_method})，降级回退工号（不串）")
+                        unified_id = employee_id
+                        matched_ldap_username = None
+
+            # 4. 写入 Redis 缓存（统一小写）
+            #    降级时不写正向 wecom→ldap（避免错误映射固化），只写 wecom→工号。
+            unified_id = normalize_user_id(unified_id)
+            if matched_ldap_username:
+                await self._set_cached_mapping(employee_id, unified_id)
+            else:
+                await self._set_cached_mapping(employee_id, employee_id)
 
             # 写入 L1
             self._resolve_cache[wecom_userid] = (
@@ -834,7 +973,7 @@ class WeComLDAPService(metaclass=SingletonMeta):
         """
         try:
             rs = self._get_redis()
-            uid = unified_id.lower().replace(" ", "")
+            uid = normalize_user_id(unified_id)
             val = await rs.get(f"{self._EMPLOYEE_ID_PREFIX}{uid}")
             if val:
                 return val
@@ -855,7 +994,7 @@ class WeComLDAPService(metaclass=SingletonMeta):
             client = rs.get_client()
             async with client.pipeline(transaction=True) as pipe:
                 for wecom_userid, unified_id in mapping.items():
-                    uid = unified_id.lower().replace(" ", "")
+                    uid = normalize_user_id(unified_id)
                     # 正向
                     pipe.set(f"{self._UID_MAP_PREFIX}{wecom_userid}",
                              uid, ex=self._MAP_TTL)

{sycommon_python_lib-0.2.7a55 → sycommon_python_lib-0.2.8a0}/src/sycommon/middleware/sandbox.py

@@ -340,6 +340,10 @@ _GREP_TIMEOUT = 60
 # read 文本路径服务端字节上限（对齐 deepagents _READ_COMMAND_TEMPLATE 的
 # MAX_OUTPUT_BYTES=500KiB）：超大文本文件不会把整包塞进 HTTP 响应/内存。
 _READ_MAX_OUTPUT_BYTES = 500 * 1024
+# read 提前停止后补数 total_lines 的文件大小闸门（对齐 deepagents sandbox.py:499
+# MAX_LINE_COUNT_BYTES=1MiB）：超过此大小的文件不数总行数（total_lines=None），
+# 避免 GB 级文件的逐行计数把 read 拖成慢操作。
+_READ_TOTAL_LINE_MAX_BYTES = 1024 * 1024
 # 默认工作目录配置
 # - Linux: /data/sycommon_sandbox (固定路径，自动创建)
 # - macOS/Windows: 使用系统临时目录
@@ -443,9 +447,16 @@ cd "$SANDBOX_ROOT"
 '''
 
 def _sanitize_user_id(user_id: str) -> str:
-    """将用户名中的空格等特殊字符替换为下划线，确保路径安全。统一小写。"""
+    """将用户名归一化（lower + 去空格）并把其余特殊字符替换为下划线，确保路径安全。
+
+    用 normalize_user_id 做第一步（与主项目/企微端同一份归一化，保证同一人在
+    沙箱侧的工作目录与主项目侧的 user_id 一致 → 企微/Web 沙箱目录互通），
+    再把剩余不安全字符替换为下划线。
+    """
     import re
-    return re.sub(r'[^a-zA-Z0-9._\-]', '_', user_id.lower().replace(" ", ""))
+    from sycommon.tools.user_id import normalize_user_id
+    norm = normalize_user_id(user_id)
+    return re.sub(r'[^a-zA-Z0-9._\-]', '_', norm)
 
 
 def get_user_workspace(user_id: str) -> str:
@@ -1020,8 +1031,10 @@ def setup_sandbox_handler(app: FastAPI, config: dict = None):
 
                 # limit<=0：协议 no_lines_requested —— 不读文件，返回空内容 + 标志位，
                 # 不带任何分页字段（客户端填 ReadResult.no_lines_requested=True）。
+                # 对齐 deepagents _build_read_cmd 的 limit<=0 早退分支。区别于空文件
+                # （空文件走上面的 "File exists but has empty contents" 提示）。
                 if limit is not None and limit <= 0:
-                    return ReadResponse(content="", error=None, encoding="utf-8")
+                    return ReadResponse(content="", error=None, encoding="utf-8", no_lines_requested=True)
 
                 lines = []
                 lines_read = 0
@@ -1075,12 +1088,18 @@ def setup_sandbox_handler(app: FastAPI, config: dict = None):
                     next_offset = None
                 else:
                     # 提前停止（limit 到顶 / 字节截断）：需要 total_lines 才能算「剩余」。
-                    # 大文件全量计数代价高，这里只在截断时补一次剩余行数扫描
-                    # （对齐 deepagents「total_lines 已知时才报」的做法）。
-                    try:
-                        with open(file_path, 'r', encoding='utf-8', newline=None) as f:
-                            total_lines = sum(1 for _ in f)
-                    except OSError:
+                    # 大文件全量计数代价高——先比 st_size 与 _READ_TOTAL_LINE_MAX_BYTES
+                    # （对齐 deepagents sandbox.py:499 的 MAX_LINE_COUNT_BYTES=1MiB 闸门），
+                    # 超过则不数（返回 None，next_offset 退化为 end_line），避免无界扫描
+                    # 把 read 变成对 GB 级文件的逐行计数慢操作。
+                    file_size = os.path.getsize(file_path)
+                    if file_size <= _READ_TOTAL_LINE_MAX_BYTES:
+                        try:
+                            with open(file_path, 'r', encoding='utf-8', newline=None) as f:
+                                total_lines = sum(1 for _ in f)
+                        except OSError:
+                            total_lines = None
+                    else:
                         total_lines = None
                     # next_offset = end_line（0-indexed 下一行 = 1-indexed 末行号），
                     # 仅当确实还有后续行时设置；否则视为读到末尾。
@@ -1717,19 +1736,65 @@ def setup_sandbox_handler(app: FastAPI, config: dict = None):
         grep_opts = "-rHnFZ" if use_null_separator else "-rHnF"
 
         # 安全处理 glob_pattern，使用 shlex.quote 防止命令注入
-        glob_pattern = f"--include={shlex.quote(req.glob)}" if req.glob else ""
         pattern_escaped = shlex.quote(req.pattern)
 
-        # 注意：不再用 2>/dev/null || true，以便捕获 stderr 用于错误诊断
-        cmd = f"grep {grep_opts} {glob_pattern} -e {pattern_escaped} {quoted_path}"
+        # glob 含 '/'（如 src/**/*.py）时，GNU grep --include 只匹配 basename，
+        # 会静默返回 0 条（对齐 deepagents sandbox.py:684 _build_grep_cmd 的判定）。
+        # 这种路径 glob 改走 Python glob 预筛文件清单 + grep -F 逐文件/批量，
+        # 避免「带路径 glob 搜不到东西」的隐蔽 bug。
+        path_glob = req.glob
+        use_path_glob = bool(path_glob and "/" in path_glob)
+        if not use_path_glob:
+            glob_pattern = f"--include={shlex.quote(req.glob)}" if req.glob else ""
+            # 注意：不再用 2>/dev/null || true，以便捕获 stderr 用于错误诊断
+            cmd = f"grep {grep_opts} {glob_pattern} -e {pattern_escaped} {quoted_path}"
+        else:
+            glob_pattern = ""  # 不用 --include；文件清单由 Python glob 预筛后喂给 grep
+
         # 对齐 deepagents 0.7.1 max_count：服务端用 head 早停，多取 1 条用于判断是否截断。
         # （grep -r 没有真正的全局计数上限，head -n N+1 截 stdout 后，客户端按 N 裁剪、
         #  超过即 truncated=True。与 deepagents BaseSandbox._build_grep_cmd 同款思路。）
         max_count = req.max_count
-        if max_count is not None and max_count >= 0:
+        if not use_path_glob and max_count is not None and max_count >= 0:
             # || true 兜底 SIGPIPE（head 读够后关闭管道，grep 收到 SIGPIPE 退出码非 0）
             cmd = f"{cmd} | head -n {int(max_count) + 1} || true"
 
+        # 含路径 glob 的分支：Python glob 预筛出匹配文件清单（仅文件，递归），
+        # 经 xargs 批量喂给 grep -F。沿用 -Z/-Hn 与正文相同的 NUL/冒号解析，故
+        # 下游 _parse_grep_results 无需改动。文件清单为空时直接返回 0 条，避免起
+        # `grep -e pat`（无文件参数）误把 stdin 当搜索源。
+        def _resolve_path_glob_files():
+            import glob as glob_module
+            full_pattern = os.path.join(search_path, path_glob)
+            try:
+                files = sorted(glob_module.glob(full_pattern, recursive=True))
+            except (FileNotFoundError, NotADirectoryError, PermissionError) as e:
+                SYLogger.warning(f"[Sandbox Server] grep 路径 glob 异常: {e}")
+                return []
+            workspace_resolved_g = os.path.realpath(workspace)
+            safe = []
+            for m in files:
+                if os.path.isdir(m):
+                    continue  # grep 按文件搜，目录跳过
+                try:
+                    if not _is_path_within(m, workspace_resolved_g):
+                        continue
+                except OSError:
+                    continue
+                safe.append(m)
+            return safe
+
+        if use_path_glob:
+            path_glob_files = await asyncio.to_thread(_resolve_path_glob_files)
+            if not path_glob_files:
+                return GrepResponse(matches=[])
+            # xargs -0：文件名以 NUL 分隔喂入，文件名含空格/引号/换行也安全。
+            # find ... -print0 | grep -FZne pattern --files-from=... 也行，但 xargs 最 portable。
+            files_argv = " ".join(shlex.quote(f) for f in path_glob_files)
+            # 不加 -r（已显式给文件清单，无需递归）；保留 -H(始终带文件名) -n(行号) -F(字面量) -Z(NUL)。
+            path_glob_grep_opts = "-HnFZ" if use_null_separator else "-HnF"
+            cmd = f"printf '%s\\0' {files_argv} | xargs -0 grep {path_glob_grep_opts} -e {pattern_escaped}"
+
         # 使用 asyncio.create_subprocess_shell 异步执行
         proc = await asyncio.create_subprocess_shell(
             cmd,
@@ -1824,6 +1889,7 @@ def setup_sandbox_handler(app: FastAPI, config: dict = None):
 
         matches = await asyncio.to_thread(_parse_grep_results)
         # 对齐 deepagents 0.7.1：超出 max_count 即置 truncated（多取的 1 条在这里裁掉）。
+        # 路径 glob 分支没在服务端 head 早停（直接 grep 文件清单），这里统一兜底裁剪。
         truncated = False
         if max_count is not None and len(matches) > max_count:
             matches = matches[:max_count]

{sycommon_python_lib-0.2.7a55 → sycommon_python_lib-0.2.8a0}/src/sycommon/models/sandbox.py

@@ -143,6 +143,11 @@ class ReadResponse(BaseModel):
     end_line: Optional[int] = None
     total_lines: Optional[int] = None
     next_offset: Optional[int] = None
+    # limit<=0 早退标志（对齐 deepagents ReadResult.no_lines_requested）：
+    # True 表示「文件未检视、零行窗口」，与「空文件」区分开。客户端据此
+    # 填 ReadResult.no_lines_requested，让 FilesystemMiddleware 给出与框架
+    # 合成实现一致的分页提示（NO_LINES_REQUESTED_WARNING）而非空文件提示。
+    no_lines_requested: bool = False
 
 
 class WriteRequest(BaseModel):

sycommon_python_lib-0.2.8a0/src/sycommon/tools/user_id.py

@@ -0,0 +1,106 @@
+"""用户标识派生（跨服务共享）。
+
+本模块是【唯一】的用户标识派生入口，主项目和沙箱项目都必须从这里导入，保证
+同一人在不同服务/不同接口派生出【同一个】标识：
+
+- 沙箱目录一致（企微传的文件 Web 能看到，反之亦然）
+- MinIO 对象 key / PG checkpointer thread_id / Redis key 全部一致
+
+提供两类标识：
+
+1. **常规标识 user_id**（``normalize_user_id``）：取自 LDAP 域账号，用于沙箱目录、
+   MinIO key、PG thread_id、LLM apiKey、大部分 Redis key。
+   规则：``lower()`` + 去全部空格。
+
+2. **边界标识 redis_uid**（``redis_uid_from_str`` / ``redis_uid_from_user``）：用于
+   跨越「登录侧」与「POST /api/token 回调侧」的两个 Redis key ——
+   ``digital_work:user_token:{redis_uid}`` 和 ``digital_work:pending_auth_retry:{redis_uid}``。
+   为什么单独一层：``/api/token`` 是无登录态回调，只能从请求体 email 反推用户
+   （``email.split("@")[0]``）；而登录侧拿到的是 ``LDAPUser.username``（域账号）。
+   两者要落到同一个 Redis key，必须用同一套归一化规则。历史上两边各自写死，靠
+   「域账号 == 邮箱本地名」的隐含约定；一旦某员工两者不一致（域账号 ``lisi``、
+   邮箱 ``li.si@…``）就断链——token 写到了读侧永远查不到的 key 下，表现为
+   「已授权却报未授权」。集中到一处彻底消除该隐含约定。
+"""
+from __future__ import annotations
+
+from typing import Any
+
+
+def normalize_user_id(s: str | None) -> str:
+    """把域账号/登录名归一化成统一的 user_id：lower() + 去全部空格。
+
+    主项目(api/chat.py、files.py、redis_session.py、health.py)与企微
+    (wecom_ldap_service.resolve_unified_user_id)都用它，消除各自硬编码
+    ``.lower().replace(" ","")`` 的散落写法，避免一处漏改导致两端不一致
+    → 沙箱目录错位 → 企微/Web 文件不互通。
+
+    Args:
+        s: 域账号(sAMAccountName)或登录名，可能带大小写/空格。
+
+    Returns:
+        归一化后的 user_id（小写、无空格）；入参为空返回 ``""``。
+    """
+    if not s:
+        return ""
+    return s.lower().replace(" ", "")
+
+
+def redis_uid_from_str(s: str | None) -> str:
+    """把字符串归一化成边界键用的 redis_uid。
+
+    规则：取 ``@`` 前的邮箱本地名，再 ``lower()`` + 去空格。
+    与 ``POST /api/token`` 写入侧（``email.split("@")[0]``）完全对齐。
+
+    - ``"Zhang.San@shengye.com"`` → ``"zhang.san"``
+    - ``"lisi@shengye.com"``      → ``"lisi"``
+    - ``"lisi"``（无 @）          → ``"lisi"``（原样归一化）
+    - ``""`` / ``None``           → ``""``
+    """
+    if not s:
+        return ""
+    return s.split("@")[0].lower().replace(" ", "")
+
+
+def redis_uid_from_user(user: Any) -> str:
+    """从 LDAPUser（或带 email/username 属性的对象）派生边界键用的 redis_uid。
+
+    优先取 ``email`` 的本地名；无 email 时回退 ``username``（= 现状，
+    不会比改动前更差——改动前所有读侧本来就用 username）。
+
+    Args:
+        user: ``sycommon.auth.LDAPUser`` 实例，或 ``None``。
+
+    Returns:
+        归一化后的 redis_uid 字符串；入参为 ``None`` 时返回 ``""``。
+    """
+    if user is None:
+        return ""
+    raw = getattr(user, "email", None) or getattr(user, "username", "") or ""
+    return redis_uid_from_str(raw)
+
+
+def make_thread_id(user_id: str, session_id: str | None) -> str:
+    """构造 LangGraph checkpointer 的 thread_id（Web 端会话隔离核心）。
+
+    规则：``session_id`` 非空 → ``f"{user_id}:{session_id}"``；为空 → ``user_id``。
+    这是 PG checkpoint 表里【唯一】的用户隔离维度（langgraph 按
+    ``WHERE thread_id = %s`` 读写），两个请求 thread_id 相同 = 共用同一对话历史。
+
+    Args:
+        user_id: 已归一化的 user_id（``normalize_user_id`` 产物）。
+        session_id: 前端会话 ID。为空/None 时退化为单会话模式（thread_id=user_id）。
+
+    Returns:
+        thread_id 字符串。
+
+    ⚠️ 调用方职责：
+      - user_id 必须先经 normalize_user_id 归一化（否则大小写/空格漂移会串）。
+      - session_id 的唯一性由前端保证；后端不强制，但若前端重复传同一 session_id，
+        同一用户的两会话会合并历史（前端 bug 即后端串）。如需更强隔离，可在
+        session_id 为空时强制生成 uuid（当前保持「退化为 user_id」的旧行为，不破坏
+        既有单会话语义）。
+    """
+    if session_id:
+        return f"{user_id}:{session_id}"
+    return user_id

{sycommon_python_lib-0.2.7a55 → sycommon_python_lib-0.2.8a0}/src/sycommon_python_lib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.7a55
+Version: 0.2.8a0
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -9,11 +9,11 @@ Requires-Dist: aiohttp==3.14.3
 Requires-Dist: aiomysql==0.3.2
 Requires-Dist: anyio==4.14.2
 Requires-Dist: decorator==5.3.1
-Requires-Dist: deepagents==0.7.1
-Requires-Dist: elasticsearch==9.4.1
+Requires-Dist: deepagents==0.7.4
+Requires-Dist: elasticsearch==9.5.0
 Requires-Dist: fastapi==0.141.1
 Requires-Dist: jinja2==3.1.6
-Requires-Dist: kafka-python==3.0.9
+Requires-Dist: kafka-python==3.0.10
 Requires-Dist: langchain==1.3.14
 Requires-Dist: langchain-core==1.5.3
 Requires-Dist: langchain-openai==1.4.1