sycommon-python-lib 0.2.8a4__py3-none-any.whl → 0.2.8a6__py3-none-any.whl

sycommon/agent/deep_agent.py

@@ -1274,21 +1274,6 @@ async def create_deep_agent(
             on_evaluation=rubric_eval_collector.on_evaluation,
         ))
 
-    # SkillApiWhitelistMiddleware(旧管控层)：已被出网收口取代——
-    # 沙箱网关(egress gateway)做 path 白名单+凭据注入,iptables 硬墙(egress_wall)
-    # 在内核层挡 node/裸socket。旧的 .wl 推送/sitecustomize monkeypatch/shell-guard
-    # 不再注册(子进程 env 零密钥后 sitecustomize 的 SYT_API_AUTHZ 注入也已由网关承接)。
-    # 回滚开关: 环境变量 SANDBOX_LEGACY_WHITELIST=1 时恢复注册(应急用)。
-    if sandbox_backend and os.environ.get("SANDBOX_LEGACY_WHITELIST", "") == "1":
-        try:
-            from sycommon.agent.middleware.skill_api_whitelist import (
-                SkillApiWhitelistMiddleware)
-            middleware_list.append(
-                SkillApiWhitelistMiddleware(sandbox_backend))
-            SYLogger.warning("[DeepAgent] 旧白名单中间件已启用(SANDBOX_LEGACY_WHITELIST=1 应急模式)")
-        except Exception as _wl_err:
-            SYLogger.warning(f"[DeepAgent] 技能接口白名单中间件加载失败(忽略): {_wl_err}")
-
     agent_kwargs = {
         "model": raw_model,
         "tools": config.tools or [get_current_date],

sycommon/middleware/egress_wall.py

@@ -13,8 +13,8 @@ EgressPolicy 来自沙箱自己的 Nacos dataId(shengye-platform-sandbox)的
 EgressPolicy 段(见 sycommon/config/EgressPolicyConfig.py),Nacos 热更新后
 调 refresh_egress_wall() 重配。
 
-这是 L3/L4 内核级硬墙，语言无关、绕不过——比应用层 hook（sitecustomize/
-LD_PRELOAD/HTTPS_PROXY）强且无盲区。
+这是 L3/L4 内核级硬墙，语言无关、绕不过——比旧应用层 hook（已删的 
+monkeypatch/LD_PRELOAD 等）强且无盲区。
 
 设计要点：
   - owner-match（-m owner --uid-owner）：只锁 child uid，沙箱服务进程（root/其它 uid）

sycommon/middleware/sandbox.py

@@ -971,6 +971,20 @@ def setup_sandbox_handler(app: FastAPI, config: dict = None):
         env["TEMP"] = os.path.join(workspace, "tmp")
         env["TMP"] = os.path.join(workspace, "tmp")
         env["SANDBOX_ROOT"] = workspace
+        # 签名型凭据豁免(企微文档机器人):WECOM_DOC_BOT_* 用于【本地 HMAC 签名】
+        # (sign=sha256(secret+bot_id+t+nonce)),签名必须在发起方算,网关无法代注
+        # ——这是收口「零密钥」的已知例外。流量仍走网关(URL 指网关+X-Upstream-Host,
+        # 受白名单/审计管制),只是 secret 必须到脚本手里。仅当凭据包里有才注入。
+        try:
+            from sycommon.middleware.sandbox_gateway import credential_store
+            _c = credential_store().any_user()
+            _creds = credential_store().get(_c) if _c else None
+            for _k in ("WECOM_DOC_BOT_ID", "WECOM_DOC_BOT_SECRET"):
+                _v = (_creds or {}).get(_k)
+                if _v:
+                    env[_k] = str(_v)
+        except Exception:
+            pass
         # 出网网关：子进程 SYT_BASE_URL 指向网关（http://127.0.0.1:port），
         # HTTPS_PROXY 让 requests/httpx/curl/wget 自动走网关。node/裸 socket 不读
         # proxy 的运行时，由后续 seccomp 硬墙兜底（只放行网关 host:port）。

sycommon/middleware/sandbox_gateway.py

@@ -6,7 +6,7 @@
   1. 按「目标 host → 凭据形态」注入正确凭据（SYT 用 Authorization Bearer +
      X-Sy-Api-Authz；OA 系用 SYU-Token + SYU-Url 改写；企微 gettoken 用
      URL query 的 corpid/corpsecret；内网服务无鉴权透传）。
-  2. 复用 skill_wl_check.match 做 path 白名单校验，不在白名单 → 403。
+  2. host/path 白名单校验（EgressPolicy 驱动），不在名单 → 403。
   3. 删子进程自带的凭据头（Authorization/SYU-Token/X-Sy-Api-Authz），由网关
      重新注入正确值（防子进程塞脏值/旧值）。
   4. 审计：每个请求记录 user/host/path/状态码/字节量。
@@ -116,15 +116,22 @@ def _strip_cred_headers(headers) -> dict:
 
 
 def _apply_credentials(method: str, target_url: str, headers: dict,
-                       creds: dict) -> tuple[str, dict]:
+                       creds: dict, upstream_host: str = "") -> tuple[str, dict]:
     """按目标 host/path 改写 URL（query 注入）+ 注入凭据头。返回 (url, headers)。
 
     网关→真上游的请求构造在此完成。host 路由表见模块 docstring。
+    upstream_host: 请求头 X-Upstream-Host 的值(网关 origin 模式下 URL host 是
+    网关自身,真实目标在该头里)——凭据路由优先按它判定,其次按 URL host。
     """
     host = (urlparse(target_url).hostname or "").lower()
+    # 网关 origin 模式:URL host 是 127.0.0.1(网关),真实目标在 X-Upstream-Host;
+    # 凭据路由按真实目标判定(取两者中非网关地址的那个)。
+    route_host = host
+    if upstream_host:
+        route_host = (urlparse(f"https://{upstream_host}").hostname or "").lower()
 
     # --- SYT 网关：Bearer + X-Sy-Api-Authz + X-Host-Name ---
-    if _match_syt_upstream(host, creds.get("SYT_BASE_URL", "")):
+    if _match_syt_upstream(route_host, creds.get("SYT_BASE_URL", "")):
         token = creds.get("SYT_TOKEN", "")
         if token:
             headers["Authorization"] = f"Bearer {token}"
@@ -137,7 +144,7 @@ def _apply_credentials(method: str, target_url: str, headers: dict,
         return target_url, headers
 
     # --- 企微 gettoken：corpid/corpsecret 在 URL query ---
-    if _is_wecom(host):
+    if _is_wecom(route_host):
         corp_id = creds.get("WECOM_CORP_ID", "")
         corp_secret = creds.get("WECOM_CORP_SECRET", "")
         if corp_id and corp_secret and "/cgi-bin/gettoken" in target_url:
@@ -146,10 +153,12 @@ def _apply_credentials(method: str, target_url: str, headers: dict,
             q.setdefault("corpid", corp_id)
             q.setdefault("corpsecret", corp_secret)
             target_url = urlunparse(parsed._replace(query=urlencode(q)))
+        # 企微文档机器人(wecom.py 的 MCP 网关)用 DOC_BOT 凭据签名——不在此注入
+        # (wecom.py 本地算签名),只保证 gettoken 的 corp 凭据注入。
         return target_url, headers
 
     # --- OA MCP 后端：SYU-Token + SYU-Url（改写为真上游 base）---
-    if _is_oa_backend(host):
+    if _is_oa_backend(route_host):
         token = creds.get("SYT_TOKEN", "")
         syt_base = (creds.get("SYT_BASE_URL") or "").rstrip("/")
         if token:
@@ -231,7 +240,7 @@ def _check_allowlist(target_url: str, creds: dict,
 
 
 def _url_allowed(url: str, allowlist: list[str]) -> bool:
-    """与 skill_wl_check._is_allowed 同构的 path 级前缀匹配（不依赖 env）。"""
+    """path 级前缀匹配（斜杠边界）。"""
     try:
         p = urlparse(url if "://" in url else "http://" + str(url))
     except Exception:
@@ -412,9 +421,23 @@ class EgressGateway:
         syt_base = (creds.get("SYT_BASE_URL") or "").rstrip("/")
         if upstream_host:
             # SSRF 防护:上游 host 禁止指向回环/本机/私有网段(本机服务含沙箱
-            # 自身 API,免鉴权,打穿即跨用户任意执行)。非回环的 10.x/172.16-31.x/
-            # 192.168.x 内网目标按 EgressPolicy 判定(directAllow 命中才放)。
-            if _is_loopback_or_private(upstream_host):
+            # 自身 API,免鉴权,打穿即跨用户任意执行)。例外:EgressPolicy 里
+            # viaGateway/directAllow 显式登记的【信任内网上游】(如 OA MCP
+            # ai.syitservice.com→10.10.1.171)——它们是内网服务但有意经营,
+            # 不属于 SSRF 攻击面(策略由 _check_allowlist 继续管)。
+            policy = None
+            try:
+                from sycommon.config.EgressPolicyConfig import EgressPolicyConfig
+                policy = EgressPolicyConfig.from_config()
+            except Exception:
+                policy = None
+            trusted = []
+            if policy is not None:
+                trusted = list(policy.viaGateway) + list(policy.directAllow)
+            uh_hostname = upstream_host.split(":")[0] if upstream_host.count(":") <= 1 \
+                else upstream_host
+            if (_is_loopback_or_private(upstream_host)
+                    and not EgressPolicyConfig._host_match(uh_hostname.lower(), trusted)):
                 SYLogger.warning(
                     f"[EgressGateway] 拒绝内网/回环上游(SSRF 防护): {upstream_host}")
                 return web.Response(status=403, text="gateway: upstream host not allowed")
@@ -446,9 +469,11 @@ class EgressGateway:
                 continue
             fwd_headers[k] = v
 
-        # 注入凭据头 / 改写 URL（query 注入）
+        # 注入凭据头 / 改写 URL（query 注入）。
+        # upstream_host 透传给凭据路由:网关 origin 模式下 URL host 是网关自身,
+        # 真实目标在 X-Upstream-Host——OA(ai.sy)/企微按它判路由。
         target_url, fwd_headers = _apply_credentials(
-            request.method, target_url, fwd_headers, creds)
+            request.method, target_url, fwd_headers, creds, upstream_host)
 
         # 读请求体（上传场景）
         body = await request.read() if request.can_read_body else None

{sycommon_python_lib-0.2.8a4.dist-info → sycommon_python_lib-0.2.8a6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.8a4
+Version: 0.2.8a6
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{sycommon_python_lib-0.2.8a4.dist-info → sycommon_python_lib-0.2.8a6.dist-info}/RECORD

@@ -136,7 +136,7 @@ sycommon/services.py,sha256=BalCSLqx0aictqEsyUOUXimjqdMGbZgZyd0MqViaBI0,27315
 sycommon/agent/__init__.py,sha256=mxceAeUifQ-DKvWp7ZEJIFlmOCb5wpYHPGQw3rwEN8I,4378
 sycommon/agent/agent_manager.py,sha256=UhhaekEumT7g4v_Z1UB4jTp13X0n8M8erYaQdkGGWkA,13620
 sycommon/agent/chat_events.py,sha256=t7qWa6OrIWLfqtd1AnqaVP67QWkn1JxpCBTZYQpoLuM,14226
-sycommon/agent/deep_agent.py,sha256=aH2SM-TXacbW8gziFMlBkPOB4CbDzC3CCly5v6HWrXY,88388
+sycommon/agent/deep_agent.py,sha256=kDEdlXKha2moNMNUA0FIP99gCkosyi0WohcTqB9uYo8,87346
 sycommon/agent/multi_agent_team.py,sha256=227UgO0XrrPxvQE4xXTNCCYq-5WiUi13r_AUolTpLS4,34719
 sycommon/agent/reasoning_content_patch.py,sha256=HZ_If0qVDHlz_b1mDT3tuTqbExhzRVhP4VgsoDt0JLc,3945
 sycommon/agent/resume_compactor.py,sha256=CJp3AUqeStr8U2JeWP31DyulomXZdrkLL4kVtLxnwn8,20849
@@ -152,9 +152,6 @@ sycommon/agent/mcp/tool_loader.py,sha256=pwhZoSoZuQVYo6BgfdMoRHlGnRPDRxvOvxEgvUM
 sycommon/agent/middleware/model_request_prep.py,sha256=W0dTgdFo6RI0Tg9jdN7jSB9QOroQR5XHIrm2hw5lslk,7618
 sycommon/agent/middleware/sandbox_path_guard.py,sha256=K1SnxA8pDxkCSucOkranwUvC9_8rd3l_-TIR8gMMTK8,8102
 sycommon/agent/middleware/sensitive_guard.py,sha256=Ql4BUwF0rNOcpqB7OOHTaO0-65MTEJ9Qk-sC6p7SIQ4,31834
-sycommon/agent/middleware/sitecustomize.py,sha256=2EUuYvmbmNXfCuW3uF_shh4Egt4kqmkPgTUaQGDWt5g,9781
-sycommon/agent/middleware/skill_api_whitelist.py,sha256=YjkqUzylOcRfNH8cd43lKpHIXCp9ql-3yxMAM9fSqh4,22154
-sycommon/agent/middleware/skill_wl_check.py,sha256=rCJ9F6aWPh8tVQBIPmcq2lKDsfwiJQduwSUku_8kXfs,3952
 sycommon/agent/middleware/skill_write_guard.py,sha256=ZLW-OIG56z5LvLRMaMnryhPz_O5PbrdTLuHTfC3PveA,3101
 sycommon/agent/sandbox/__init__.py,sha256=jR7LlkD4J4Y6QYyRXQClkwmqDBCCPmycV_hQV9p9YHw,4621
 sycommon/agent/sandbox/consistent_hash.py,sha256=8Jgk-W4NAD2-u5_vKRVlPmql_e0Vy4aNORiXOuzvIrs,7277
@@ -183,7 +180,6 @@ sycommon/config/PgConfig.py,sha256=Hs9LwgIxSBxcFP16oq18N6Gq9hU2qVl4-7bPfd-ON_s,2
 sycommon/config/RedisConfig.py,sha256=gIa4BS8L_HdmBg9Dkv3cuIK6CU9zt9RodZOJUuUlh5Y,5235
 sycommon/config/RerankerConfig.py,sha256=35sVwzus2IscvTHnCG63Orl2pC-pMsrVi6wAGDmOH3U,341
 sycommon/config/SentryConfig.py,sha256=OsLb3G9lTsCSZ7tWkcXWJHmvfILQopBxje5pjnkFJfo,320
-sycommon/config/SkillApiWhitelistConfig.py,sha256=-fimbAofnYSZRhksmvg_rrZOJPc76wSWClH57L1xg-s,4059
 sycommon/config/XxlJobConfig.py,sha256=VSG6dn9ysfUVunOs7PqugyZUGJWmX_cEePz2ZCfqHtU,392
 sycommon/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sycommon/config/config_change_notifier.py,sha256=7qQe7vdBS1zohEfVq0d5IaDqYsLdgd2ckF4mKKgh0gE,6848
@@ -234,13 +230,13 @@ sycommon/middleware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSu
 sycommon/middleware/context.py,sha256=Skwq0IAXJmyVTZCYoNbjWotExmm2LgxS-dlENQ4bnUs,1188
 sycommon/middleware/cors.py,sha256=0B5d_ovD56wcH9TfktRs88Q09R9f8Xx5h5ALWYvE8Iw,600
 sycommon/middleware/docs.py,sha256=bVdDBIHXGVBv562MQLSroa1DgHoObxR9gFzv71PIejg,1187
-sycommon/middleware/egress_wall.py,sha256=BWp9M0SG4YH1b_bLeO1NB2wXo66SRoZxmyKeNvHjetw,11756
+sycommon/middleware/egress_wall.py,sha256=z66EInw-tjy7UnPzP6lAjBqSoMKi2FbPKGVqRV-3qpY,11759
 sycommon/middleware/exception.py,sha256=UAy0tKijI_2JoKjwT3h62aL-tybftP3IETvcr26NOao,2883
 sycommon/middleware/middleware.py,sha256=1qA_0rT7pv1xTfuvA0kdYkxVOHYT6roSSNO7Cmf2wYg,1778
 sycommon/middleware/monitor_memory.py,sha256=pYRK-wRuDd6enSg9Pf8tQxPdYQS6S0AyjyXeKFRLKEs,628
 sycommon/middleware/mq.py,sha256=9X6KKtadFjBXKS5L3kEKujYio9wwGfWgXwWOAHO-HDg,254
-sycommon/middleware/sandbox.py,sha256=q4meNKKonqviamB4iDcX92pfSNZ7PLwjikfeCjdxr2Q,101543
-sycommon/middleware/sandbox_gateway.py,sha256=MdvzYz-LLicwX9YkwreZA7OUTR9WTwVi6VW4e20wQWw,23298
+sycommon/middleware/sandbox.py,sha256=UMSFteEKhzbL-G_o0BypIc6MftmQd5ICzK8eWgJhhq8,102376
+sycommon/middleware/sandbox_gateway.py,sha256=pwW0n-U7JVO3oE1l1L_7P55hcnI0lQMGyRPfFNpMbBE,24920
 sycommon/middleware/timeout.py,sha256=KlxOPa8xl2dg6yuRi_EzkVJG8bX4stb5ueYxctzzGM8,1433
 sycommon/middleware/token_tracking.py,sha256=rEbgV1bgWMdzAERx4aq5XAvOIT6jTY_tK1P0xHJnL3o,6609
 sycommon/middleware/tool_result_truncation.py,sha256=xtwBf8q11Z8EPzmo3Ju4OfUbULOklSsWo_oystxCW0o,13640
@@ -333,8 +329,8 @@ sycommon/tools/timing.py,sha256=OiiE7P07lRoMzX9kzb8sZU9cDb0zNnqIlY5pWqHcnkY,2064
 sycommon/tools/user_id.py,sha256=o-zsubGSR5rSSZf8Pk8B7AhE21ahDTTIW5JZmJO6Flw,4761
 sycommon/xxljob/__init__.py,sha256=7eoBlQxv-B39IfRSCY2bkqdGYs1QRe1umAWd88VMEEM,86
 sycommon/xxljob/xxljob_service.py,sha256=1yifwIBNGsCIxLnQjHKiBlbsigc_zvPH-dMTZcNxe-Q,7649
-sycommon_python_lib-0.2.8a4.dist-info/METADATA,sha256=NZxc6nNAdgPwefWjpCfFT3wVBl8QhqlfcVGh7M_0Fb8,7996
-sycommon_python_lib-0.2.8a4.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-sycommon_python_lib-0.2.8a4.dist-info/entry_points.txt,sha256=gsR4SssKxDWjRU8ggidzNcdMXDPRSKRS7UaGyNP84Qg,92
-sycommon_python_lib-0.2.8a4.dist-info/top_level.txt,sha256=RgphKrg7nJyZ7irJqbxFr-5H2LUYTvI7ivoWZH2hcD0,29
-sycommon_python_lib-0.2.8a4.dist-info/RECORD,,
+sycommon_python_lib-0.2.8a6.dist-info/METADATA,sha256=3brl8cOuDVlHkn1Zz5YiDtGIV8Jcg4RzKWlmMYNdvLU,7996
+sycommon_python_lib-0.2.8a6.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+sycommon_python_lib-0.2.8a6.dist-info/entry_points.txt,sha256=gsR4SssKxDWjRU8ggidzNcdMXDPRSKRS7UaGyNP84Qg,92
+sycommon_python_lib-0.2.8a6.dist-info/top_level.txt,sha256=RgphKrg7nJyZ7irJqbxFr-5H2LUYTvI7ivoWZH2hcD0,29
+sycommon_python_lib-0.2.8a6.dist-info/RECORD,,

sycommon/agent/middleware/sitecustomize.py

@@ -1,300 +0,0 @@
-"""技能接口白名单客户端注入脚本（部署到沙箱 site-packages）。
-
-Python 解释器启动时（未传 -S）自动 import 本模块。它负责 Python HTTP 库的
-请求拦截：
-
-  1. 读环境变量 SKILL_API_WHITELIST（JSON）。无此 env → 不管控（全放行，fail-open）。
-  2. monkeypatch urllib / httpx / requests / aiohttp，发请求前做 path 级前缀匹配，
-     未命中抛 PermissionError（LLM 能看到清晰错误）。
-
-  ⚠️ shell 命令（curl/wget 等）的拦截【不】在本文件处理——sitecustomize 只在
-     `python` 启动时执行，纯 shell 命令不会触发它。shell 拦截由主进程中间件把
-     curl/wget 包装函数【内联】到每条 execute 命令前缀实现（见 skill_api_whitelist.py）。
-
-URL 匹配核心逻辑复用同目录 skill_wl_check.py。
-
-另外提供【独立于白名单】的 header 注入：当环境变量 SYT_API_AUTHZ 非空时，
-对 host 命中 SYT_BASE_URL 的请求自动补 X-Sy-Api-Authz 头。这是云平台网关的
-鉴权要求，对所有沙箱技能请求生效（不门控白名单），由中间件无条件 export
-SYT_API_AUTHZ + 推送本 sitecustomize 触发。
-
-注意：本模块在沙箱子进程里运行，不依赖主进程内存。配置全部来自环境变量。
-"""
-
-import json
-import os
-import sys
-from urllib.parse import urlparse
-
-# SKILL_API_WHITELIST 存在即「启用管控」；allowlist 为空时「全拦截」。
-_ENABLED = "SKILL_API_WHITELIST" in os.environ
-
-# 把沙箱 site-packages 里存放本模块的目录加入 sys.path，以便 import skill_wl_check。
-_HERE = os.path.dirname(os.path.abspath(__file__))
-if _HERE not in sys.path:
-    sys.path.insert(0, _HERE)
-
-
-def _load_check():
-    """加载同目录 skill_wl_check，返回其 match 函数；失败返回 None。"""
-    try:
-        import skill_wl_check  # type: ignore
-        return skill_wl_check
-    except Exception as e:  # pragma: no cover
-        sys.stderr.write("[sitecustomize] 加载 skill_wl_check 失败，白名单禁用: %s\n" % e)
-        return None
-
-
-def _patch_urllib(match):
-    import urllib.request
-
-    _orig = urllib.request.urlopen
-
-    def _urlopen(url, *args, **kwargs):
-        actual = url.full_url if isinstance(url, urllib.request.Request) else url
-        if actual and not match(str(actual)):
-            raise PermissionError(
-                "[SkillApiWhitelist] 拦截: URL 不在白名单内 (urlopen, %s)" % actual)
-        return _orig(url, *args, **kwargs)
-
-    urllib.request.urlopen = _urlopen
-
-
-def _patch_httpx(match):
-    try:
-        import httpx
-    except ImportError:
-        return
-
-    _orig_sync = httpx.Client.send
-
-    def _send(self, request, **kwargs):
-        if not match(str(request.url)):
-            raise PermissionError(
-                "[SkillApiWhitelist] 拦截: URL 不在白名单内 (httpx, %s)" % request.url)
-        return _orig_sync(self, request, **kwargs)
-
-    httpx.Client.send = _send
-
-    if hasattr(httpx, "AsyncClient"):
-        _orig_async = httpx.AsyncClient.send
-
-        async def _asend(self, request, **kwargs):
-            if not match(str(request.url)):
-                raise PermissionError(
-                    "[SkillApiWhitelist] 拦截: URL 不在白名单内 (httpx.async, %s)" % request.url)
-            return await _orig_async(self, request, **kwargs)
-
-        httpx.AsyncClient.send = _asend
-
-
-def _patch_requests(match):
-    try:
-        import requests
-    except ImportError:
-        return
-
-    _orig = requests.Session.request
-
-    def _request(self, method, url, *args, **kwargs):
-        if not match(str(url)):
-            raise PermissionError(
-                "[SkillApiWhitelist] 拦截: URL 不在白名单内 (requests %s, %s)"
-                % (method.upper(), url))
-        return _orig(self, method, url, *args, **kwargs)
-
-    requests.Session.request = _request
-
-
-def _patch_aiohttp(match):
-    try:
-        import aiohttp
-    except ImportError:
-        return
-    if not hasattr(aiohttp.ClientSession, "_request"):
-        return
-
-    _orig = aiohttp.ClientSession._request
-
-    async def _request(self, method, str_or_url, **kwargs):
-        if not match(str(str_or_url)):
-            raise PermissionError(
-                "[SkillApiWhitelist] 拦截: URL 不在白名单内 (aiohttp %s, %s)"
-                % (method, str_or_url))
-        return await _orig(self, method, str_or_url, **kwargs)
-
-    aiohttp.ClientSession._request = _request
-
-
-# =============== header 注入（独立于白名单）===============
-# 云平台网关要求请求带 X-Sy-Api-Authz 头。仅当 host 命中 SYT_BASE_URL 的 host
-# 才补该头，其它域名（内网 OCR / 企微 / 合同比对内网 / MCP 后端等）不注入。
-# 门控：环境变量 SYT_API_AUTHZ 非空。调用方已显式设过同名头则不覆盖。
-
-_AUTHZ_HEADER = "X-Sy-Api-Authz"
-
-
-def _syt_host():
-    """解析 SYT_BASE_URL 的 host（小写）。失败返回 None。"""
-    base = os.environ.get("SYT_BASE_URL", "").strip()
-    if not base:
-        return None
-    try:
-        return (urlparse(base).hostname or "").lower() or None
-    except Exception:
-        return None
-
-
-def _host_matches_syt(url) -> bool:
-    """请求 URL 的 host 是否等于 SYT_BASE_URL 的 host。"""
-    host = _syt_host()
-    if not host:
-        return False
-    try:
-        return (urlparse(str(url)).hostname or "").lower() == host
-    except Exception:
-        return False
-
-
-def _patch_urllib_hdr():
-    import urllib.request
-
-    _orig = urllib.request.urlopen
-
-    def _urlopen(url, *args, **kwargs):
-        # 只能给 Request 对象补头；裸 str URL 在 urlopen 层无 headers 概念，跳过
-        if isinstance(url, urllib.request.Request) and _host_matches_syt(url.full_url):
-            url.add_header(_AUTHZ_HEADER, os.environ["SYT_API_AUTHZ"])
-        return _orig(url, *args, **kwargs)
-
-    urllib.request.urlopen = _urlopen
-
-
-def _patch_requests_hdr():
-    try:
-        import requests
-    except ImportError:
-        return
-
-    _orig = requests.Session.request
-
-    def _request(self, method, url, *args, **kwargs):
-        if _host_matches_syt(url):
-            headers = kwargs.get("headers")
-            if headers is None:
-                headers = {}
-            if isinstance(headers, dict):
-                if _AUTHZ_HEADER not in headers:
-                    headers[_AUTHZ_HEADER] = os.environ["SYT_API_AUTHZ"]
-                kwargs["headers"] = headers
-            else:
-                # list / 其它形态：保守起见交给底层，避免破坏既有结构
-                pass
-        return _orig(self, method, url, *args, **kwargs)
-
-    requests.Session.request = _request
-
-
-def _patch_httpx_hdr():
-    try:
-        import httpx
-    except ImportError:
-        return
-
-    def _apply(request):
-        if request is not None and _host_matches_syt(request.url):
-            request.headers.setdefault(_AUTHZ_HEADER, os.environ["SYT_API_AUTHZ"])
-
-    _orig_sync = httpx.Client.send
-
-    def _send(self, request, **kwargs):
-        _apply(request)
-        return _orig_sync(self, request, **kwargs)
-
-    httpx.Client.send = _send
-
-    if hasattr(httpx, "AsyncClient"):
-        _orig_async = httpx.AsyncClient.send
-
-        async def _asend(self, request, **kwargs):
-            _apply(request)
-            return await _orig_async(self, request, **kwargs)
-
-        httpx.AsyncClient.send = _asend
-
-
-def _patch_aiohttp_hdr():
-    try:
-        import aiohttp
-    except ImportError:
-        return
-    if not hasattr(aiohttp.ClientSession, "_request"):
-        return
-
-    _orig = aiohttp.ClientSession._request
-
-    async def _request(self, method, str_or_url, **kwargs):
-        if _host_matches_syt(str_or_url):
-            headers = kwargs.get("headers")
-            if isinstance(headers, dict):
-                if _AUTHZ_HEADER not in headers:
-                    headers[_AUTHZ_HEADER] = os.environ["SYT_API_AUTHZ"]
-            elif headers is None:
-                kwargs["headers"] = {_AUTHZ_HEADER: os.environ["SYT_API_AUTHZ"]}
-            else:
-                # list / CIMultiDict 等其它形态：跳过，避免破坏结构
-                pass
-        return await _orig(self, method, str_or_url, **kwargs)
-
-    aiohttp.ClientSession._request = _request
-
-
-def _install_header_injection():
-    """装 header 注入 patch（独立于白名单）。
-
-    门控：环境变量 SYT_API_AUTHZ 非空。任一库 import 失败都不阻断。
-    """
-    val = os.environ.get("SYT_API_AUTHZ", "").strip()
-    if not val:
-        return
-    if not _syt_host():
-        sys.stderr.write(
-            "[sitecustomize] SYT_API_AUTHZ 已设置但 SYT_BASE_URL 无法解析 host，"
-            "跳过 header 注入\n")
-        return
-    _patch_urllib_hdr()
-    _patch_requests_hdr()
-    _patch_httpx_hdr()
-    _patch_aiohttp_hdr()
-
-
-def _install():
-    if not _ENABLED:
-        return
-    check = _load_check()
-    if check is None:
-        return
-    # allowlist 为空（明确禁止）时也走校验——match 必然 False，从而全拦截。
-    match = check.match
-    _patch_urllib(match)
-    _patch_httpx(match)
-    _patch_requests(match)
-    _patch_aiohttp(match)
-
-
-# 保留解析结果（供排查）
-try:
-    _WHITELIST_RAW = json.loads(os.environ.get("SKILL_API_WHITELIST", "{}"))
-except Exception:
-    _WHITELIST_RAW = {}
-
-try:
-    _install()
-except Exception as _e:  # 任何 patch 失败都不能阻断进程启动
-    sys.stderr.write("[sitecustomize] 白名单安装失败（fail-open）: %s\n" % _e)
-
-# header 注入独立于白名单，单独 try/except，互不影响
-try:
-    _install_header_injection()
-except Exception as _e:
-    sys.stderr.write("[sitecustomize] header 注入安装失败（fail-open）: %s\n" % _e)

sycommon/agent/middleware/skill_api_whitelist.py

@@ -1,479 +0,0 @@
-"""技能接口白名单中间件。
-
-拦截 `execute` 工具（FilesystemMiddleware 注册的 shell 执行工具），做两件事：
-
-1. 从命令路径推断顶级技能名（skills/<顶级技能>/ → <顶级技能>，如 sy-oa-skill），
-   查 SkillApiWhitelist 配置得到该顶级技能的白名单，把占位符 ${VAR} 在主进程
-   解析成完整 URL，序列化成 JSON 后以 `export SKILL_API_WHITELIST='<json>'`
-   前缀注入命令——供沙箱内 sitecustomize.py 读取并 monkeypatch urllib/
-   httpx/requests/aiohttp。每个顶级技能的 allowlist 是其下所有子技能出网地址的并集。
-
-2. 命令前缀内联 curl/wget 的 shell 函数包装：纯 shell 命令（不走 Python）
-   不会触发 sitecustomize，故用 shell 函数在执行 curl/wget 前调
-   `python -m skill_wl_check <url>` 做校验，未命中则 return 1 拦截。
-
-3. 首次惰性把 sitecustomize.py + skill_wl_check.py 推进沙箱 site-packages，
-   使 Python 启动时自动 import sitecustomize。
-
-语义：子技能未配置 / enabled:false → 不注入（全放行，向后兼容）；
-allowlist:[] 空数组 → 注入空白名单（全拦截）。
-"""
-
-import base64
-import hashlib
-import json
-import os
-import re
-import shlex
-from typing import Optional
-from urllib.parse import urlparse
-
-from langchain.agents.middleware.types import AgentMiddleware
-from langchain_core.messages import ToolMessage
-from langgraph.prebuilt.tool_node import ToolCallRequest
-
-from sycommon.logging.kafka_log import SYLogger
-
-# 命令路径形如  skills/system/sy-oa-skill/workflow-todo/scripts/x.py
-#               skills/user/sy-oa-skill/SKILL.md
-# _SKILL_TOP_RE：白名单配置提取用——限定 system|user|shengye-platform 三层后取第二段
-# 作域级技能名(如 sy-oa-skill / oa)，配合 SkillApiWhitelist 按顶级域配置。
-# (?<![\w]) 否定左查找:要求 skills 前不是单词字符,避免误匹配 myskills/。
-_SKILL_TOP_RE = re.compile(
-    r'(?<![\w])skills/(?:system|user|shengye-platform)/([A-Za-z0-9_\-]+)(?:/|$)')
-
-# _SKILL_ANY_RE：技能命令判定用（宽松）——匹配任意 skills/<...>/ 前缀。
-# 用于 header 注入等对所有技能命令（含用户自行拷贝到非 system 目录的技能）生效的能力，
-# 与白名单配置是否启用解耦。同样 (?<![\w]) 避免误匹配 myskills/。
-_SKILL_ANY_RE = re.compile(r'(?<![\w])skills/[A-Za-z0-9_\-]+(?:/|$)')
-
-# BASE_URL 占位符 ${VAR}
-_PLACEHOLDER_RE = re.compile(r'\$\{([A-Z_][A-Z0-9_]*)\}')
-
-# workspace 内白名单目录的 shell 形式（init_script 已 export $SANDBOX_ROOT，运行期展开）
-_WL_DIR = "$SANDBOX_ROOT/.wl"
-# .wl 目录在 workspace 内的相对路径段（用于 hash 校验命令里的文件名）
-_WL_FILES = [
-    ".wl/sitecustomize.py",          # 极小 loader（明文，无业务逻辑）
-    ".wl/sitecustomize.payload",     # sitecustomize.py 源码的 base64
-    ".wl/skill_wl_check.payload",    # skill_wl_check.py 源码的 base64
-]
-
-# ---- 极小 loader（落盘为 .wl/sitecustomize.py）----
-# 不含任何白名单/拦截业务逻辑，只做"解码同目录 payload + exec"。
-# 关键：把 skill_wl_check 注册成真模块对象进 sys.modules，使 sitecustomize.payload
-# 里的 `import skill_wl_check; skill_wl_check.match(...)` 按原逻辑工作（逻辑不变）。
-_LOADER_SRC = b'''# sycommon injected loader: decode payloads, exec them. No business logic.
-import os, sys, base64, types
-_HERE = os.path.dirname(os.path.abspath(__file__))
-if _HERE not in sys.path:
-    sys.path.insert(0, _HERE)
-
-
-def _run(name, ns):
-    p = os.path.join(_HERE, name)
-    try:
-        with open(p, "rb") as f:
-            exec(compile(base64.b64decode(f.read()), name, "exec"), ns)
-    except Exception as _e:
-        sys.stderr.write("[.wl loader] load %s failed: %s\\n" % (name, _e))
-
-
-_wl = types.ModuleType("skill_wl_check")
-sys.modules["skill_wl_check"] = _wl
-_run("skill_wl_check.payload", _wl.__dict__)
-_run("sitecustomize.payload", globals())
-'''
-
-
-def _build_payload(src_name: str) -> bytes:
-    """读包内源码并 base64 编码，作为 .payload 落盘内容（防明文窥探）。"""
-    raw = _load_resource_bytes(src_name)
-    return base64.b64encode(raw)
-
-
-def _expected_hashes() -> dict:
-    """运行时从主进程源码算各 .wl 文件的预期 sha256（hex）。
-
-    payload 的预期 hash 算的是【编码后的 base64 字节】——即沙箱里实际落盘内容，
-    这样 sha256 比对的就是真实文件内容。loader 的预期 hash 算 _LOADER_SRC（固定常量）。
-    """
-    loader_bytes = _LOADER_SRC
-    sc_bytes = _build_payload("sitecustomize.py")
-    wl_bytes = _build_payload("skill_wl_check.py")
-    return {
-        ".wl/sitecustomize.py": hashlib.sha256(loader_bytes).hexdigest(),
-        ".wl/sitecustomize.payload": hashlib.sha256(sc_bytes).hexdigest(),
-        ".wl/skill_wl_check.payload": hashlib.sha256(wl_bytes).hexdigest(),
-    }
-
-
-# ---- .wl 写拦截（复刻 skill_write_guard 的正则集合）----
-# .wl 目录保护：精确匹配 .wl 或 .wl/...（带边界，防误伤 myapp.wl 之类）
-_WL_PROTECTED_RE = re.compile(r'\.wl(?:/|\s|"|\'|$)')
-# 写动作动词（命令首或分号/管道/空格后）
-_WRITE_VERB_RE = re.compile(
-    r'(^|[\s;&|])(rm|rmdir|mv|cp|chmod|chown|tee|truncate|install|rsync|scp|dd|>\.wl)\b')
-# 输出重定向 > 或 >>
-_REDIRECT_RE = re.compile(r'>>?')
-_WL_DENIED_MSG = "Error: .wl 为系统注入目录，禁止写入/修改/删除。"
-
-
-def _command_writes_wl(cmd: str) -> bool:
-    """execute 命令是否在写 .wl：命中 .wl 路径 且 含写动词或重定向。"""
-    if not _WL_PROTECTED_RE.search(cmd or ""):
-        return False
-    return bool(_WRITE_VERB_RE.search(cmd) or _REDIRECT_RE.search(cmd))
-
-
-def _is_wl_path(p: str) -> bool:
-    """file_path 是否落在 .wl 目录内（write_file/edit_file 拦截用）。
-
-    注意不能用 lstrip("./")——它是按字符集 strip，会把 ".wl" 的前导 "." 也吃成 "wl"。
-    改为逐前缀剥离再判。
-    """
-    s = (p or "").strip().replace("\\", "/")
-    # 剥前导 ./ 和 /
-    while s.startswith("./") or s.startswith("/"):
-        s = s[1:] if s.startswith("/") else s[2:]
-    return s == ".wl" or s.startswith(".wl/")
-
-
-
-def _resolve_placeholders(pattern: str, env_lookup) -> Optional[str]:
-    """把 ${VAR} 替换为解析后的值。任一 VAR 不存在返回 None（配置错误）。
-
-    env_lookup: callable(var_name) -> str|None。中间件传入「先查主进程 os.environ，
-    再查 sandbox env 字典（含 SYT_BASE_URL 等运行时算出/从 Nacos 读出的值）」的查找器。
-    """
-    missing = []
-
-    def _sub(m):
-        val = env_lookup(m.group(1))
-        if val is None:
-            missing.append(m.group(1))
-            return ""
-        return str(val).rstrip("/")
-
-    expanded = _PLACEHOLDER_RE.sub(_sub, pattern)
-    if missing:
-        SYLogger.warning(
-            "[Whitelist] 占位符未定义 %s，丢弃规则 %s", missing, pattern)
-        return None
-    return expanded
-
-
-def _load_resource_bytes(filename: str) -> bytes:
-    """从本包读取注入脚本源码（package_data）。"""
-    try:
-        from importlib.resources import files
-        return (files("sycommon.agent.middleware").joinpath(filename).read_bytes())
-    except Exception as e:
-        raise RuntimeError(
-            f"读取注入脚本 {filename} 失败，请确认已随包安装(package_data): {e}") from e
-
-
-def _build_shell_guard(with_whitelist: bool = False,
-                       with_header: bool = False,
-                       with_rewrite_to_gateway: bool = False) -> str:
-    """生成内联到命令前缀的 curl/wget 包装函数（shell）。
-
-    抽取参数里【最后一个】 http(s) URL 到 _u，按需承担三类职责（可同时启用）：
-      - with_rewrite_to_gateway：把 _u 的真上游 URL 改写成网关 URL
-        （http://127.0.0.1:port，真 host 进 X-Upstream-Host 头），凭据头剥除。
-        收口模式下子进程 SYT_BASE_URL 已是网关，多数脚本自动走网关；此分支兜底
-        硬编码 https://<真上游> 的 curl/wget 命令（绕过 SYT_BASE_URL）。
-      - with_whitelist：网关已做白名单，此处保留为纵深（沙箱 python3 校验）。
-      - with_header：收口后凭据由网关注入，此分支仅在未启用收口（兼容旧部署）时生效。
-
-    skill_wl_check 与 sitecustomize 同处 site-packages，python3 启动时 sitecustomize
-    会 import 它并把该目录加入 sys.path。覆盖 curl / wget；其它 shell 出网方式
-    (nc/裸 /dev/tcp 等)不覆盖（由 seccomp 硬墙兜底）。
-    """
-    rewrite_block = ""
-    if with_rewrite_to_gateway:
-        # _u 形如 https://syapi.x.com/path?qs。改写为 http://127.0.0.1:$__GW_PORT__/path?qs，
-        # 真上游 host 进 X-Upstream-Header，并剥除 Authorization/SYU-Token/X-Sy-Api-Authz
-        # （网关重新注入正确凭据）。port 取自子进程 SYT_BASE_URL（收口已注入网关地址）。
-        # 修审核 P1-6:重写后的 URL 必须替换 "$@" 里的原 URL 参数(旧实现只改了
-        # 校验变量 _u,curl 实际仍直连真上游)。URL 参数判定:与 _u 原值相等的参数。
-        # 注:该分支当前无调用方启用(旧白名单中间件已注销,收口走 SYT_BASE_URL
-        # 指向网关),保留为 legacy 应急路径并修正确性。
-        rewrite_block = (
-            'if [ -n "$_u" ]; then '
-            # 取真上游 host（去 scheme/path/port）
-            '_rh="${_u#*://}"; _rh="${_rh%%/*}"; _rh="${_rh%%\\?*}"; _rh="${_rh%%:*}"; '
-            # 取 path?query
-            '_rp="${_u#*://}"; _rp="${_rp#*/}"; '
-            '[ "$_rp" = "$_u#*://" ] && _rp=""; '
-            '[ -n "$_rp" ] && _rp="/$_rp"; '
-            # 网关地址来自 SYT_BASE_URL（收口已注入 http://127.0.0.1:port）
-            '_gw="${SYT_BASE_URL%%/}"; '
-            'if [ -n "$__GW_PORT__" ]; then _gw="http://127.0.0.1:$__GW_PORT__"; fi; '
-            'if [ -n "$_gw" ] && [ -n "$_rh" ]; then '
-            '_rw="$_gw$_rp"; '
-            # 重建参数:剥凭据头 + 把原 URL 参数替换为网关 URL(P1-6 修)
-            'set -- "$@"; _new=(); _skip=0; '
-            'for _a in "$@"; do '
-            'if [ "$_skip" = "1" ]; then _skip=0; continue; fi; '
-            'case "$_a" in '
-            '"-H"|"--header") _skip=1; continue;; '
-            '"Authorization:"*|"SYU-Token:"*|"X-Sy-Api-Authz:"*|"SYU-Url:"*) continue;; '
-            '"$_u") _new+=("$_rw"); continue;; '
-            'esac; _new+=("$_a"); done; '
-            'set -- "${_new[@]}" -H "X-Upstream-Host: $_rh"; '
-            '_u="$_rw"; '
-            'fi; '
-            'fi; '
-        )
-    wl_block = ""
-    if with_whitelist:
-        check_cmd = (
-            'python3 -c \'import skill_wl_check,sys; '
-            'sys.exit(0 if skill_wl_check.match(sys.argv[1]) else 1)\' "$_u"'
-        )
-        wl_block = (
-            f'if [ -n "$_u" ] && ! {check_cmd}; then '
-            'echo "[SkillApiWhitelist] 拦截 shell 请求: $_u" 1>&2; return 1; fi; '
-        )
-    hdr_block = ""
-    if with_header:
-        # 仅兼容旧部署（未收口）的 X-Sy-Api-Authz 注入。收口模式下网关注入，跳过。
-        hdr_block = (
-            'if [ -n "$_u" ] && [ -n "$__SYT_HOST__" ] && [ -n "$SYT_API_AUTHZ" ]; then '
-            '_h="${_u#*://}"; _h="${_h%%/*}"; _h="${_h%%\\?*}"; _h="${_h%%#*}"; '
-            '_h="${_h##*@}"; _h="${_h%%:*}"; '
-            'case "$(printf "%s" "$_h" | tr "A-Z" "a-z")" in '
-            '"$__SYT_HOST__") '
-            'case " $* " in *"X-Sy-Api-Authz"*) :;; *) '
-            'set -- "$@" -H "X-Sy-Api-Authz: $SYT_API_AUTHZ";; '
-            'esac;; '
-            'esac; '
-            'fi; '
-        )
-    if not wl_block and not hdr_block and not rewrite_block:
-        return ""
-    body = (
-        '() { local _u _a _h; for _a in "$@"; do '
-        'case "$_a" in http://*|https://*) _u="$_a";; esac; done; '
-        + rewrite_block + wl_block + hdr_block +
-        'command {CMD} "$@"; };'
-    )
-    guard = "curl" + body.replace("{CMD}", "curl") + " wget" + body.replace("{CMD}", "wget")
-    return guard.rstrip(";")  # 末尾不带分号：由调用方按需拼接分隔符
-
-
-class SkillApiWhitelistMiddleware(AgentMiddleware):
-    """按子技能动态注入接口白名单环境变量 + shell 包装。
-
-    AgentMiddleware 协议钩子：实现 `awrap_tool_call`（异步版本），在 execute
-    工具真正执行前注入白名单。框架对工具调用走 astream/ainvoke 异步链路，故
-    只需实现异步钩子（与现有 TokenTrackingMiddleware/ToolResultTruncationMiddleware 一致）。
-    """
-
-    def __init__(self, sandbox_backend):
-        self._backend = sandbox_backend
-        # 注：不再缓存"已推送"标志。用户可在会话中删除 .wl/ 绕过白名单，
-        # 故改为每次 execute 前校验文件完整性、缺则重推（见 _ensure_sitecustomize）。
-
-    def _env_lookup(self):
-        """构造占位符查找器：先查主进程 os.environ，再查 sandbox env 字典。
-
-        SYT_BASE_URL / XINGHAN_BASE_URL / YEALINK_BASE_URL 等不在主进程 os.environ 里，
-        而是放在传给 sandbox backend 的 env 字典中（tools/config.py.build_sandbox_env 构造）。
-        MultiSandboxRouter/HTTPSandboxBackend 都暴露 `_env`，这里统一兜底取值。
-        """
-        sandbox_env = {}
-        b = self._backend
-        for attr in ("_env",):
-            v = getattr(b, attr, None)
-            if isinstance(v, dict):
-                sandbox_env.update(v)
-            else:
-                # RoutingBackend 等代理对象：尝试 default/local/remote 子 backend
-                pass
-        # 再尝试 default backend（MultiSandboxRouter._default._env）
-        default = getattr(b, "_default", None)
-        if default is not None:
-            v = getattr(default, "_env", None)
-            if isinstance(v, dict):
-                sandbox_env.update(v)
-
-        def lookup(var):
-            val = os.environ.get(var)
-            if val is None:
-                val = sandbox_env.get(var)
-            return val
-
-        return lookup
-
-    # ---- 懒加载:把注入脚本推进沙箱 workspace/.wl ----
-    async def _ensure_sitecustomize(self) -> bool:
-        """把 loader + 2 个 base64 payload 推到沙箱 workspace 内的 .wl 目录。
-
-        防篡改 + 自愈：每次 execute 前对 3 个文件算 sha256，与主进程源码算出的
-        预期 hash 比对。任一文件缺失/被改 → 全量重推 + chmod 555。
-        旧的 test -f 存在性校验挡不住「用户把 sitecustomize 改成空文件」，
-        sha256 内容校验才能挡。失败 fail-open（不阻塞业务）。
-        """
-        backend = self._backend
-        if backend is None:
-            return False
-        try:
-            expected = _expected_hashes()
-            # 一条命令取三个文件的 sha256（缺失则该行输出 MISSING），换行拼接返回。
-            files_quoted = " ".join(
-                shlex.quote(f) for f in _WL_FILES)
-            check_cmd = (
-                f'for f in {files_quoted}; do '
-                f'if [ -f "$SANDBOX_ROOT/$f" ]; then '
-                f'sha256sum "$SANDBOX_ROOT/$f" 2>/dev/null | cut -d" " -f1; '
-                f'else echo MISSING; fi; done'
-            )
-            try:
-                resp = await backend.aexecute(check_cmd)
-                actual_lines = (getattr(resp, "output", "") or "").strip().splitlines()
-            except Exception:
-                actual_lines = []
-
-            # 逐文件比对：长度/顺序与 _WL_FILES 对应
-            intact = (len(actual_lines) == len(_WL_FILES)
-                      and all(actual_lines[i] == expected[_WL_FILES[i]]
-                              for i in range(len(_WL_FILES))))
-
-            if intact:
-                return True  # 内容完整，无需重推
-
-            # 重推：loader 明文 + 2 个 payload
-            files = [
-                (".wl/sitecustomize.py", _LOADER_SRC),
-                (".wl/sitecustomize.payload", _build_payload("sitecustomize.py")),
-                (".wl/skill_wl_check.payload", _build_payload("skill_wl_check.py")),
-            ]
-            await backend.aupload_files(files)
-            # chmod -R 555：挡普通用户改/删（root 仍可绕，靠 sha256 自愈兜底）
-            try:
-                await backend.aexecute(f'chmod -R 555 "{_WL_DIR}"')
-            except Exception as _ce:
-                SYLogger.warning("[Whitelist] chmod .wl 555 失败(非致命): %s", _ce)
-            SYLogger.info("[Whitelist] 注入脚本已(重新)推送至沙箱 %s (sha256 校验触发)", _WL_DIR)
-            return True
-        except Exception as e:
-            SYLogger.error("[Whitelist] 推送 sitecustomize 失败(fail-open): %s", e)
-            return False
-
-    # ---- 顶级技能名提取 ----
-    def _extract_skill_name(self, command: str) -> Optional[str]:
-        m = _SKILL_TOP_RE.search(command)
-        if m:
-            return m.group(1)
-        return None
-
-    # ---- 主入口（AgentMiddleware 异步钩子）----
-    async def awrap_tool_call(
-        self,
-        request: ToolCallRequest,
-        handler,
-    ):
-        tc = request.tool_call
-        name = tc.get("name")
-        args = tc.get("args", {}) or {}
-
-        # ---- .wl 写拦截（短路 fail-closed，在任何业务逻辑之前）----
-        # 防 agent 经 write_file/edit_file/execute 篡改注入目录。参考 SkillWriteGuard。
-        if name in ("write_file", "edit_file"):
-            fp = args.get("file_path") if isinstance(args, dict) else ""
-            if _is_wl_path(fp):
-                return ToolMessage(content=_WL_DENIED_MSG, name=name,
-                                   tool_call_id=tc.get("id", ""), status="error")
-        elif name == "execute":
-            command = args.get("command", "") if isinstance(args, dict) else ""
-            if _command_writes_wl(command):
-                return ToolMessage(content=_WL_DENIED_MSG, name="execute",
-                                   tool_call_id=tc.get("id", ""), status="error")
-
-        if name != "execute":
-            return await handler(request)
-
-        command = args.get("command", "") if isinstance(args, dict) else ""
-        if not command:
-            return await handler(request)
-
-        # 技能命令判定（宽松）：任意 skills/.../ 前缀即算（含用户拷贝到非 system
-        # 目录的技能）。header 注入等对所有技能命令生效的能力以此为门控。
-        if not _SKILL_ANY_RE.search(command):
-            # 非技能命令 → 不注入任何前缀
-            return await handler(request)
-
-        # 白名单配置提取（限定三层后取第二段）
-        skill_name = self._extract_skill_name(command)
-        from sycommon.config.SkillApiWhitelistConfig import SkillApiWhitelistConfig
-        cfg = (SkillApiWhitelistConfig.from_config(skill_name)
-               if skill_name is not None else None)
-        whitelist_on = bool(cfg and cfg.enabled)
-
-        # 主进程解析占位符 ${VAR}（数据源：os.environ + sandbox env 字典）
-        env_lookup = self._env_lookup()
-        resolved = []
-        if whitelist_on:
-            for pat in cfg.allowlist:
-                if "${" in pat:
-                    expanded = _resolve_placeholders(pat, env_lookup)
-                    if expanded:
-                        resolved.append(expanded)
-                else:
-                    resolved.append(pat)
-
-        # header 注入所需：SYT_API_AUTHZ（缺则不注入）+ SYT_BASE_URL 的 host
-        syt_authz = env_lookup("SYT_API_AUTHZ")
-        header_on = bool(syt_authz and syt_authz.strip())
-        syt_host = ""
-        if header_on:
-            syt_base = env_lookup("SYT_BASE_URL") or ""
-            try:
-                syt_host = (urlparse(syt_base).hostname or "").lower()
-            except Exception:
-                syt_host = ""
-            header_on = bool(syt_host)
-
-        # 推送注入脚本（惰性，每后端实例一次）。
-        # 只要【白名单 或 header 注入】任一启用就要推 .wl（sitecustomize）。
-        if whitelist_on or header_on:
-            await self._ensure_sitecustomize()
-
-        # 组装命令前缀
-        prefix_parts: list[str] = []
-        if whitelist_on:
-            payload = json.dumps({"skill": skill_name, "allowlist": resolved},
-                                 ensure_ascii=False)
-            prefix_parts.append(f"export SKILL_API_WHITELIST={shlex.quote(payload)}")
-        if header_on:
-            prefix_parts.append(
-                f"export SYT_API_AUTHZ={shlex.quote(syt_authz)}")
-            prefix_parts.append(f'export __SYT_HOST__={shlex.quote(syt_host)}')
-        if whitelist_on or header_on:
-            # PYTHONPATH(shell 启动 python 时自动 import sitecustomize)
-            prefix_parts.append(f'export PYTHONPATH="{_WL_DIR}:$PYTHONPATH"')
-            guard = _build_shell_guard(with_whitelist=whitelist_on,
-                                       with_header=header_on)
-            if guard:
-                prefix_parts.append(guard)
-
-        if not prefix_parts:
-            return await handler(request)
-
-        # 每个 part 之间用 '; ' 分隔（而非空格）—— export 语句之间、函数定义与后续命令
-        # 之间都需要语句分隔符；末尾留一个 ';' 与原命令隔开。
-        prefix = "; ".join(prefix_parts) + "; "
-
-        new_command = prefix + command
-        new_args = {**args, "command": new_command} if isinstance(args, dict) else args
-        new_tc = {**tc, "args": new_args}
-        tags = []
-        if whitelist_on:
-            tags.append(f"白名单({len(resolved)}条)")
-        if header_on:
-            tags.append("Authz头注入")
-        SYLogger.info("[Whitelist] 技能 %s 注入: %s", skill_name or "<user>",
-                      "+".join(tags) if tags else "(空)")
-        return await handler(request.override(tool_call=new_tc))

sycommon/agent/middleware/skill_wl_check.py

@@ -1,123 +0,0 @@
-"""技能接口白名单：URL 匹配核心逻辑（被 sitecustomize 与 shell 包装层共用）。
-
-沙箱内运行。从环境变量 `SKILL_API_WHITELIST` 读取白名单 JSON：
-
-    {"skill": "<子技能名>", "allowlist": ["<完整URL或path前缀>", ...]}
-
-提供：
-  - match(url) -> bool        供 sitecustomize（Python 库 monkeypatch）内存调用
-  - main()                    CLI：`python3 -m skill_wl_check <url>`，exit 0=放行 / 1=拦截
-
-匹配规则（path 级前缀，带斜杠边界）：
-  - 完整 URL 条目：scheme/host 小写比较，port 规则未写则任意，path 前缀匹配
-  - 纯 path 前缀条目（无 host）：只比 path（匹配任意 host，谨慎用）
-  - /wf 匹配 /wf 与 /wf/...，不匹配 /wfcount（斜杠边界）
-  - query string 不参与匹配
-"""
-
-import json
-import os
-import sys
-from urllib.parse import urlparse
-
-_ENV = "SKILL_API_WHITELIST"
-
-
-def _load_allowlist() -> list[str]:
-    """从环境变量读白名单。无 env / 解析失败 → 空列表（sitecustomize 据此决定是否启用）。"""
-    raw = os.environ.get(_ENV, "")
-    if not raw:
-        return []
-    try:
-        data = json.loads(raw)
-        if isinstance(data, dict):
-            return [str(x) for x in data.get("allowlist", [])]
-        if isinstance(data, list):
-            return [str(x) for x in data]
-    except Exception:
-        pass
-    return []
-
-
-def _normalize(entry: str) -> tuple:
-    """把白名单条目规范化成 (scheme, host, port, path_prefix)。
-
-    - 'https://oa.syholdings.com/services/WorkflowService'
-        → ('https', 'oa.syholdings.com', None, '/services/WorkflowService')
-    - 'http://10.100.8.72:8888'
-        → ('http', '10.100.8.72', 8888, '')
-    - '/wf'  (纯 path 前缀，无 host)
-        → (None, None, None, '/wf')
-    """
-    entry = entry.strip().rstrip("/")
-    if entry.startswith(("http://", "https://")):
-        p = urlparse(entry)
-        path = (p.path or "").rstrip("/")
-        return (
-            (p.scheme or "").lower(),
-            (p.hostname or "").lower(),
-            p.port,
-            path,
-        )
-    # 纯 path 前缀（无 host）
-    if not entry.startswith("/"):
-        entry = "/" + entry
-    return (None, None, None, entry)
-
-
-def _compiled():
-    return [_normalize(e) for e in _load_allowlist()]
-
-
-def _is_allowed(url: str, rules=None) -> bool:
-    if rules is None:
-        rules = _compiled()
-    try:
-        p = urlparse(url if "://" in url else "http://" + str(url))
-    except Exception:
-        return False
-    req_scheme = (p.scheme or "").lower()
-    req_host = (p.hostname or "").lower()
-    req_port = p.port
-    req_path = (p.path or "").rstrip("/")
-    for (sch, host, port, pfx) in rules:
-        if pfx == "":
-            pfx_match = True  # 规则没带 path → 该 host 下任意 path 放行
-        elif req_path == pfx or req_path.startswith(pfx + "/"):
-            pfx_match = True
-        else:
-            pfx_match = False
-        if not pfx_match:
-            continue
-        if sch is None:
-            # 纯 path 前缀规则：只比 path（host 任意）
-            return True
-        if req_scheme != sch or req_host != host:
-            continue
-        if port is not None and req_port not in (None, port):
-            continue
-        return True
-    return False
-
-
-def match(url: str) -> bool:
-    """供 Python 库内存调用：URL 是否在白名单内。"""
-    return _is_allowed(url)
-
-
-def main(argv=None) -> int:
-    argv = list(sys.argv[1:] if argv is None else argv)
-    if not argv:
-        sys.stderr.write("[skill_wl_check] 用法: python3 -m skill_wl_check <url>\n")
-        return 2
-    url = argv[0]
-    if match(url):
-        return 0
-    sys.stderr.write(
-        "[SkillApiWhitelist] 拦截: URL 不在白名单内 (url=%s)。"
-        "请联系管理员修改 SkillApiWhitelist 配置。\n" % url)
-    return 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())

sycommon/config/SkillApiWhitelistConfig.py

@@ -1,87 +0,0 @@
-"""技能接口白名单配置模型。
-
-定义「单个顶级技能被允许访问的外部接口白名单」，配置来源是 Nacos 的
-`shengye-platform-digital-work` dataId 下的 `SkillApiWhitelist` 列表。
-
-配置粒度按顶级技能（5 个域：sy-oa-skill / sy-syt-skill / sy-eas-skill /
-sy-metting-skill / skill-creator），每个域的 allowlist 是其下所有子技能
-出网地址的并集。skill 字段取自 `skills/<顶级技能>/` 的第一段目录名：
-
-    SkillApiWhitelist:
-      - skill: sy-oa-skill              # 顶级技能名（skills/<顶级技能>/ 里的 <顶级技能>）
-        enabled: true
-        allowlist:
-          - "${OA_WORKFLOW_URL}"                    # BASE_URL 占位符，主进程解析成完整 URL
-          - "${SYT_BASE_URL}/wf"                    # 占位符 + path 后缀
-          - "https://oa.syholdings.com"             # 完整 URL
-          - "/wf"                                   # 纯 path 前缀（匹配任意 host，谨慎用）
-
-语义约定（务必在 Nacos 配置注释里写明）：
-  - 顶级技能【未出现】在配置里 → 不管控，全放行（向后兼容）
-  - enabled: false            → 全放行
-  - allowlist: []（空数组）   → 明确禁止该顶级技能任何外网请求（全拦截）
-
-代码侧用 `SkillApiWhitelistConfig.from_config(skill)` 按 skill 取单条，
-或 `list_from_config()` 取全部。
-"""
-
-from typing import Optional
-
-from pydantic import BaseModel, Field
-
-
-class SkillApiWhitelistConfig(BaseModel):
-    """单个子技能的接口白名单配置。"""
-
-    skill: str = Field(
-        description="顶级技能名，对应 skills/<顶级技能>/ 目录，"
-                    "如 'sy-oa-skill'、'sy-syt-skill'、'sy-eas-skill'、"
-                    "'sy-metting-skill'、'skill-creator'")
-    enabled: bool = Field(default=True, description="是否启用白名单管控；False 则全放行")
-    allowlist: list[str] = Field(
-        default_factory=list,
-        description=(
-            "白名单条目（字符串数组）。每条可以是：完整 URL（https://...）、"
-            "BASE_URL 占位符（${ENV_VAR} 或 ${ENV_VAR}/path）、纯 path 前缀（/wf）。"
-            "主进程加载时把 ${ENV_VAR} 解析成完整 URL，运行期做 path 级前缀匹配。"
-            "空数组 [] = 明确禁止该顶级技能任何外网请求。"
-        ))
-
-    @classmethod
-    def from_config(cls, skill: str) -> Optional["SkillApiWhitelistConfig"]:
-        """按 skill 名从 Nacos 配置取单个白名单配置。不存在返回 None。"""
-        for cfg in list_from_config():
-            if cfg.skill == skill:
-                return cfg
-        return None
-
-    @classmethod
-    def list_from_config(cls) -> list["SkillApiWhitelistConfig"]:
-        """从 Nacos 配置取全部已配置的顶级技能白名单。
-
-        配置读 `Config().config.get("SkillApiWhitelist", [])`——即
-        `shengye-platform-digital-work` dataId 下的 SkillApiWhitelist 列表
-        （需在 Config.set_attr 的 override_keys 里登记，否则读不到）。
-        """
-        from sycommon.config.Config import Config
-
-        raw_list = Config().config.get("SkillApiWhitelist", []) or []
-        result: list[SkillApiWhitelistConfig] = []
-        for item in raw_list:
-            try:
-                result.append(cls(**item))
-            except Exception as e:  # 单条配置错误不影响其它
-                import logging
-                logging.getLogger(__name__).warning(
-                    "Invalid SkillApiWhitelistConfig entry %s: %s", item, e)
-        return result
-
-    @classmethod
-    def list_enabled_from_config(cls) -> list["SkillApiWhitelistConfig"]:
-        """取全部 enabled=True 的配置。"""
-        return [c for c in cls.list_from_config() if c.enabled]
-
-
-def list_from_config() -> list[SkillApiWhitelistConfig]:
-    """模块级便捷函数，等价于 SkillApiWhitelistConfig.list_from_config()。"""
-    return SkillApiWhitelistConfig.list_from_config()