codebee 0.1.49 → 0.1.51

package/app/core/manager.py

@@ -6,6 +6,7 @@
 """
 from __future__ import annotations
 
+import hashlib
 import json
 import os
 import re
@@ -15,6 +16,7 @@ import signal
 import socket
 import subprocess
 import sys
+import tempfile
 import threading
 import time
 import webbrowser
@@ -46,6 +48,31 @@ def _expand(p):
     return os.path.abspath(os.path.expanduser(os.path.expandvars(p)))
 
 
+def _under(path, root):
+    try:
+        return os.path.commonpath([os.path.realpath(path), root]) == root
+    except ValueError:
+        return False
+
+
+def tmp_data_no_home_write():
+    """测试实例防毒闸：TUTTI_DATA 指向系统临时目录、且进程主目录仍是真实
+    主目录时，一切对真实 CLI 配置的写入都应拒绝。
+
+    一次性测试服务的 models.json 里全是 a.test/sk-test 夹具，忘设假 HOME 的
+    测试一旦触发 launch/自愈/autobind 同步，就会把夹具毒进真实
+    ~/.claude/settings.json（2026-09-22 实案：claude 步骤全体 ENOTFOUND，
+    下一次测试又覆盖回来，形成「越测越坏」循环）。已设假 HOME 的测试不受
+    影响——假 HOME 本身就在临时目录下。
+    """
+    td = (os.environ.get("TUTTI_DATA") or "").strip()
+    if not td:
+        return False
+    tmp = tempfile.gettempdir()
+    home = os.path.abspath(os.path.expanduser("~"))
+    return _under(td, tmp) and not _under(home, tmp)
+
+
 def _safe_config_path(raw):
     """展开并校验配置路径：必须在用户主目录内（防穿越）。"""
     if not raw:
@@ -165,21 +192,38 @@ def sweep_orphan_cli_processes():
 
 
 def detect_all(force=False):
-    """检测全部条目。检测（慢磁盘 IO）在锁外跑：shutil.which/isfile 在
-    Windows 上遇到断链的 PATH 项可能卡数秒，持锁会把所有并发请求堵死
-    （曾导致 SSE 多连接时服务假死）。等待方有界等待 30s 后拿旧结果。
-    """
+    """检测全部条目。快照用途（force=False）热路径永不等检测：缓存新鲜直接
+    返回；过期返回旧快照、同时把刷新踢到后台线程（stale-while-revalidate）。
+
+    检测是慢磁盘 IO：shutil.which/isfile 在 Windows 上遇到断链的 PATH 项
+    可能卡数秒。此前「领队请求自己跑检测、其余请求 ev.wait(30) 排队」，每
+    60s 缓存周期都有一个 /api/catalog、/api/state（含 SSE 推送）一起卡数秒
+    的窗口；前端无超时轮询把浏览器 6 连接池塞满后整个界面假死（2026-09-22
+    用户实测「左栏点不动、右栏不刷新」）。冷启动首轮与 force=True（显式
+    重载/安装回调）仍同步跑拿新鲜结果。"""
     with _LOCK:
         if not force and _STATE["detected"] and time.time() - _STATE["detect_ts"] < 60:
             return _STATE["detected"]
         ev = _STATE["detect_ev"]
-        lead = ev is None  # 我是本次检测的执行者
+        lead = ev is None  # 我是本次刷新的发起人
         if lead:
             ev = _STATE["detect_ev"] = threading.Event()
+        cold = not _STATE["detected"]   # 冷启动首轮：还没有任何快照
     if not lead:
-        ev.wait(30)  # 检测完成或超时；两种情况都拿当前最新快照
+        if not cold:
+            return dict(_STATE["detected"])   # 过期快照也比卡请求强
+        ev.wait(30)  # 冷启动窗口内并发首查：等首轮检测完成（一次性）
         with _LOCK:
             return dict(_STATE["detected"])
+    if not cold and not force:
+        threading.Thread(target=_detect_refresh, args=(ev,),
+                         name="catalog-detect", daemon=True).start()
+        return dict(_STATE["detected"])
+    return _detect_refresh(ev)
+
+
+def _detect_refresh(ev):
+    """跑一轮全量检测并落快照；完成后置时间戳、清在飞标记、放行等待者。"""
     try:
         detected = {}
         for entry in catalog.load():
@@ -190,12 +234,12 @@ def detect_all(force=False):
         if detected:
             with _LOCK:
                 _STATE["detected"] = detected
+        return dict(_STATE["detected"])
     finally:
         with _LOCK:
             _STATE["detect_ts"] = time.time()
             _STATE["detect_ev"] = None
         ev.set()
-    return detected
 
 
 def _uwp_version(package_dir):
@@ -521,6 +565,9 @@ def read_model(entry):
 def write_model(entry, model):
     """写入默认模型（改动前自动备份 .bak）。支持 toml-line / toml-section /
     json / json-path / jsonc / yaml-line。"""
+    if tmp_data_no_home_write():
+        return {"ok": False,
+                "error": "测试数据目录（TUTTI_DATA 在临时目录）不写真实 CLI 配置，已拦截"}
     path = _config_path(entry)
     cfg = entry.get("config") or {}
     fmt = cfg.get("format")
@@ -750,6 +797,8 @@ def _sync_dsh_settings(entry, model, base_url):
     端点不同步不行——settings 优先级高于 env，密钥会发给旧端点；
     models 列表不同步不行——dsh web 的模型下拉只列它，缺条目就选不中。
     返回错误串或 None。"""
+    if tmp_data_no_home_write():
+        return "测试数据目录（TUTTI_DATA 在临时目录）不写真实 CLI 配置，已拦截"
     path = _config_path(entry)
     if not path:
         return "dsh 配置路径无效"
@@ -891,6 +940,8 @@ def _sync_codex_settings(entry, model, cp):
     _codex_provider_args 同构，但落 config 文件。返回错误串或 None。"""
     if _is_dead_endpoint(cp.get("base_url")):
         return "供应商端点 %r 是测试/保留地址，拒绝写入 config.toml" % (cp.get("base_url"),)
+    if tmp_data_no_home_write():
+        return "测试数据目录（TUTTI_DATA 在临时目录）不写真实 CLI 配置，已拦截"
     path = _config_path(entry)
     if not path:
         return "codex 配置路径无效"
@@ -1120,6 +1171,8 @@ def _sync_settings_env(path, updates, remove_keys=()):
     """把键值对写进目标 settings.json 的 env 段（claude/qwen 等同构：交互 TUI
     启动时把该段合并进进程环境）。只动 env 相关键，其余内容保留；坏 JSON 中止
     不覆盖；改动前 .bak。返回错误串或 None。path 必须已过主目录围栏校验。"""
+    if tmp_data_no_home_write():
+        return "测试数据目录（TUTTI_DATA 在临时目录）不写真实 CLI 配置，已拦截"
     try:
         if os.path.isfile(path):
             text = _read_text(path)
@@ -1213,6 +1266,8 @@ def _sync_opencode_settings(entry, model, prov):
     没 key）。写入所有已存在的候选文件（避免新文件遮蔽旧文件的读取优先级），
     全不存在时建 catalog 登记的那个。纯 JSON 走整体读改写；带注释的 JSONC 走
     文本级就地 patch（保留注释）。返回错误串或 None。"""
+    if tmp_data_no_home_write():
+        return "测试数据目录（TUTTI_DATA 在临时目录）不写真实 CLI 配置，已拦截"
     npm = "@ai-sdk/anthropic" if prov.get("protocol") == "anthropic" else "@ai-sdk/openai-compatible"
     base = prov.get("base_url") or ""
     if prov.get("protocol") == "anthropic" and not base.rstrip("/").endswith("/v1"):
@@ -1323,7 +1378,9 @@ def _sync_kimi_settings(entry, model, prov):
     yolo/defaultPermissionMode（camelCase）+ [providers.<id>]（type/apiKey/
     baseUrl）+ [models.<别名>]（provider/model/maxContextSize 必填）。无人值守
     要 yolo——否则工具调用逐个要审批，headless 全被拒。文本级托管块（标记注释
-    之间）幂等重写，用户自有内容保留在外。"""
+    之间）幂等重写，用户自有内容保留在外。返回错误串或 None。"""
+    if tmp_data_no_home_write():
+        return "测试数据目录（TUTTI_DATA 在临时目录）不写真实 CLI 配置，已拦截"
     import re as _re
     top_keys = ("defaultProvider", "defaultModel", "yolo", "defaultPermissionMode")
     targets = [os.path.abspath(os.path.expanduser("~/.kimi-code/config.toml"))]
@@ -1357,10 +1414,23 @@ def _sync_kimi_settings(entry, model, prov):
     return "；".join(errs) or None
 
 
+def _claude_sync_enabled():
+    """「直写 claude 配置」开关（settings 的 claude_config_sync，默认开）。
+    关闭 = ~/.claude/settings.json 归用户手动管理（cc-switch 等），打开/运行前
+    防线一律不落盘；编排步骤经 runner 一次性 --settings 注入绑定链，不受影响。"""
+    try:
+        from . import settings
+        return settings.load().get("claude_config_sync", True)
+    except Exception:
+        return True
+
+
 def sync_cli_config_now(agent_id):
     """运行期自愈：CLI 本体没配置（如 kimi「No model configured」）→ 立即把
     绑定注入其自家配置，换将/下轮即可用。返回给日志的备注（空=无事发生）。"""
     try:
+        if agent_id == "claude-code" and not _claude_sync_enabled():
+            return "按设置跳过直写 ~/.claude 配置（编排步骤经一次性 --settings 注入，不受影响）"
         from . import modelhub
         entry = next((a for a in catalog.load() if a.get("id") == agent_id), None)
         if not entry:
@@ -1397,6 +1467,8 @@ def _sync_agent_injection(entry, binding):
     spec = _AGENT_INJECTORS.get(entry["id"])
     if spec:
         protocols, injector = spec
+        if entry["id"] == "claude-code" and not _claude_sync_enabled():
+            return "按设置跳过直写 ~/.claude 配置（交互 TUI 保持手动管理；编排步骤经一次性 --settings 注入不受影响）"
         pick, note = modelhub.launch_pick(entry["id"], protocols)
         if pick:
             prov = pick["provider"]
@@ -1466,7 +1538,19 @@ def _sync_launch_model(entry, binding):
 # （draft-c12 等），CLI 身份在 kind 里；目录型智能体的 id 就是条目 id。
 _KIND_ENTRY = {"codex": "codex-cli", "claude": "claude-code",
                "qwen": "qwencode", "opencode": "opencode", "aider": "aider"}
-_RUNTIME_SYNC = {"fps": {}, "lock": threading.Lock()}
+_RUNTIME_SYNC = {"fps": {}, "files": {}, "lock": threading.Lock()}
+
+
+def _runtime_cfg_hash(entry):
+    """CLI 自家配置文件的内容指纹；文件不存在返回 None。"""
+    try:
+        p = _safe_config_path((entry.get("config") or {}).get("path"))
+        if p and os.path.isfile(p):
+            with open(p, "rb") as fh:
+                return hashlib.sha256(fh.read()).hexdigest()
+    except Exception:
+        pass
+    return None
 
 
 def sync_runtime_config(agent):
@@ -1509,10 +1593,16 @@ def sync_runtime_config(agent):
         fp = (model, repr(sorted(env.items())),
               repr(binding.get("codex_provider") or "")[:300])
         with _RUNTIME_SYNC["lock"]:
-            if _RUNTIME_SYNC["fps"].get(entry["id"]) == fp:
+            if (_RUNTIME_SYNC["fps"].get(entry["id"]) == fp
+                    and _RUNTIME_SYNC["files"].get(entry["id"]) == _runtime_cfg_hash(entry)):
                 return
+            # 绑定没变≠文件没变：指纹命中但文件被外部改写（测试毒写/手工编辑
+            # 托管段）时必须按绑定重写——2026-09-22 kimi 实案：测试夹具毒入
+            # ~/.kimi-code/config.toml（x.example 不可解析），换将步骤因指纹
+            # 命中跳过重写，kimi 带毒配置静默退出码 1
             _sync_launch_model(entry, binding)
             _RUNTIME_SYNC["fps"][entry["id"]] = fp
+            _RUNTIME_SYNC["files"][entry["id"]] = _runtime_cfg_hash(entry)
     except Exception:
         pass
 

package/app/core/market.py

@@ -290,8 +290,34 @@ def install_files(pack_id, name, files, extra=None):
                 record.update(extra)
             installed[pack_id] = record
         _save_registry(reg)
+    # 装后冒烟验证（SkillForge 证据驱动借鉴）：装完重新走 skills 的解析链，
+    # 证明该包能被加载、名字对得上、正文非空——写盘成功 ≠ 技能可用，
+    # frontmatter 缺失/正文为空都能在这里当场暴露，而不是下次任务注入时静默丢失。
+    smoke = ""
+    try:
+        with skills._LOCK:
+            skills._user_pack_cache.clear()
+            skills._user_dir_mtime["ts"] = 0.0
+            skills._user_dir_mtime["ids"] = None
+        up = next((p for p in skills.user_packs()
+                   if str(p.get("file") or "").replace("\\", "/").endswith("/" + target)), None)
+        if up is None:
+            smoke = "装后冒烟未找到已装包（解析失败？）"
+        elif (up.get("name") or "").strip() != name.strip():
+            smoke = "装后冒烟名字不符：%s ≠ %s" % (up.get("name"), name)
+        elif not str(up.get("body") or "").strip():
+            smoke = "装后冒烟正文为空"
+        else:
+            smoke = "ok:%d字" % len(str(up.get("body") or ""))
+    except Exception as e:
+        smoke = "装后冒烟异常: %s" % str(e)[:120]
+    with _LOCK:
+        reg = _load_registry()
+        if pack_id in (reg.get("installed") or {}):
+            reg["installed"][pack_id]["smoke"] = smoke
+            _save_registry(reg)
     return {"ok": True, "id": pack_id, "name": name, "file": target,
-            "already": already, "scan": scan_note}, None
+            "already": already, "scan": scan_note, "smoke": smoke}, None
 
 
 def remove(pack_id):

package/app/core/modelhub.py

@@ -448,6 +448,30 @@ def _drop_model_refs(data, prov, name):
             _sync_chain_refs(b)
 
 
+def _prune_binding_chains(data, prov_ids=(), pairs=()):
+    """停用即出调度：把指向已停用供应商/模型的条目从所有绑定链里剔除。
+
+    与删除的清引用（_drop_model_refs / providers_op delete）不同，停用可逆，
+    只摘链上死条目，不动主供应商 provider_id 与厂商默认模型——重新启用后
+    原样恢复。链上剔除不回填：调度页所见即所绑，不靠运行时降级默默跳过
+    占位死条目（2026-09-22 用户拍板：禁用就直接去掉，自动就行）。
+    """
+    ids = {i for i in (prov_ids or ()) if i}
+    prs = {(p, m) for p, m in (pairs or ()) if p and m}
+    if not ids and not prs:
+        return
+    for b in (data.get("bindings") or {}).values():
+        chain = b.get("chain")
+        if not chain:
+            continue
+        kept = [c for c in chain
+                if (c.get("provider_id") or "") not in ids
+                and (c.get("provider_id") or "", c.get("model") or "") not in prs]
+        if len(kept) != len(chain):
+            b["chain"] = kept
+            _sync_chain_refs(b)
+
+
 _MODEL_OPS = ("enable", "disable", "delete", "restore")
 
 
@@ -475,6 +499,7 @@ def _apply_model_op(data, prov, models, name, op):
         if not target.get("enabled", True):
             return False, ""
         target["enabled"] = False
+        _prune_binding_chains(data, pairs=[(prov.get("id"), name)])
     elif op == "delete":
         if target.get("hidden"):
             return False, ""
@@ -494,6 +519,8 @@ def model_ops(provider_id, names, op):
 
     先整体校验再落盘：任一名不存在、或 enable/disable 选中了已删除的模型，
     整个请求都不生效，避免只改一半。全部改动合并为一次写盘。
+    disable 即出调度：命中的 (供应商, 模型) 条目自动从所有绑定链剔除，
+    不回填；delete 走 _drop_model_refs 连默认模型引用一起清。
     restore 与可见模型混选时，可见项直接跳过（不算失败），便于「恢复所选」。
     """
     names = list(dict.fromkeys(n for n in (names or []) if n))
@@ -656,9 +683,13 @@ def provider_view():
 _KEY_COOLDOWN_S = 30 * 60      # 欠费类失败后的冷却时长
 MAX_PROVIDER_KEYS = 8          # 单厂商 KEY 上限
 MAX_CHAIN_ATTEMPTS = 8         # 链展开后的尝试上限（模型 × KEY）
-# 欠费/配额类失败：换 KEY 有意义（同厂商另一账号还能用），与瞬态网络错误分开记
+# 欠费/配额/限流类失败：换 KEY 有意义（同厂商另一账号=另一份额度与并发桶），
+# 与瞬态网络错误分开记。429 限流文案一并纳入——只记错不冷却会让每个新步骤都
+# 从超限的首选 KEY 重新烧起（2026-09-22 首选超限不切备用实案）。
 _QUOTA_HINTS = ("insufficient", "quota", "balance", "credit", "billing", "arrears",
-                "payment required", "402", "欠费", "余额", "额度", "exceeded")
+                "payment required", "402", "欠费", "余额", "额度", "exceeded",
+                "too many requests", "rate limit", "rate_limit", "http 429",
+                "并发", "超过限")
 
 
 def _quota_error(err):
@@ -938,8 +969,9 @@ def upsert_provider(entry):
 def providers_op(ids, op):
     """批量供应商操作（enable | disable | delete | duplicate）。返回 (改动数, 错误)。
 
-    停用只影响 Tutti 编排时的运行时解析（resolve_binding 返回空 → 回落 CLI 默认），
-    不清除配置，也不影响绑定引用，随时可再启用。
+    停用即出调度：绑定链里它的条目自动剔除（_prune_binding_chains），配置与
+    模型列表保留，随时可再启用；已剔除的链条目不回填。运行时解析本来就会
+    跳过停用供应商，这里把落盘链一并清掉，调度页所见即所绑。
     duplicate 复制一条（同地址同密钥的第二个账号/新网关），副本不带绑定引用。
     """
     ids = list(dict.fromkeys(i for i in (ids or []) if i))
@@ -998,6 +1030,8 @@ def providers_op(ids, op):
                     p["enabled"] = want
                     changed += 1
             if changed:
+                if not want:
+                    _prune_binding_chains(data, prov_ids=ids)
                 # 启用置顶：本次选中的启用者排最前，其余启用跟随，停用的殿后；
                 # 排序稳定，各块内部保持原有顺序。落盘重排，列表页看到的就是它。
                 sel = set(ids)
@@ -2298,11 +2332,13 @@ def resolve_binding(agent_kind_or_id, difficulty="default"):
         entries.append(_chain_entry_env(prov, model, target=agent_kind_or_id,
                                         endpoint=ep, key=kk["key"],
                                         key_id=kk.get("id") or "", provider_id=pid))
+    mk = (chain_keys or [{}])[0]   # 回退模型沿用首选可用 KEY：失败也要能记账冷却
     for n in fallbacks:
         if len(entries) >= MAX_CHAIN_ATTEMPTS:
             break
         entries.append(_chain_entry_env(prov, n, target=agent_kind_or_id,
-                                        endpoint=ep, provider_id=pid))
+                                        endpoint=ep, key=mk.get("key") or "",
+                                        key_id=mk.get("id") or "", provider_id=pid))
     head = entries[0]
     out = {"model": model, "env": head["env"], "provider": prov,
            "model_fallbacks": fallbacks,
@@ -2406,6 +2442,18 @@ def launch_pick(agent_id, protocols):
     protocols = tuple(p for p in (protocols or ()) if p)
     b = bindings().get(agent_id) or {}
     chain = _binding_chain(b)
+    if not chain and str(b.get("provider_id") or "").strip():
+        # 只锁定了供应商、没排链也没选模型的绑定：与 resolve_binding 的无链分支
+        # 同语义补一条，打开前才有凭据可注入。否则这类绑定永远「未指定供应商」，
+        # CLI 自家配置里的残留（a.test 占位案）等不到自愈覆盖——2026-09-22
+        # claude ENOTFOUND 四连败实测，settings.json 毒端点靠它长期存活。
+        _pid = str(b.get("provider_id")).strip()
+        _prov = {p.get("id"): p for p in providers()}.get(_pid)
+        _model = str(b.get("model") or "").strip()
+        if _prov and not _model:
+            _names = [m["name"] for m in _enabled_models(_prov)]
+            _model = _prov.get("model") or (_names[0] if _names else "")
+        chain = [{"provider_id": _pid, "model": _model}]
     provs = {p.get("id"): p for p in providers()}
     disabled, mismatch = [], False
     for item in chain: