codebee 0.1.6 → 0.1.8

package/app/core/runner.py

@@ -16,14 +16,18 @@ import json
 import os
 import re
 import shutil
+import signal
 import subprocess
+import tempfile
 import threading
 import time
 
 from .env_scrub import scrub_env
 from .error_codes import ErrorCode
 
-CREATE_NO_WINDOW = 0x08000000
+# 非 Windows 必须置 0：POSIX 的 Popen 对非零 creationflags 直接抛 ValueError，
+# 置 0 则两边通用（remote.py 同款守卫）。
+CREATE_NO_WINDOW = 0x08000000 if os.name == "nt" else 0
 DEFAULT_TIMEOUT = 1200  # 单步 20 分钟
 
 _BASH_CANDIDATES = [
@@ -35,6 +39,11 @@ _bash_cache = {"path": None, "done": False}
 
 
 def find_git_bash():
+    """Windows 专供：claude 原生 exe 找不到 bash 会拒绝启动，指给 Git Bash。
+    macOS/Linux 有系统 bash，claude 自会找到；强行设 CLAUDE_CODE_GIT_BASH_PATH
+    反而可能指错（/bin/bash 与 Git Bash 行为有差异），故非 Windows 一律 None。"""
+    if os.name != "nt":
+        return None
     if _bash_cache["done"]:
         return _bash_cache["path"]
     _bash_cache["done"] = True
@@ -81,6 +90,19 @@ def _npm_shim_bypass(argv):
 
 
 def _kill_tree(pid):
+    """杀整棵进程树。Windows 用 taskkill /T；POSIX 靠 spawn 时的
+    start_new_session（子进程自成一个进程组，pgid==pid）用 killpg 连孙带杀。"""
+    if os.name != "nt":
+        try:
+            os.killpg(pid, signal.SIGKILL)
+            return
+        except Exception:
+            pass
+        try:
+            os.kill(pid, signal.SIGKILL)
+        except Exception:
+            pass
+        return
     try:
         subprocess.run(
             ["taskkill", "/F", "/T", "/PID", str(pid)],
@@ -295,7 +317,8 @@ def run_process(argv=None, shell_cmd=None, stdin_text=None, cwd=None, env=None,
     返回 {ok, exit_code, stdout, stderr, duration, cancelled, timed_out, stalled}。
     """
     if shell_cmd:
-        argv = ["cmd", "/c", shell_cmd]
+        # shell 串的解析器随平台：重定向/引号语法两边通用，只是解释器不同
+        argv = ["cmd", "/c", shell_cmd] if os.name == "nt" else ["/bin/sh", "-c", shell_cmd]
     if argv is None:
         return {"ok": False, "exit_code": None, "stdout": "", "stderr": "argv 为空",
                 "duration": 0.0, "cancelled": False, "timed_out": False, "stalled": False}
@@ -327,7 +350,8 @@ def run_process(argv=None, shell_cmd=None, stdin_text=None, cwd=None, env=None,
                 [str(a) for a in argv], cwd=cwd, env=full_env,
                 stdin=subprocess.PIPE if stdin_text is not None else subprocess.DEVNULL,
                 stdout=subprocess.PIPE, stderr=subprocess.PIPE,
-                creationflags=CREATE_NO_WINDOW)
+                creationflags=CREATE_NO_WINDOW,
+                start_new_session=(os.name != "nt"))  # POSIX 需独立进程组供 killpg 杀树；Windows 忽略该参数
         except Exception as e:
             return {"ok": False, "exit_code": None, "stdout": "",
                     "stderr": "启动失败: %r" % e, "duration": 0.0,
@@ -676,12 +700,29 @@ def _codex_sandbox(readonly):
     return "danger-full-access"
 
 
+def _prompt_to_file(prompt, workdir):
+    """超长提示词落盘（工作目录优先，保证评审 CLI 沙箱内可读），返回绝对路径。"""
+    try:
+        d = workdir if workdir and os.path.isdir(workdir) else None
+        fd, path = tempfile.mkstemp(prefix="tutti_prompt_", suffix=".md", dir=d)
+        with os.fdopen(fd, "w", encoding="utf-8") as f:
+            f.write(prompt)
+        return path
+    except Exception:
+        return None
+
+
+_ARGV_PROMPT_SAFE = 20000   # 字符。Windows CreateProcess 命令行上限 32767，留路径/参数余量
+
+
 def _build_call(agent, kind, sid, readonly, model, prompt, images=None, workdir=None):
-    """构建一次 CLI 调用的 (argv, stdin_text, prompt)。model 可为 None=CLI 默认。
-    images 为图片附件绝对路径：codex 用 -i 原生附图；其余 kind 忽略（调用方已过滤）。"""
+    """构建一次 CLI 调用的 (argv, stdin_text, prompt, tmp_files)。model 可为 None=CLI 默认。
+    images 为图片附件绝对路径：codex 用 -i 原生附图；其余 kind 忽略（调用方已过滤）。
+    tmp_files：为绕开命令行长度限制落盘的指令临时文件，调用方用完（进程结束后）删除。"""
     env = {}
     argv = None
     stdin_text = None
+    tmp_files = []
     imgs = [str(p) for p in (images or []) if p]
     if kind == "codex":
         cp = agent.get("codex_provider")
@@ -766,7 +807,20 @@ def _build_call(agent, kind, sid, readonly, model, prompt, images=None, workdir=
         argv = _npm_shim_bypass(argv)
         if "{prompt}" not in tmpl:
             stdin_text = prompt  # 恢复模板不带 {prompt}：提示词走 stdin（mimo 实测支持）
-    return argv, stdin_text, prompt
+    # Windows CreateProcess 命令行上限 32767 字符：全局评审会把全书文本（约 6 万
+    # 字）嵌进 argv，直接 WinError 206 启动失败（2026-09-18 七猫甜宠案，kimi 实证）。
+    # 超长时落盘临时文件、参数位换成读文件指令——评审/作者 CLI 非交互模式均带
+    # 读文件工具（kimi 0.43 实测可读），读不到的调用输出不可解析，由评审全挂
+    # 防线兜底判失败，绝不静默降级。
+    if argv is not None and stdin_text is None and len(prompt) > _ARGV_PROMPT_SAFE \
+            and argv.count(prompt) == 1:
+        pf = _prompt_to_file(prompt, workdir)
+        if pf:
+            argv[argv.index(prompt)] = (
+                "[系统] 本次完整指令因命令行长度限制已写入文件：%s\n"
+                "请先用读文件工具完整读取该文件，然后把文件内容当作你的任务指令执行。" % pf)
+            tmp_files.append(pf)
+    return argv, stdin_text, prompt, tmp_files
 
 
 def _check_approval(agent):
@@ -876,13 +930,22 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
             # 链内条目未注入供应商时不能沿用上一条（可能是另一家厂商）的 -c 覆盖
             del eff_agent["codex_provider"]
         for attempt in range(2):  # claude 偶发空响应（0 token）自动重试一次
-            argv, stdin_text, prompt_eff = _build_call(eff_agent, kind, sid, readonly,
-                                                       att["model"], prompt,
-                                                       images=images if kind == "codex" else None,
-                                                       workdir=workdir)
-            res = run_process(argv=argv, stdin_text=stdin_text, cwd=workdir, env=env,
-                              timeout=timeout, cancel_event=cancel_event, log_path=log_path,
-                              stall_timeout=stall_t)
+            argv, stdin_text, prompt_eff, tmp_files = _build_call(
+                eff_agent, kind, sid, readonly,
+                att["model"], prompt,
+                images=images if kind == "codex" else None,
+                workdir=workdir)
+            try:
+                res = run_process(argv=argv, stdin_text=stdin_text, cwd=workdir, env=env,
+                                  timeout=timeout, cancel_event=cancel_event, log_path=log_path,
+                                  stall_timeout=stall_t)
+            finally:
+                # 超长指令临时文件：CLI 进程已结束（管道已收），即刻清场不污染工作目录
+                for tf in tmp_files:
+                    try:
+                        os.remove(tf)
+                    except OSError:
+                        pass
             out = {"ok": res["ok"], "text": "", "json": None, "cost_usd": 0.0,
                    "tokens": 0, "usage": None, "error": "", "error_code": "",
                    "sid": "", "raw": res, "kind": kind, "model": att["model"]}
@@ -996,6 +1059,44 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
     return out
 
 
+def _loads_lenient(text):
+    """容错 json.loads：修复字符串内未转义引号后再解析。
+
+    模型高频病：评审 note 里带英文直引号（"第5章"冷战三天"使用…"），
+    严格 JSON 被打碎。判据：字符串内遇到 `"` 时向后看第一个非空白字符，
+    是 , } ] : 视为结构性收尾引号，否则按字面引号转义。"""
+    out = []
+    i, n = 0, len(text)
+    in_str = False
+    while i < n:
+        c = text[i]
+        if in_str:
+            if c == "\\" and i + 1 < n:
+                out.append(text[i:i + 2])
+                i += 2
+                continue
+            if c == '"':
+                j = i + 1
+                while j < n and text[j] in " \t\r\n":
+                    j += 1
+                nxt = text[j] if j < n else ""
+                if nxt in ",}]:":
+                    in_str = False
+                    out.append(c)
+                else:
+                    out.append('\\"')
+                i += 1
+                continue
+            out.append(c)
+            i += 1
+            continue
+        if c == '"':
+            in_str = True
+        out.append(c)
+        i += 1
+    return json.loads("".join(out))
+
+
 def extract_json(text):
     """从模型回复中提取 JSON：直接解析 → ```json 围栏 → 平衡花括号扫描。"""
     if not text:
@@ -1011,6 +1112,10 @@ def extract_json(text):
             return json.loads(m.group(1))
         except Exception:
             pass
+        try:
+            return _loads_lenient(m.group(1))
+        except Exception:
+            pass
     start = text.find("{")
     while start != -1:
         depth = 0
@@ -1027,3 +1132,33 @@ def extract_json(text):
                         break
         start = text.find("{", start + 1)
     return None
+
+
+def as_scores(gj):
+    """评审解析第二道网：花括号兜底扫描会掉进第一个可平衡的子对象——
+    外层 JSON 病得重时返回的是「维度→分数」本体（无 scores 键），这里包回
+    评审形状，否则良评审被误判成「输出不可解析」（2026-09-18 七猫案：
+    kimi 正常出分却因内嵌引号整轮判评审全挂，连环白烧自动续跑）。"""
+    if isinstance(gj, dict) and not isinstance(gj.get("scores"), dict):
+        vals = {k: v for k, v in gj.items()
+                if isinstance(v, (int, float)) and not isinstance(v, bool)}
+        if vals and len(vals) == len(gj) and len(vals) >= 3:
+            return {"scores": vals, "issues": [], "summary": ""}
+    return gj if isinstance(gj, dict) else None
+
+
+def scores_from_prose(text, dims):
+    """评审解析第三道网：agentic CLI 有时把 JSON 写进文件、stdout 只留中文
+    总结（「情节 8 / 人物 8 / …」）。JSON 全灭后按维度名从正文提分；
+    至少命中 3 个维度才认（防普通行文里的巧合数字）。"""
+    if not text or not dims:
+        return {}
+    found = {}
+    for d in dims:
+        m = re.search(re.escape(d) + r"\s*[:：/是]?\s*([0-9]+(?:\.[0-9]+)?)", text)
+        if m:
+            try:
+                found[d] = float(m.group(1))
+            except (TypeError, ValueError):
+                pass
+    return found if len(found) >= 3 else {}

package/app/core/selfupdate.py

@@ -18,18 +18,22 @@ SSE 可看进度）。npm 替换的是包目录文件，当前进程已加载进
 """
 from __future__ import annotations
 
-import json
-import os
+import json
+import logging
+import os
 import re
 import socket
 import subprocess
 import sys
 import threading
 import time
+from pathlib import Path
 
-from . import paths, runner
-
-_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}
@@ -72,6 +76,13 @@ def _relnotes(readme):
     return m.group(1).strip() if m else ""
 
 
+def _npm_argv(*args):
+    """npm 命令 argv：Windows 的 npm 是 .cmd 垫片须经 cmd /c；POSIX 直接跑。"""
+    if os.name == "nt":
+        return ["cmd", "/c", "npm"] + list(args)
+    return ["npm"] + list(args)
+
+
 def _npm_meta():
     """npm view <pkg> --json；返回 (latest, relnotes, err)。
 
@@ -79,7 +90,7 @@ def _npm_meta():
     GitHub 连通性），展示「新版本更新内容」用。部分 npm 版本 --json 不带
     readme 字段，此时回退到 `npm view <pkg> readme` 纯文本再提取。"""
     r = runner.run_process(
-        argv=["cmd", "/c", "npm", "view", _PKG_NAME, "--json"], timeout=60)
+        argv=_npm_argv("view", _PKG_NAME, "--json"), timeout=60)
     if not r["ok"]:
         return "", "", (r["stderr"] or r["stdout"] or "")[-200:] or "npm 命令失败"
     ver, notes = "", ""
@@ -95,7 +106,7 @@ def _npm_meta():
         ver = m.group(0) if m else ""
     if ver and not notes:
         r2 = runner.run_process(
-            argv=["cmd", "/c", "npm", "view", _PKG_NAME, "readme"], timeout=60)
+            argv=_npm_argv("view", _PKG_NAME, "readme"), timeout=60)
         if r2["ok"]:
             notes = _relnotes(r2["stdout"] or "")
     return ver, notes, ("" if ver else "npm 输出无法解析")
@@ -150,22 +161,41 @@ 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
-    run = store.create_run("mgmt", "升级 CodeBee 本体（npm install -g %s@latest）" % _PKG_NAME,
-                           entry_id="__self__", op="selfupgrade")
-    jobs.enqueue({"kind": "selfupgrade", "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"]}
 
 
 def run_upgrade(run_id, log_path):
     """worker 线程里执行升级命令（run/step 生命周期由 jobs 层管）。"""
     res = runner.run_process(
-        argv=["cmd", "/c", "npm", "install", "-g", _PKG_NAME + "@latest"],
-        cwd=str(paths.ROOT), timeout=900, log_path=log_path)
+        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"]:
         with _LOCK:  # 装完即过期查新缓存，重启后自然拿到新版本
             _CHECK_CACHE["result"] = None
@@ -200,9 +230,10 @@ def relaunch(port):
     if port < 1 or port > 65535:
         return False
     subprocess.Popen(
-        [sys.executable, "main.py", "--port", str(port),
+        [sys.executable, str(paths.APP_DIR / "main.py"), "--port", str(port),
          "--wait-port", "--no-browser"],
-        cwd=str(paths.APP_DIR),
+        # 新实例 CWD 同样不得落在包内，否则下次升级 npm 改名包目录再撞 EBUSY
+        cwd=str(Path.home()),
         stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
         close_fds=True,
         creationflags=(0x00000008 | 0x00000200) if os.name == "nt" else 0)

package/app/core/settings.py

@@ -11,8 +11,11 @@ from . import paths
 _LOCK = threading.RLock()
 _FILE = paths.DATA_DIR / "settings.json"
 
-# default_workdir 为空表示未自定义，用 builtin_workdir() 回落
-DEFAULTS = {"max_concurrent_jobs": 3, "default_workdir": ""}
+# default_workdir 为空表示未自定义，用 builtin_workdir() 回落；
+# telemetry_errors：匿名错误回传开关（默认开；关掉后版本 ping/错误上传/诊断包遥测部分全部停发，
+# 「导出诊断包」是用户手动操作不受此开关限制）
+DEFAULTS = {"max_concurrent_jobs": 3, "default_workdir": "", "hooks_token": "",
+            "telemetry_errors": True}
 MIN_WORKERS, MAX_WORKERS = 1, 6
 
 
@@ -77,6 +80,10 @@ def save(patch):
             if err:
                 return cur, err
             cur["default_workdir"] = wd
+        if "hooks_token" in patch:
+            cur["hooks_token"] = str(patch.get("hooks_token") or "").strip()[:128]
+        if "telemetry_errors" in patch:
+            cur["telemetry_errors"] = bool(patch.get("telemetry_errors"))
         _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/step_runner.py

@@ -22,31 +22,55 @@ log = logging.getLogger(__name__)
 # 触发「压缩后重试」的错误码
 _OVERFLOW_CODES = {ErrorCode.CONTEXT_OVERFLOW, ErrorCode.MAX_TOKENS}
 
+# 事前预检阈值：最近一次调用的上下文锚点已占本步模型容量九成 → 第一个请求
+# 大概率被供应商拒。只拦「大概率必死」，不提前压缩平时的高压（used() 是累计
+# 口径，比真实上下文偏大；0.8 的响应式阈值语义与此不同，勿混用）。
+_PRECHECK_RATIO = 0.9
+
 
 def execute_step(session, run_agent_fn, prompt, *, model: str = "",
                  llm_caller=None, retain_tail_tokens=None, **kwargs):
     """执行一次 step；撑爆时压缩并守门重试一次。
 
+    事前预检（借鉴 freebuff base-chat 每步容量重估）：换将切到小窗口模型后，
+    响应式路径要等供应商报 CONTEXT_OVERFLOW 才压缩——报得不干净就直接卡死。
+    先用「最近一次调用上下文 vs 本步模型容量」判一次，超阈先压缩再发。
+
     Args:
         session: session_log.Session（记录 replace_generation）
         run_agent_fn: runner.run_agent（或测试替身），签名 (prompt, **kwargs) -> dict
         prompt: 已渲染的提示词（重试时原样复用，不重新渲染）
-        model: token_meter 压力估算用模型名
+        model: 本步将要使用的模型名（容量与压力估算都按它算）
         llm_caller: 压缩摘要 LLM（None = 不压缩，永不重试）
         **kwargs: 透传 run_agent_fn
 
     Returns:
         (result, retried: bool)
     """
+    compact_kwargs = {}
+    if retain_tail_tokens is not None:
+        compact_kwargs["retain_tail_tokens"] = retain_tail_tokens
+    if llm_caller is not None and model:
+        try:
+            from .token_meter import token_meter
+            ctx = token_meter.last_context(session.run_id)
+            cap = token_meter.capacity(model)
+            if ctx > 0 and cap > 0 and ctx > cap * _PRECHECK_RATIO:
+                gen_p0 = session.replace_generation()
+                if maybe_compact(session, model=model, llm_caller=llm_caller,
+                                 run_id=session.run_id, **compact_kwargs) \
+                        and session.replace_generation() > gen_p0:
+                    log.info("precheck: last ctx~%d > %.0f%% of cap(%s)=%d, "
+                             "compacted before step", ctx, _PRECHECK_RATIO * 100,
+                             model, cap)
+        except Exception:
+            log.debug("precheck skipped", exc_info=True)
     gen0 = session.replace_generation()
     result = run_agent_fn(prompt, **kwargs)
     code = result.get("error_code") or ""
     if code not in _OVERFLOW_CODES or llm_caller is None:
         return result, False
     # 撑爆 → 尝试压缩
-    compact_kwargs = {}
-    if retain_tail_tokens is not None:
-        compact_kwargs["retain_tail_tokens"] = retain_tail_tokens
     compacted = maybe_compact(session, model=model, llm_caller=llm_caller,
                               run_id=session.run_id, **compact_kwargs)
     gen1 = session.replace_generation()