codebee 0.1.101 → 0.1.103

package/app/core/catalog.py

@@ -200,15 +200,19 @@ DEFAULT_CATALOG = [
     {
         "id": "trae-agent", "name": "Trae Agent", "cli_group": "installable",
         "note": "字节跳动开源 trae-agent；可执行名 trae-cli；PyPI 无包，uv tool 从 "
-                "GitHub 直装（Python ≥3.12）；无头 trae-cli run \"提示词\"（一次性任务"
-                "形态）；配置 trae_config.yaml 默认找当前工作目录（TRAE_CONFIG_FILE "
-                "可指定），默认模型是 agents.trae_agent.model 指向 models 表别名的两层"
-                "引用，CodeBee 暂不托管其模型落盘——绑定模型请在 trae_config.yaml 自配",
+                "GitHub 直装（Python ≥3.12）；--with 钉 cryptography<49——49.0.0 起"
+                "上游不再发 Intel Mac wheel，缺 brew 的 Mac 落 sdist 编译必死于 "
+                "openssl-sys；无头 trae-cli run \"提示词\"（一次性任务形态）；配置 "
+                "trae_config.yaml 默认找当前工作目录（TRAE_CONFIG_FILE 可指定），"
+                "默认模型是 agents.trae_agent.model 指向 models 表别名的两层引用，"
+                "CodeBee 暂不托管其模型落盘——绑定模型请在 trae_config.yaml 自配",
         "detect": {"cli": "trae-cli"},
         "orch": {"kind": "generic", "command": "trae-cli", "argv_template": ["run", "{prompt}"]},
         "config": {"path": "~/.trae/trae_config.yaml", "format": None, "model_key": None},
-        "install": "uv tool install --python 3.12 git+https://github.com/bytedance/trae-agent",
-        "upgrade": "uv tool install --force --python 3.12 git+https://github.com/bytedance/trae-agent",
+        "install": 'uv tool install --python 3.12 --with "cryptography<49"'
+                   " git+https://github.com/bytedance/trae-agent",
+        "upgrade": 'uv tool install --force --python 3.12 --with "cryptography<49"'
+                   " git+https://github.com/bytedance/trae-agent",
         "uninstall": "uv tool uninstall trae-agent",
         "default_enabled": False,
     },
@@ -395,6 +399,24 @@ def _apply_install_patch(entries):
         cur = (e.get("install") or "").strip()
         if "pip" in cur and "install" in cur:
             e["install"], e["upgrade"] = aider_uv
+    # trae-agent 经 google-genai→google-auth 拉 cryptography，而 cryptography
+    # 49.0.0 起不再发 Intel Mac wheel（只剩 macosx_11_0_arm64）——uv 找不到
+    # wheel 落 sdist 经 maturin/cargo 编译，openssl-sys 在无 brew 的 Mac 上
+    # 缺 pkg-config/OpenSSL 开发头必死（2026-10-10 Mac 实案）。钉 <49（48.x
+    # 是最后带 macosx_10_9_universal2 的系列，google-auth 只要求 >=38.0.3）
+    # 让 uv 恒走预编译 wheel。凡 uv 形态且未钉 cryptography 的旧命令一律
+    # 迁移——钉版是兼容底线不是偏好，trae 的安装命令本就无人手改。
+    trae_pinned = ('uv tool install --python 3.12 --with "cryptography<49"'
+                   " git+https://github.com/bytedance/trae-agent")
+    trae_upgrade_pinned = ('uv tool install --force --python 3.12'
+                           ' --with "cryptography<49"'
+                           " git+https://github.com/bytedance/trae-agent")
+    for e in entries:
+        if e.get("id") != "trae-agent":
+            continue
+        cur = (e.get("install") or "").strip()
+        if "uv tool install" in cur and "cryptography<" not in cur:
+            e["install"], e["upgrade"] = trae_pinned, trae_upgrade_pinned
     if sys.platform == "win32":
         return
     for e in entries:

package/app/core/chaptersafe.py

@@ -1,32 +1,32 @@
-# -*- coding: utf-8 -*-
-"""章节安全落盘（tmp+原子改名，inkos 安全章节工作区借鉴）。
-
-写一半崩溃/磁盘满不会留下半章正文冒充成稿——断点续跑按「文件够长」
-判定，半文件会被误当合法稿复用；.tmp 写完 os.replace 原子落位，
-失败清理残渣后原样抛出。路径守卫用 pathlib resolve+parents 惯用法
-（同 _ms_io/_inside 口径）。pipeline._write_chapter 委托此函数。"""
-from __future__ import annotations
-
-from pathlib import Path
-
-
-def atomic_write_chapter(workdir, i, text):
-    """第 i 章安全落盘：tmp 写入 → 原子改名。返回最终路径。"""
-    root = Path(workdir).resolve()
-    p = (root / ("chapter-%02d.md" % int(i))).resolve()
-    # 守卫：目标必须在 workdir 之内且不得是 workdir 本身（".." 作 workdir
-    # 时 resolve 到父目录，p 仍是其中一章——但那不是调用方的工作目录，
-    # 一并拒绝：workdir 必须是已存在的目录）
-    if root not in p.parents or not root.is_dir():
-        raise ValueError("章节路径越界: chapter-%02d.md" % int(i))
-    tmp = Path(str(p) + ".tmp")
-    try:
-        tmp.write_text(str(text), encoding="utf-8", errors="replace")
-        tmp.replace(p)
-    except BaseException:
-        try:
-            tmp.unlink(missing_ok=True)
-        except OSError:
-            pass
-        raise
-    return p
+# -*- coding: utf-8 -*-
+"""章节安全落盘（tmp+原子改名，inkos 安全章节工作区借鉴）。
+
+写一半崩溃/磁盘满不会留下半章正文冒充成稿——断点续跑按「文件够长」
+判定，半文件会被误当合法稿复用；.tmp 写完 os.replace 原子落位，
+失败清理残渣后原样抛出。路径守卫用 pathlib resolve+parents 惯用法
+（同 _ms_io/_inside 口径）。pipeline._write_chapter 委托此函数。"""
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def atomic_write_chapter(workdir, i, text):
+    """第 i 章安全落盘：tmp 写入 → 原子改名。返回最终路径。"""
+    root = Path(workdir).resolve()
+    p = (root / ("chapter-%02d.md" % int(i))).resolve()
+    # 守卫：目标必须在 workdir 之内且不得是 workdir 本身（".." 作 workdir
+    # 时 resolve 到父目录，p 仍是其中一章——但那不是调用方的工作目录，
+    # 一并拒绝：workdir 必须是已存在的目录）
+    if root not in p.parents or not root.is_dir():
+        raise ValueError("章节路径越界: chapter-%02d.md" % int(i))
+    tmp = Path(str(p) + ".tmp")
+    try:
+        tmp.write_text(str(text), encoding="utf-8", errors="replace")
+        tmp.replace(p)
+    except BaseException:
+        try:
+            tmp.unlink(missing_ok=True)
+        except OSError:
+            pass
+        raise
+    return p

package/app/core/checkpoints.py

@@ -7,6 +7,7 @@ import json
 import base64
 import difflib
 import os
+import re
 import secrets
 import stat
 import subprocess
@@ -21,7 +22,7 @@ from .redact import scrub_text
 _DIR = paths.DATA_DIR / "checkpoints"
 _LOCK = threading.RLock()
 _TERMINAL = {"done", "failed", "cancelled", "timeout", "unknown"}
-_SNAPSHOT_MAX_BYTES = 1024 * 1024
+_SNAPSHOT_MAX_BYTES = 1024 * 1024      # ≤此值内嵌快照 JSON；超限进 git 对象库
 _SNAPSHOT_TOTAL_MAX_BYTES = 16 * 1024 * 1024
 _SUPPORTS_DIR_FD_RENAME = os.rename in getattr(os, "supports_dir_fd", set())
 
@@ -141,7 +142,12 @@ def replay_preview(run_id):
                     or x.get("step") not in starts), None)
     if not steps:
         unknown = {"reason": "checkpoint_not_found"}
+    total_steps = len(steps)
+    max_preview_steps = 200
+    steps = steps[-max_preview_steps:]
     return {"run_id": str(run_id or ""), "steps": steps,
+            "total_steps": total_steps,
+            "truncated": total_steps > max_preview_steps,
             "replayable": unknown is None,
             "blocked_reason": ("checkpoint_not_found" if not steps else
                                "requires_reconciliation" if unknown else "")}
@@ -198,15 +204,17 @@ def _load_snapshot(run_id, rel):
 def capture_file(run_id, workdir, path):
     """Persist the first pre-edit bytes for a workspace-relative file.
 
-    Full-content snapshots are intentionally bounded; unsupported/large files
-    are reported as untracked rather than silently treated as reversible.
+    ≤1MB 内嵌进快照 JSON（b64）；更大的文件（连载全书稿这类持续增长的
+    tracked 脏文件）前态进工作区 git 对象库，不再顶着 1MB 上限把整步拒死
+    （2026-10-10 实案：manuscript.md 涨到 1.14MB 后全部评审步被「已有改动
+    无法完整快照」拒起 CLI）。对象库也存不进（非 git 目录）才维持拒绝：
+    起跑闸宁拒不假装可恢复。
     """
     root, rel = _safe_snapshot_path(workdir, path)
     if root is None:
         return {"ok": False, "reason": "path_outside_workspace"}
     with _LOCK:
-        existing = _load_snapshot(run_id, rel)
-        if existing:
+        if _load_snapshot(run_id, rel):
             return {"ok": True, "existing": True, "path": rel}
         snap_dir = _snapshot_dir(run_id)
         try:
@@ -215,28 +223,32 @@ def capture_file(run_id, workdir, path):
             target = root / rel
             existed = target.exists()
             raw = target.read_bytes() if existed else b""
-            if len(raw) > _SNAPSHOT_MAX_BYTES or total + len(raw) > _SNAPSHOT_TOTAL_MAX_BYTES:
-                return {"ok": False, "reason": "snapshot_size_limit", "path": rel}
-            item = {"path": rel, "existed": existed,
-                    "before_b64": base64.b64encode(raw).decode("ascii"),
-                    "before_sha256": hashlib.sha256(raw).hexdigest() if existed else "",
-                    "after_sha256": None, "captured_at": time.time()}
-            _snapshot_file(run_id, rel).write_text(
-                json.dumps(item, ensure_ascii=False, sort_keys=True), encoding="utf-8")
-            return {"ok": True, "existing": False, "path": rel}
+            if len(raw) > _SNAPSHOT_MAX_BYTES:
+                return _write_oversize_snapshot(run_id, root, rel, existed,
+                                                file_path=target)
+            if total + len(raw) > _SNAPSHOT_TOTAL_MAX_BYTES:
+                # b64 预算满：大内容照样可以走对象库，别在这里误杀
+                return _write_oversize_snapshot(run_id, root, rel, existed,
+                                                file_path=target) if raw else \
+                    {"ok": False, "reason": "snapshot_size_limit", "path": rel}
+            return _write_snapshot(run_id, rel, existed, raw=raw)
         except OSError as exc:
             return {"ok": False, "reason": "snapshot_io_error", "path": rel,
                     "detail": str(exc)[:200]}
 
 
 def capture_bytes(run_id, workdir, path, raw, *, existed=True):
-    """Persist an explicit pre-step byte image (used for clean Git baseline files)."""
+    """Persist an explicit pre-step byte image (used for clean Git baseline files).
+
+    超限字节流同样进 git 对象库兜底：finish 阶段从 HEAD 取回的 clean 基线
+    （如归档后的整本 manuscript.md）此前只能给 warning，现在也能完整留底。
+    """
     root, rel = _safe_snapshot_path(workdir, path)
     if root is None:
         return {"ok": False, "reason": "path_outside_workspace"}
     raw = bytes(raw or b"") if existed else b""
     if len(raw) > _SNAPSHOT_MAX_BYTES:
-        return {"ok": False, "reason": "snapshot_size_limit", "path": rel}
+        return _write_oversize_snapshot(run_id, root, rel, existed, raw=raw)
     with _LOCK:
         if _load_snapshot(run_id, rel):
             return {"ok": True, "existing": True, "path": rel}
@@ -246,27 +258,87 @@ def capture_bytes(run_id, workdir, path, raw, *, existed=True):
             total = sum(p.stat().st_size for p in snap_dir.glob("*.json") if p.is_file())
             if total + len(raw) > _SNAPSHOT_TOTAL_MAX_BYTES:
                 return {"ok": False, "reason": "snapshot_size_limit", "path": rel}
-            item = {"path": rel, "existed": bool(existed),
-                    "before_b64": base64.b64encode(raw).decode("ascii"),
-                    "before_sha256": hashlib.sha256(raw).hexdigest() if existed else "",
-                    "after_sha256": None, "captured_at": time.time()}
-            _snapshot_file(run_id, rel).write_text(
-                json.dumps(item, ensure_ascii=False, sort_keys=True), encoding="utf-8")
-            return {"ok": True, "existing": False, "path": rel}
+            return _write_snapshot(run_id, rel, existed, raw=raw)
         except OSError as exc:
             return {"ok": False, "reason": "snapshot_io_error", "path": rel,
                     "detail": str(exc)[:200]}
 
 
-def _git_bytes(workdir, *args):
+def _git_bytes(workdir, *args, data=None):
     try:
         return subprocess.run(["git", "-C", str(workdir), *args],
                               stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+                              input=data,
                               timeout=15, check=False)
     except (OSError, subprocess.SubprocessError):
         return None
 
 
+def _git_blob_sha(workdir, *, file_path=None, raw=None):
+    """把内容存进工作区 git 仓库的对象库，返回 blob sha（空串=失败）。
+
+    超限文件的前态走这里：blob 内容寻址、批间归档提交后自然转为被引用；
+    未被引用期间也只在 git gc 的两周宽限后才可能被清，与检查点生命周期同量级。
+    """
+    if file_path is not None:
+        res = _git_bytes(workdir, "hash-object", "-w", "--", str(file_path))
+    else:
+        res = _git_bytes(workdir, "hash-object", "-w", "--stdin", data=bytes(raw or b""))
+    if not res or res.returncode:
+        return ""
+    sha = os.fsdecode(res.stdout).strip()
+    return sha if re.fullmatch(r"[0-9a-f]{40}", sha) else ""
+
+
+def _snapshot_before_bytes(item, root):
+    """快照的前态字节：小文件取 JSON 内嵌 b64，超限文件回对象库取 blob。
+
+    返回 None = 前态不可得（对象库不可用或已被清理），调用方按不可恢复处理。
+    """
+    b64 = item.get("before_b64")
+    if b64:
+        return base64.b64decode(b64, validate=True)
+    sha = item.get("before_git_blob") or ""
+    if sha:
+        res = _git_bytes(root, "cat-file", "blob", sha)
+        if res is not None and not res.returncode:
+            return res.stdout
+    return None
+
+
+def _write_snapshot(run_id, rel, existed, raw=None, blob_sha=""):
+    """落一份前态快照记录：小文件内嵌 b64，超限文件只记 blob 引用。"""
+    item = {"path": rel, "existed": bool(existed),
+            "before_sha256": hashlib.sha256(raw or b"").hexdigest() if existed else "",
+            "after_sha256": None, "captured_at": time.time()}
+    if blob_sha:
+        item["before_git_blob"] = blob_sha
+    else:
+        item["before_b64"] = base64.b64encode(raw or b"").decode("ascii")
+    _snapshot_file(run_id, rel).write_text(
+        json.dumps(item, ensure_ascii=False, sort_keys=True), encoding="utf-8")
+    return {"ok": True, "existing": False, "path": rel}
+
+
+def _write_oversize_snapshot(run_id, root, rel, existed, *, file_path=None, raw=None):
+    """超限前态的落盘：存进 git 对象库；存不进（非 git 目录）才维持拒绝。"""
+    if file_path is not None:
+        sha = _git_blob_sha(root, file_path=file_path)
+    else:
+        sha = _git_blob_sha(root, raw=raw)
+    if not sha:
+        return {"ok": False, "reason": "snapshot_size_limit", "path": rel}
+    with _LOCK:
+        if _load_snapshot(run_id, rel):
+            return {"ok": True, "existing": True, "path": rel}
+        try:
+            _snapshot_dir(run_id).mkdir(parents=True, exist_ok=True)
+            return _write_snapshot(run_id, rel, existed, blob_sha=sha)
+        except OSError as exc:
+            return {"ok": False, "reason": "snapshot_io_error", "path": rel,
+                    "detail": str(exc)[:200]}
+
+
 def _git_changed_paths(workdir, gitmod):
     """Return every changed path, including both sides of renames/copies."""
     result = _git_bytes(workdir, "status", "--porcelain", "-z", "--untracked-files=all")
@@ -453,7 +525,7 @@ def snapshot_preview(run_id, workdir):
                 target = root / rel
                 current = target.read_bytes() if target.is_file() and not target.is_symlink() else None
                 current_hash = hashlib.sha256(current).hexdigest() if current is not None else None
-                before = base64.b64decode(item.get("before_b64") or "", validate=True)
+                before = _snapshot_before_bytes(item, root)
                 status = "unchanged" if current_hash == item.get("before_sha256") else "changed"
                 if "after_exists" in item:
                     can_restore = (bool(item.get("after_exists")) == (current is not None)
@@ -464,7 +536,9 @@ def snapshot_preview(run_id, workdir):
                 else:
                     can_restore = item.get("after_sha256") == current_hash
                 diff = ""
-                if current is not None and item.get("existed"):
+                if before is None and item.get("before_git_blob"):
+                    diff = "（大文件前态存于 git 对象库且当前不可读取，差异省略）"
+                elif current is not None and item.get("existed") and before is not None:
                     try:
                         old_text = before.decode("utf-8").splitlines(True)
                         new_text = current.decode("utf-8").splitlines(True)
@@ -521,16 +595,26 @@ def _restore_file_posix(root, rel, item, expected_exists, expected_hash):
                 try:
                     if not stat.S_ISREG(os.fstat(file_fd).st_mode):
                         return False
-                    with os.fdopen(file_fd, "rb", closefd=False) as handle:
-                        current = handle.read(_SNAPSHOT_MAX_BYTES + 1)
+                    # 全量流式哈希：截断读会让超限文件（前态走对象库的那种）
+                    # 的指纹恒不匹配、永远拒恢复。
+                    digest = hashlib.sha256()
+                    while True:
+                        chunk = os.read(file_fd, 1 << 20)
+                        if not chunk:
+                            break
+                        digest.update(chunk)
+                    current = digest.hexdigest()
                 finally:
                     os.close(file_fd)
         current_exists = current is not None
-        current_hash = hashlib.sha256(current).hexdigest() if current_exists else None
+        current_hash = current if current_exists else None
         if current_exists != bool(expected_exists) or current_hash != expected_hash:
             return False
 
         if item.get("existed"):
+            raw = _snapshot_before_bytes(item, root)
+            if raw is None:
+                return False
             if missing_parent:
                 parent_fd = root_fd
                 for part in parts[:-1]:
@@ -541,7 +625,6 @@ def _restore_file_posix(root, rel, item, expected_exists, expected_hash):
                     child_fd = os.open(part, directory_flags, dir_fd=parent_fd)
                     owned_fds.append(child_fd)
                     parent_fd = child_fd
-            raw = base64.b64decode(item.get("before_b64") or "", validate=True)
             temp_name = ".codebee-restore-%s.tmp" % secrets.token_hex(12)
             temp_fd = os.open(temp_name, os.O_WRONLY | os.O_CREAT | os.O_EXCL
                               | getattr(os, "O_NOFOLLOW", 0), 0o600, dir_fd=parent_fd)
@@ -611,7 +694,10 @@ def restore_files(run_id, workdir):
                     conflicts.append(rel)
                     continue
                 if item.get("existed"):
-                    raw = base64.b64decode(item.get("before_b64") or "", validate=True)
+                    raw = _snapshot_before_bytes(item, root)
+                    if raw is None:
+                        conflicts.append(rel)
+                        continue
                     target.parent.mkdir(parents=True, exist_ok=True)
                     safe_root, safe_rel = _safe_snapshot_path(root, root / rel)
                     if safe_root is None or safe_rel != rel: