codebee 0.1.17 → 0.1.19

package/app/core/selfupdate.py

@@ -18,9 +18,9 @@ SSE 可看进度）。npm 替换的是包目录文件，当前进程已加载进
 """
 from __future__ import annotations
 
-import json
-import logging
-import os
+import json
+import logging
+import os
 import re
 import socket
 import subprocess
@@ -29,11 +29,11 @@ import threading
 import time
 from pathlib import Path
 
-from . import paths, runner
-
-log = logging.getLogger(__name__)
-
-_PKG_NAME = "codebee"   # npm 发布名；必须与 package.json 的 name 一致（单测断言）
+from . import paths, runner
+
+log = logging.getLogger(__name__)
+
+_PKG_NAME = "codebee"   # npm 发布名；必须与 package.json 的 name 一致（单测断言）
 _UPDATE_TTL = 600   # 查新结果缓存（秒）
 _LOCK = threading.Lock()
 _CHECK_CACHE = {"ts": 0.0, "result": None}
@@ -161,46 +161,88 @@ def check(force=False):
     return out
 
 
-def apply_upgrade():
+def apply_upgrade():
     """发起升级：建 mgmt run 异步跑 npm install -g @latest。返回 {run_id} 或 {error}。"""
     if install_mode() != "npm":
         return {"error": "当前安装方式不支持自动升级（见版本页说明）"}
     from . import store, jobs
-    try:
-        run = store.create_run(
-            "mgmt", "升级 CodeBee 本体（npm install -g %s@latest）" % _PKG_NAME,
-            entry_id="__self__", op="selfupgrade")
-    except Exception:
-        log.exception("selfupdate: 创建升级运行记录失败")
-        return {"error": "升级任务创建失败，请稍后重试"}
-    try:
-        jobs.enqueue({"kind": "selfupgrade", "run_id": run["id"]})
-    except Exception:
-        # The run is already durable when enqueue fails. Close it explicitly so
-        # the upgrade panel cannot remain in a misleading queued state.
-        log.exception("selfupdate: 升级任务入队失败 run=%s", run["id"])
-        try:
-            store.update_run(run["id"], status="failed",
-                             error="升级任务入队失败，请稍后重试",
-                             ended_at=time.strftime("%Y-%m-%d %H:%M:%S"))
-        except Exception:
-            log.exception("selfupdate: 升级运行失败收口失败 run=%s", run["id"])
-        return {"error": "升级任务入队失败，请稍后重试", "run_id": run["id"]}
-    return {"run_id": run["id"]}
+    try:
+        run = store.create_run(
+            "mgmt", "升级 CodeBee 本体（npm install -g %s@latest）" % _PKG_NAME,
+            entry_id="__self__", op="selfupgrade")
+    except Exception:
+        log.exception("selfupdate: 创建升级运行记录失败")
+        return {"error": "升级任务创建失败，请稍后重试"}
+    try:
+        jobs.enqueue({"kind": "selfupgrade", "run_id": run["id"]})
+    except Exception:
+        # The run is already durable when enqueue fails. Close it explicitly so
+        # the upgrade panel cannot remain in a misleading queued state.
+        log.exception("selfupdate: 升级任务入队失败 run=%s", run["id"])
+        try:
+            store.update_run(run["id"], status="failed",
+                             error="升级任务入队失败，请稍后重试",
+                             ended_at=time.strftime("%Y-%m-%d %H:%M:%S"))
+        except Exception:
+            log.exception("selfupdate: 升级运行失败收口失败 run=%s", run["id"])
+        return {"error": "升级任务入队失败，请稍后重试", "run_id": run["id"]}
+    return {"run_id": run["id"]}
+
+
+_LOCKED_RE = re.compile(r"\b(EBUSY|EPERM)\b")
+_RETRY_DELAYS = (5, 15)   # 目录被占用时自动重试前的等待秒数（暂时性占用多在此窗口内释放）
+
+
+def _locked_error(res):
+    """npm 失败输出是否为「包目录被占用」类（EBUSY/EPERM）——值得等一等重试。"""
+    blob = ((res or {}).get("stderr") or "") + ((res or {}).get("stdout") or "")
+    return bool(_LOCKED_RE.search(blob[-4000:]))
+
+
+def _log_note(log_path, text):
+    """向步骤日志追加一行进度说明（run_process 以 append 模式写同一文件）。"""
+    if not log_path:
+        return
+    try:
+        with open(log_path, "ab") as fh:
+            fh.write(("\n===== %s =====\n" % text).encode("utf-8", "replace"))
+    except Exception:
+        pass
 
 
 def run_upgrade(run_id, log_path):
-    """worker 线程里执行升级命令（run/step 生命周期由 jobs 层管）。"""
-    res = runner.run_process(
-        argv=_npm_argv("install", "-g", _PKG_NAME + "@latest"),
-        # Windows 上 npm 换版本靠把包目录整体改名（codebee → .codebee-xxx）；
-        # cwd 若落在本包内，目录被自身进程占用，rename 必报 EBUSY——钉在包外
-        cwd=str(Path.home()), timeout=900, log_path=log_path)
+    """worker 线程里执行升级命令（run/step 生命周期由 jobs 层管）。
+
+    包目录被其他进程占用（EBUSY/EPERM：打开包目录的资源管理器/终端窗口、
+    杀毒或索引扫描）是升级失败的最常见原因，且多为暂时性——自动重试
+    _RETRY_DELAYS 轮，仍败则给人话结论（原始 npm 输出在步骤日志里可查）。"""
+    res = {}
+    for attempt, delay in enumerate((0,) + _RETRY_DELAYS):
+        if delay:
+            _log_note(log_path, "目录被占用（EBUSY/EPERM），%d 秒后自动重试（第 %d/%d 次）"
+                      % (delay, attempt, len(_RETRY_DELAYS)))
+            time.sleep(delay)
+        res = runner.run_process(
+            argv=_npm_argv("install", "-g", _PKG_NAME + "@latest"),
+            # Windows 上 npm 换版本靠把包目录整体改名（codebee → .codebee-xxx）；
+            # cwd 若落在本包内，目录被自身进程占用，rename 必报 EBUSY——钉在包外
+            cwd=str(Path.home()), timeout=900, log_path=log_path)
+        if res["ok"] or not _locked_error(res):
+            break
     if res["ok"]:
         with _LOCK:  # 装完即过期查新缓存，重启后自然拿到新版本
             _CHECK_CACHE["result"] = None
-    return {"ok": res["ok"], "exit_code": res["exit_code"],
-            "error": "" if res["ok"] else (res["stderr"][-800:] or "退出码 %s" % res["exit_code"])}
+        return {"ok": True, "exit_code": res["exit_code"], "error": ""}
+    stderr = res["stderr"] or ""
+    if _locked_error(res):
+        err = ("升级失败：codebee 安装目录被其他程序占用（已自动重试 %d 次未恢复）。"
+               "常见占用：打开包目录的资源管理器窗口/终端、杀毒或索引扫描。"
+               "请关闭相关窗口后回版本页重试；仍不行可退出 CodeBee 后手动执行 "
+               "npm install -g %s@latest。" % (len(_RETRY_DELAYS), _PKG_NAME))
+    else:
+        # npm 的进度条/颜色转义与中文 Windows 的 GBK 输出都进过这里，先洗再用
+        err = runner.clean_cli_text(stderr)[-800:] or "退出码 %s" % res["exit_code"]
+    return {"ok": False, "exit_code": res["exit_code"], "error": err}
 
 
 def _port_free(port):

package/app/core/settings.py

@@ -16,9 +16,19 @@ _FILE = paths.DATA_DIR / "settings.json"
 # 「导出诊断包」是用户手动操作不受此开关限制）
 # publish_daily_cap / publish_fail_streak：自动发布护栏——每任务每平台每日
 # 成功发章上限、平台连续失败几次后暂停自动发布（publish/auto.py 读取）
+# pet_enabled / pet_mode：桌面蜜蜂（app/pet.py）开关与显示模式。关闭后看护线程
+# 不再拉起、在岗蜜蜂轮询到 false 自行退出；mode=always 常驻，tasks_only 仅任务
+# 运行时出现（空闲 90s 隐身）。
+# cleanup_enabled / cleanup_retention_days：每日垃圾清理（core/cleanup.py）——
+# 运行过程日志/发布截图/bak 残留等超期自动清理；retention 为保留天数。
 DEFAULTS = {"max_concurrent_jobs": 6, "default_workdir": "", "hooks_token": "",
             "telemetry_errors": True, "publish_daily_cap": 10,
-            "publish_fail_streak": 3, "notify_webhook": "", "notify_base_url": ""}
+            "publish_fail_streak": 3, "notify_webhook": "", "notify_base_url": "",
+            "pet_enabled": True, "pet_mode": "always", "pet_skin": "plush",
+            "cleanup_enabled": True, "cleanup_retention_days": 14}
+# 桌宠形象白名单（与 app/pet.py 的 SKINS 对齐；这里不 import pet 模块，避免
+# core 反向依赖 app 根目录脚本）
+PET_SKINS = ("plush", "robot")
 # 并发上限 12：worker 只是拉起 CLI 子进程的调度位，跨任务无共享资源；
 # 同任务单飞守卫在 jobs 层。默认 6 对齐「多任务并行不排队」的使用预期。
 MIN_WORKERS, MAX_WORKERS = 1, 12
@@ -103,6 +113,27 @@ def save(patch):
             cur["notify_webhook"] = str(patch.get("notify_webhook") or "").strip()[:300]
         if "notify_base_url" in patch:
             cur["notify_base_url"] = str(patch.get("notify_base_url") or "").strip()[:200]
+        if "pet_enabled" in patch:
+            cur["pet_enabled"] = bool(patch.get("pet_enabled"))
+        if "pet_mode" in patch:
+            pm = str(patch.get("pet_mode") or "").strip()
+            if pm not in ("always", "tasks_only"):
+                return cur, "pet_mode 只能是 always 或 tasks_only"
+            cur["pet_mode"] = pm
+        if "pet_skin" in patch:
+            ps = str(patch.get("pet_skin") or "").strip()
+            if ps not in PET_SKINS:
+                return cur, "pet_skin 只能是 %s 之一" % "/".join(PET_SKINS)
+            cur["pet_skin"] = ps
+        if "cleanup_enabled" in patch:
+            cur["cleanup_enabled"] = bool(patch.get("cleanup_enabled"))
+        if "cleanup_retention_days" in patch:
+            try:
+                cur["cleanup_retention_days"] = int(patch.get("cleanup_retention_days"))
+            except (TypeError, ValueError):
+                return cur, "cleanup_retention_days 必须是整数"
+            if not 1 <= cur["cleanup_retention_days"] <= 365:
+                return cur, "cleanup_retention_days 取值 1-365"
         _FILE.parent.mkdir(parents=True, exist_ok=True)
         tmp = _FILE.with_suffix(".tmp")
         tmp.write_text(json.dumps(cur, ensure_ascii=False, indent=2), encoding="utf-8")

package/app/core/skill_scan.py

@@ -0,0 +1,86 @@
+# -*- coding: utf-8 -*-
+"""skill 装前危险模式扫描（借鉴 NVIDIA SkillSpector 的静态扫描思路）。
+
+研究数据（SkillSpector 对 31,132 个 skill 的分析）：26.1% 含漏洞、5.2% 疑似
+恶意。我们在「白名单闸门 + SSRF 防护 + 剥离式检查」之外补一道**内容静态扫描**：
+装前扫 skill 正文里的危险模式，给风险提示——提示不是拦阻（用户仍可装），
+但危险必须被看见。
+
+纯内存函数：输入是文本，输出是发现列表，无网络无落盘。
+"""
+from __future__ import annotations
+
+import re
+
+# 危险模式（静态正则；命中即在装前提示行展示）
+# —— 每条：(模式, 类别, 中文说明)
+_PATTERNS = [
+    # 代码执行
+    (r"\beval\s*\(", "代码执行", "动态 eval 执行任意代码"),
+    (r"\bexec\s*\(", "代码执行", "exec 执行任意代码"),
+    (r"subprocess|os\.system|Popen", "代码执行", "起子进程执行命令"),
+    # 数据外发
+    (r"https?://(?!api\.|docs\.|github\.com|raw\.githubusercontent)[a-z0-9.-]+/(upload|collect|track|ingest|webhook|callback)",
+     "数据外发", "向非常规端点上传/回调数据"),
+    (r"requests\.post|urllib\.request|fetch\s*\(", "网络请求", "发起网络请求（确认目标可信）"),
+    # 敏感信息读取
+    (r"os\.environ|process\.env|getenv", "环境读取", "读取环境变量（可能带走密钥）"),
+    (r"\.ssh/|\.aws/|\.npmrc|\.gitconfig|credentials|\.env\b", "敏感文件", "触碰凭据/密钥文件路径"),
+    (r"keychain|credential manager|dpapi", "敏感文件", "访问系统凭据库"),
+    # 提示注入特征
+    (r"(ignore|disregard|forget).{0,30}(previous|above|prior|all).{0,20}(instruction|prompt|rule)",
+     "提示注入", "指令覆盖话术（试图无视既有规则）"),
+    (r"system prompt|开发者指令|隐藏指令", "提示注入", "提及系统提示词/隐藏指令"),
+    (r"do not (tell|reveal|mention).{0,20}(user|human|player)", "提示注入", "要求对用户隐瞒行为"),
+    # 反拒答/越权
+    (r"(you (are|must) (now|act as)|从此你是|你现在必须)", "越权人格", "试图重设助手人格"),
+    (r"exfiltrat|渗透|后门|backdoor|keylog", "可疑意图", "包含可疑渗透/后门词汇"),
+]
+
+_COMPILED = [(re.compile(p, re.I), cat, desc) for p, cat, desc in _PATTERNS]
+
+
+def scan_text(text, max_findings=12):
+    """扫描一段 skill 文本。返回 [{category, detail, line}]；空列表=干净。
+
+    line 是 1 起的行号（供装前提示定位）。同一类别只报首个命中
+    （提示行是给人看的，重复刷屏没有信息量）。"""
+    findings, seen_cats = [], set()
+    if not text:
+        return []
+    lines = text.splitlines()
+    for rx, cat, desc in _COMPILED:
+        if cat in seen_cats:
+            continue
+        for i, ln in enumerate(lines, 1):
+            if rx.search(ln):
+                findings.append({"category": cat, "detail": desc, "line": i})
+                seen_cats.add(cat)
+                break
+        if len(findings) >= max_findings:
+            break
+    return findings
+
+
+def risk_label(findings):
+    """发现列表 → 风险标签（装前提示行用）。
+
+    高危（代码执行/敏感文件/可疑意图）任一命中 = 高风险；否则有发现 = 注意；
+    空 = 干净。"""
+    if not findings:
+        return ""
+    cats = {f["category"] for f in findings}
+    if cats & {"代码执行", "敏感文件", "可疑意图", "数据外发"}:
+        return "⚠ 高风险"
+    return "△ 注意"
+
+
+def scan_summary(text):
+    """一步到位：扫描+汇总成一行提示文案（空=干净返回空串）。"""
+    fs = scan_text(text)
+    if not fs:
+        return ""
+    label = risk_label(fs)
+    top = "、".join("%s(行%d)" % (f["category"], f["line"]) for f in fs[:4])
+    more = " 等 %d 项" % len(fs) if len(fs) > 4 else ""
+    return "%s：%s%s" % (label, top, more)

package/app/core/store.py

@@ -410,6 +410,28 @@ def migrate_task_workdirs(old_root, new_root):
     return moved, skipped
 
 
+def _sanitize_run_text(r):
+    """就地清洗 run 与各步骤里的 CLI 文本字段（错误串/摘要/输出）。
+
+    写入侧与读盘侧共用：runner 已经把 ANSI/覆写/乱码墙洗过一遍，这里兜住
+    「错误串是我们自己拼的」「历史数据是旧版本写的」两条漏网路径。只动字符串
+    值，不碰结构——清洗是幂等的，重复调用无副作用。"""
+    for k in ("error", "summary"):
+        v = r.get(k)
+        if isinstance(v, str) and v:
+            r[k] = runner.clean_cli_text(v)
+    for s in r.get("steps") or []:
+        if not isinstance(s, dict):
+            continue
+        for k in ("summary", "error"):
+            v = s.get(k)
+            if isinstance(v, str) and v:
+                s[k] = runner.clean_cli_text(v)
+        # output 是智能体正文：只剥 ANSI（同 finish_step 的口径）
+        if isinstance(s.get("output"), str) and s["output"]:
+            s["output"] = runner.strip_ansi(s["output"])
+
+
 def load_all():
     with LOCK:
         for p in paths.TASKS_DIR.glob("*.json"):
@@ -422,6 +444,10 @@ def load_all():
             try:
                 r = json.loads(p.read_text(encoding="utf-8"))
                 r.pop("cancel_event", None)
+                # 存量清洗：早期版本把 CLI 的 ANSI 转义/控制字符原样写进了摘要与
+                # 错误串（`[91m[1mError:`、U+FFFD 乱码墙），读盘时统一洗一遍——
+                # 老运行不必等重跑才干净（2026-09-20「咋还有乱码」实测）
+                _sanitize_run_text(r)
                 # 队列不跨进程持久化：磁盘上仍是 queued/running 的运行必是上次进程中断的残骸
                 if r.get("status") in ("queued", "running"):
                     r["status"] = "failed"
@@ -620,6 +646,11 @@ def update_run(run_id, expected_status=None, **fields):
             return None
         if expected_status is not None and run.get("status") != expected_status:
             return None
+        for k in ("error", "summary"):
+            if isinstance(fields.get(k), str):
+                # 错误串多是我们自己拼的 CLI 尾巴（含 ANSI/覆写/乱码墙）：
+                # 落内存前洗一遍，UI/台账读到的就是干净文本
+                fields[k] = runner.clean_cli_text(fields[k])
         run.update(fields)
         # 终态收尸：run 已结束却还挂 queued/running 的步骤统一落 cancelled，
         # 语义与 recover_orphaned_runs 的启动清扫对齐（那套清跨进程遗留，
@@ -1105,7 +1136,26 @@ def retry_task(task_id):
                                if s.get("status") == "done"
                                and (s.get("role") or "").startswith("draft-c")
                                and str(s.get("role")).split("c")[-1].isdigit()})
-                if done:
+                v_scores = (prev.get("verdict") or {}).get("chapter_scores") or []
+                # 重写未达标章：上一遍完整跑完但质量未过线（verdict.publishable
+                # =False）时，未过线章的成稿与分数都不进继承——流水线对缺继承
+                # 的章走正常起草+评审，等于只重写这几章；已过线章照常复用不烧
+                # token。大纲始终继承（全章未过线时 done 清空也继承），保住全书
+                # 结构——这正是「重写未达标章」按钮（前端 done+未达标态放行
+                # retry）区别于断点续跑的语义。
+                redo = set()
+                if (prev.get("verdict") or {}).get("publishable") is False:
+                    redo = {int(c["chapter"]) for c in v_scores
+                            if not c.get("passed") and c.get("chapter") is not None}
+                if redo:
+                    done = [n for n in done if n not in redo]
+                    v_scores = [c for c in v_scores if c.get("passed")]
+                if done or redo:
+                    if redo:
+                        scores = v_scores          # 未达标重写：只带已过线章的分数
+                    else:
+                        scores = ((prev.get("verdict") or {}).get("chapter_scores")
+                                  or prev.get("chapter_scores") or [])
                     run["inherit"] = {
                         "outline": outline,
                         "done_chapters": done,
@@ -1113,8 +1163,7 @@ def retry_task(task_id):
                         # failed/cancelled 的 run 没有 verdict，退回每章实时
                         # 落账的 chapter_scores——否则多轮失败恢复会把全部
                         # 已过线章节重新评审（实测一晚白烧数百万 token）
-                        "chapter_scores": ((prev.get("verdict") or {}).get("chapter_scores")
-                                           or prev.get("chapter_scores") or []),
+                        "chapter_scores": scores,
                     }
                     break
         task["status"] = "queued"
@@ -1333,7 +1382,9 @@ def finish_step(run_id, n, status, summary="", exit_code=None,
             if s["n"] == n:
                 s["status"] = status
                 s["ended_at"] = time.strftime("%H:%M:%S")
-                s["summary"] = summary
+                # 步骤摘要是 CLI 文本的汇聚点（失败时=错误尾巴，成功时=智能体结论）：
+                # 落盘前统一清洗，避免 ANSI/覆写/乱码墙进 UI 与报告
+                s["summary"] = runner.clean_cli_text(summary)
                 s["exit_code"] = exit_code
                 s["cost_usd"] = round(cost_usd, 4)
                 s["tokens"] = tokens
@@ -1342,7 +1393,9 @@ def finish_step(run_id, n, status, summary="", exit_code=None,
                 if duration_s is not None:
                     s["duration_s"] = round(duration_s, 1)
                 if output is not None:
-                    s["output"] = str(output)[:6000]
+                    # output 是智能体正文（对话气泡直读）：只剥 ANSI，不做噪声折叠
+                    # ——正文里的装饰性长串是作者写的，不能替它省略
+                    s["output"] = runner.strip_ansi(str(output))[:6000]
                 if followups:
                     s["followups"] = list(followups)[:3]
                 break
@@ -1497,9 +1550,10 @@ def read_step_log(run_id, rel_path, tail=paths.LOG_TAIL_CHARS, pretty=False):
             text = "...(已截断)...\n" + runner.tail_decoded(data, tail)
         else:
             text = runner.decode_output(data)
-        # 折叠遥测刷屏（时间戳不同的重复 WARN）；pretty 再把 codex JSONL
-        # 事件流翻译成【消息】【命令】等可读行，日志抽屉直读"蜂在干什么"
-        text = runner.collapse_dup_lines(text)
+        # 先洗终端噪声（ANSI/覆写/乱码墙），再折叠遥测刷屏（时间戳不同的重复
+        # WARN）；pretty 最后把 codex JSONL 事件流翻译成【消息】【命令】等可读行
+        # ——顺序不能反：乱码墙会挤掉折叠分组，翻译也会把 ANSI 当正文
+        text = runner.collapse_dup_lines(runner.clean_cli_text(text))
         if pretty:
             text = runner.pretty_cli_log(text)
         return text