codebee 0.1.101 → 0.1.102

package/app/core/publish/auto.py

@@ -24,6 +24,7 @@ import time
 PACE_S = 45                  # 章间间隔（防风控节奏），测试里可置 0
 IDLE_POLL_S = 2              # 等 manager busy 结束的轮询步长
 IDLE_TIMEOUT_S = 420         # 单章最长等待（含浏览器操作与人工确认窗口）
+TRANSIENT_RETRY_S = 5        # 连接类瞬断的重试前静默（等浏览器缓过来）
 
 _CAP_DEFAULT = 10
 _STREAK_DEFAULT = 3
@@ -95,6 +96,36 @@ def _fail_window_text():
     return ("%g 小时" % h) if h < 24 else ("%g 天" % (h / 24))
 
 
+# 连接类瞬断标记（2026-10-10 存草稿实案：45 章 fill 时「连接被关闭」整链
+# 停摆）——命中即对该章重试一次再弃，不因浏览器抖动废掉整批
+_TRANSIENT_MARKS = ("连接断开", "连接被关闭", "10053", "10054", "等响应超时",
+                    "已中止", "目标已关闭")
+# 幂等拒起标记（manager 层台账/实况对账的拒绝话术）——命中即跳过该章，
+# 不是失败
+_IDEMPOTENT_MARKS = ("已成功发布过", "已存过草稿")
+
+
+def _is_transient(err):
+    e = str(err or "")
+    return any(m in e for m in _TRANSIENT_MARKS)
+
+
+def _is_idempotent_reject(err):
+    e = str(err or "")
+    return any(m in e for m in _IDEMPOTENT_MARKS)
+
+
+def other_batch_running(task_id):
+    """除本任务外是否还有别的自动发布/存草稿批次在跑。命中返回对方
+    task_id，否则空串——草稿链与之互斥（共用平台浏览器会互踩页签，
+    2026-10-10 实案：连载发章占着浏览器，草稿流 fill 被掐断连接）。"""
+    with _LOCK:
+        for tid, ent in _running.items():
+            if tid != str(task_id) and ent.get("status") == "running":
+                return str(tid)
+    return ""
+
+
 # ---------------------------------------------------------------- 待发枚举
 # 文档目录里的编号文件不是章节稿：章纲/大纲按章编号（第85章-xxx.md、
 # vol-1-ch-16.md），全按章号算会把待发清单撑出一堆「假章」——批量选择
@@ -282,7 +313,10 @@ def publish_pending_async(task_id, platform, auto_submit=False, only=None,
     as_draft=True（全部发草稿，2026-10-09）：逐章自动填稿并点「存草稿」，
     不上线、不受质量闸拦、无需人工确认，一章接一章连跑到清空待发清单
     （章间仍按 PACE_S 防风控节奏）；提交发布由用户到平台草稿箱手工完成，
-    届时质量闸照常把关。与 auto_submit 互斥（草稿模式忽略 auto_submit）。"""
+    届时质量闸照常把关。与 auto_submit 互斥（草稿模式忽略 auto_submit）。
+    草稿链三条专属护栏（2026-10-10 假成功案）：起跑前先 attach-only 对账
+    平台实况并重算待发（已发布/已存稿剔除，对不了账就拒起）；跑批期间
+    检测到另一批自动发布即让位停止（平台浏览器互斥）。"""
     from .. import store
     from . import ledger, manager
     if platform not in manager.PLATFORMS:
@@ -301,6 +335,11 @@ def publish_pending_async(task_id, platform, auto_submit=False, only=None,
         cur = _running.get(task_id) or {}
         if cur.get("status") == "running":
             return False, "该任务已有自动发布进行中，请等本轮结束"
+    if as_draft:
+        other = other_batch_running(task_id)
+        if other:
+            return False, ("检测到另一批自动发布/存草稿进行中（任务 %s）——两边"
+                           "共用平台浏览器会互踩，请等它跑完再存草稿" % other)
     task = store.get_task(task_id)
     if not task:
         return False, "任务不存在"
@@ -329,6 +368,7 @@ def publish_pending_async(task_id, platform, auto_submit=False, only=None,
     pend, err = pending(task_id, platform)
     if err:
         return False, err
+    want = None
     if only is not None:
         try:
             want = {int(n) for n in (only or []) if n}
@@ -346,13 +386,49 @@ def publish_pending_async(task_id, platform, auto_submit=False, only=None,
     st = {"platform": platform, "at": time.strftime("%Y-%m-%d %H:%M:%S"),
           "done": 0, "total": len(pend), "status": "running", "error": "",
           "auto_submit": bool(auto_submit), "as_draft": bool(as_draft),
-          "last_chapter": 0}
+          "last_chapter": 0, "skipped": 0, "notes": []}
     with _LOCK:
         _running[task_id] = st
 
     def run():
         try:
-            for item in pend:
+            items = pend
+            if as_draft:
+                # 起草前对账（2026-10-10 假成功案）：台账只记得自己发的章，
+                # 手工补交的只有平台知道——attach-only 刷一次校准再重算待发，
+                # 已发布/已存稿章就地剔除，不去撞序号重复。对不了账（浏览器
+                # 未连接/忙）整个拒起：存草稿本来就需要平台浏览器，宁等空窗
+                # 不盲跑；平台没配章节计数时跳过对账维持旧路径。
+                ok_r, why_r = manager.sync_published(task_id, platform,
+                                                     manual=False)
+                if not ok_r and "未配置章节计数" not in str(why_r or ""):
+                    st["status"] = "error"
+                    st["error"] = ("存草稿前对账失败：%s。为防把已发布章重复存稿，"
+                                   "本次未起草；请连接平台浏览器并等它空闲后重试"
+                                   % why_r)
+                    return
+                fresh, _ = pending(task_id, platform)
+                if want is not None:
+                    fresh = [p for p in fresh if p["chapter_no"] in want]
+                if not fresh:
+                    st["status"] = "done"
+                    st["message"] = ("对账后没有可存草稿的章节（所选均已发布或"
+                                     "已存稿）；确需重存请先在平台删旧稿")
+                    return
+                if len(fresh) != st["total"]:
+                    st["notes"].append("对账剔除 %d 章已发布/已存稿，实存 %d 章"
+                                       % (st["total"] - len(fresh), len(fresh)))
+                st["total"] = len(fresh)
+                items = fresh
+            for item in items:
+                if as_draft:
+                    other = other_batch_running(task_id)
+                    if other:
+                        st["status"] = "error"
+                        st["error"] = ("检测到另一批自动发布已启动（任务 %s），"
+                                       "存草稿让位停止；已存 %d 章落平台草稿箱，"
+                                       "等对方跑完再续" % (other, st["done"]))
+                        return
                 g_ok, why = guards(task_id, platform)   # 每章前复查（中途也能拦）
                 if not g_ok:
                     st["status"] = "error"
@@ -366,6 +442,22 @@ def publish_pending_async(task_id, platform, auto_submit=False, only=None,
                 ok2, err2 = manager.upload_chapter_async(
                     task_id, platform, str(Path(wd) / item["file"]),
                     **upload_kwargs)
+                if not ok2 and as_draft and _is_idempotent_reject(err2):
+                    # 幂等拒起＝这章已发布/已存过稿：跳过，不是失败——
+                    # 整链不该因「没活干」停摆
+                    st["skipped"] += 1
+                    st["notes"].append("第 %d 章跳过：%s"
+                                       % (item["chapter_no"], str(err2)[:60]))
+                    continue
+                if not ok2 and as_draft and _is_transient(err2):
+                    # 连接类瞬断（连载流互踩/浏览器抖动）：重试一次再弃
+                    st["notes"].append("第 %d 章连接中断，%d 秒后重试一次"
+                                       % (item["chapter_no"],
+                                          TRANSIENT_RETRY_S))
+                    time.sleep(TRANSIENT_RETRY_S)
+                    ok2, err2 = manager.upload_chapter_async(
+                        task_id, platform, str(Path(wd) / item["file"]),
+                        **upload_kwargs)
                 if not ok2:
                     st["status"] = "error"
                     st["error"] = "第 %d 章发起失败：%s" % (item["chapter_no"], err2)
@@ -387,12 +479,15 @@ def publish_pending_async(task_id, platform, auto_submit=False, only=None,
                     if item["chapter_no"] not in ledger.drafted_chapters(
                             task_id, platform):
                         st["status"] = "error"
-                        st["error"] = ("第 %d 章存草稿未确认，后续章节未存（详见"
-                                       "发布台账与截图存证）" % item["chapter_no"])
+                        st["error"] = ("第 %d 章存草稿未确认（台账未落草稿账），"
+                                       "后续章节未存；截图存证见发布台账，若实际"
+                                       "已保存成功，把页面反馈文案照截图校准进"
+                                       "流程表 expect_text 步骤"
+                                       % item["chapter_no"])
                         return
                     st["done"] += 1
                     st["last_chapter"] = item["chapter_no"]
-                    if st["done"] < st["total"]:
+                    if st["done"] + st["skipped"] < st["total"]:
                         time.sleep(PACE_S)
                     continue
                 if not auto_submit:
@@ -416,9 +511,11 @@ def publish_pending_async(task_id, platform, auto_submit=False, only=None,
                     time.sleep(PACE_S)
             st["status"] = "done"
             if as_draft:
-                st["message"] = ("已存草稿 %d 章（未发布，不受质量闸拦不代表可直发）；"
-                                 "请到平台章节管理/草稿箱逐章检查后提交发布"
-                                 % st["done"])
+                st["message"] = ("已存草稿 %d 章%s（未发布，不受质量闸拦不代表可"
+                                 "直发）；请到平台章节管理/草稿箱逐章检查后提交"
+                                 "发布"
+                                 % (st["done"], ("、跳过 %d 章" % st["skipped"])
+                                    if st["skipped"] else ""))
             elif not auto_submit:
                 st["message"] = "第 %d 章已填好，请在浏览器里确认提交，再重新校准" % st["last_chapter"]
         except Exception as e:                 # 线程内绝不能悬挂无终态

package/app/core/publish/fanqie.py

@@ -110,12 +110,17 @@ UPLOAD_CHAPTER = [
      "optional": True},
 ]
 
-# 发章存草稿（2026-10-09 全部发草稿）：与 UPLOAD_CHAPTER 同一张填表前段，
-# 终点不同——点编辑器头部「存草稿」直接落草稿箱，不走「下一步→内容检测→
-# 发布提示→提交」发布链。草稿不上线，批量连跑无需人工确认；提交发布由
-# 用户到章节管理/草稿箱手工完成。verify 沿用章节管理页断言（草稿行同样
-# 出现在列表里，标题/章号标记可命中）；若平台改版把草稿挪去独立草稿箱页，
-# 首轮失败的 step 截图会指出来，照 flows-fanqie.json 校准即可。
+# 发章存草稿（2026-10-09 全部发草稿；2026-10-10 假成功案重构）：
+# 与 UPLOAD_CHAPTER 同一张填表前段，终点不同——点编辑器头部「存草稿」直接
+# 落草稿箱，不走「下一步→内容检测→发布提示→提交」发布链。三点教训入表：
+# 1) submit 带 always=true：草稿流程跑在 auto_submit=false 语义下，而这里的
+#    「存草稿」点击本身就是保存动作——被人工闸吞掉时 manager 把「填好未存」
+#    记成成功（44 章假成功实案）。
+# 2) expect_text 等编辑器页保存反馈为主凭据（标记文案以真机校准为准，失败
+#    自动落 fail 截图）；「已保存」这类自动保存字样刻意不入标记——编辑器
+#    自动保存不可依赖，不能当本次点击的证据。
+# 3) verify 仍走章节管理页兜底（新章草稿行同样在列表里）；对「已发布章重复
+#    起草」它必然假通过——该情形由起草前对账（auto 层）剔除，不靠本表。
 UPLOAD_CHAPTER_DRAFT = [
     {"do": "navigate", "url": "{editor_url}"},
     {"do": "url_any", "any": ["fanqienovel.com"]},
@@ -131,10 +136,11 @@ UPLOAD_CHAPTER_DRAFT = [
     {"do": "wait", "sel": "[contenteditable=true],textarea[class*=content],div[class*=editor]", "timeout": 10},
     {"do": "fill", "sel": "[contenteditable=true],textarea[class*=content]", "key": "chapter_body"},
     {"do": "shot", "name": "chapter-filled-draft"},
-    {"do": "submit", "text": "存草稿", "scope": "button", "tries": 15},
-    {"do": "js_click", "text": "存草稿", "scope": "button", "tries": 10,
-     "optional": True, "skip_if_modal": True},
-    {"do": "sleep", "s": 2.5},
+    {"do": "submit", "text": "存草稿", "scope": "button", "tries": 15, "always": True},
+    {"do": "sleep", "s": 1.2},
+    {"do": "shot", "name": "chapter-draft-clicked"},
+    {"do": "expect_text",
+     "any": ["保存成功", "存草稿成功", "草稿已保存", "已存草稿"], "timeout": 12},
     {"do": "verify", "url": "{chapter_manage_url}",
      "any": ["第{chapter_no}章", "{chapter_name}"], "settle": 6, "new_tab": True},
 ]

package/app/core/publish/flow.py

@@ -558,7 +558,10 @@ def run_flow(page, steps, values=None, config=None, auto_submit=False,
                 if log:
                     log("PROBE " + json.dumps(info, ensure_ascii=False)[:4000])
             elif act == "submit":
-                if not auto_submit:
+                # always=true 的提交步（草稿流的「存草稿」）本身就是保存动作，
+                # 不吃 auto_submit 人工闸——被闸吞掉时流程停在「填好未存」，
+                # manager 却照记成功（2026-10-10 44 章假成功实案）
+                if not auto_submit and not st.get("always"):
                     note(i, "已填好未提交——请人工检查后提交（auto_submit=false）")
                     if shot:
                         shot("ready-manual-submit")
@@ -686,6 +689,31 @@ def run_flow(page, steps, values=None, config=None, auto_submit=False,
                 finally:
                     if new_tab:
                         vpage.close_tab()
+            elif act == "expect_text":
+                # 页面反馈等待（草稿保存凭据，2026-10-10）：轮询页面文本直到
+                # 出现任一成功标记（toast/状态字样）——verify 的章节管理页对
+                # 「已发布章重复起草」必然假通过，编辑器保存反馈才是本次动作
+                # 自己的证据。超时即失败：宁可带 fail 截图拦下，不可把「没
+                # 存上」记成成功。标记文案以真机校准为准。
+                marks = [str(m) for m in (st.get("any") or [])]
+                if not marks:
+                    continue
+                deadline = time.time() + float(st.get("timeout") or 12)
+                hit = ""
+                while time.time() < deadline:
+                    body_txt = str(page.call(
+                        "()=>(document.body.innerText||'')", timeout=15) or "")
+                    hit = next((m for m in marks if m in body_txt), "")
+                    if hit:
+                        break
+                    time.sleep(0.8)
+                if not hit:
+                    raise FlowError("未见保存成功反馈（等了 %ds，标记：%s）——"
+                                    "若截图里实际已保存成功，请把真实反馈文案"
+                                    "校准进流程表"
+                                    % (int(float(st.get("timeout") or 12)),
+                                       "、".join(marks)[:60]))
+                note(i, "反馈命中「%s」" % hit)
             elif act == "volume":
                 # 发章带卷（2026-10-08 批量自动发布·自动分卷）：确保目标卷
                 # 在平台上存在（缺则走「新建分卷」）。平台新章按卷自动归类、

package/app/core/publish/manager.py

@@ -897,6 +897,14 @@ def upload_chapter_async(task_id, plat, chapter_file, auto_submit=False,
     book_ref = dict(book)
     if _st(plat).get("status") == "busy":
         return False, "该平台有操作正在进行中"
+    if as_draft:
+        # 草稿与别的自动发布批次互斥（2026-10-10 实案：连载发章占着浏览器，
+        # 草稿流 fill 被掐断连接）——单章草稿同样不让起
+        from . import auto as _auto
+        other = _auto.other_batch_running(task_id)
+        if other:
+            return False, ("检测到另一批自动发布进行中（任务 %s），平台浏览器会"
+                           "被互踩；等它跑完再存草稿" % other)
     ch_no, title, body, err = read_chapter(chapter_file)
     if err:
         return False, err

package/app/core/sandbox_runtime.py

@@ -0,0 +1,95 @@
+"""Optional process sandbox launchers.
+
+The default CodeBee install has no container dependency. Docker is an explicit
+opt-in backend selected by a task policy and a configured image; this module
+only builds argv and never silently falls back to a weaker backend.
+"""
+from __future__ import annotations
+
+import os
+import re
+import shutil
+from pathlib import Path
+
+
+class SandboxUnavailable(RuntimeError):
+    pass
+
+
+def requested_backend(sandbox):
+    value = str((sandbox or {}).get("backend") or "native").strip().lower()
+    return value or "native"
+
+
+def docker_argv(command, *, sandbox, workdir, image=None, extra_args=(),
+                container_workdir=None,
+                container_command=("/bin/sh", "-lc")):
+    """Build a restricted ``docker run`` argv for a command or stdio server."""
+    if requested_backend(sandbox) != "docker":
+        raise SandboxUnavailable("Docker 后端未被任务策略启用")
+    docker = shutil.which("docker")
+    if not docker:
+        raise SandboxUnavailable("当前系统没有可用的 Docker CLI")
+    root = Path(workdir or ".").expanduser().resolve(strict=True)
+    image = str(image or (sandbox or {}).get("docker_image") or "").strip()
+    if not image or len(image) > 240 or not re.match(r"^[A-Za-z0-9][A-Za-z0-9._/:@-]*$", image):
+        raise SandboxUnavailable("Docker 后端必须配置可信镜像")
+    roots = []
+    for value in (sandbox or {}).get("allowed_roots") or [str(root)]:
+        candidate = Path(value).expanduser().resolve(strict=True)
+        # Docker currently mounts exactly one root. Require the task workspace
+        # itself; narrower roots need a separately resolved container cwd and
+        # must never accidentally broaden into an ancestor mount.
+        if candidate != root:
+            raise SandboxUnavailable("Docker 目前只支持挂载任务工作目录")
+        if candidate not in roots:
+            roots.append(candidate)
+    if not roots:
+        raise SandboxUnavailable("Docker 后端没有允许目录")
+    selected_root = next((candidate for candidate in roots
+                          if candidate == root or candidate in root.parents
+                          or root in candidate.parents), None)
+    if selected_root is None:
+        raise SandboxUnavailable("当前工作目录不在 Docker 允许目录内")
+    if len(roots) != 1:
+        raise SandboxUnavailable("Docker 暂只支持一个明确的允许目录")
+    argv = [docker, "run", "--rm", "--init", "--read-only",
+            "--security-opt", "no-new-privileges", "--cap-drop=ALL",
+            "--ipc=none", "--pids-limit", "256", "--memory", "2g", "--cpus", "2",
+            "--tmpfs", "/tmp:rw,noexec,nosuid,size=64m"]
+    if hasattr(os, "getuid") and hasattr(os, "getgid"):
+        argv += ["--user", "%d:%d" % (os.getuid(), os.getgid())]
+    else:
+        argv += ["--user", "65534:65534"]
+    argv += ["--network", "none" if not bool((sandbox or {}).get("network", True)) else "bridge"]
+    for name in (sandbox or {}).get("env_allowlist") or []:
+        name = str(name)
+        if name and name in os.environ:
+            # Value is supplied through the filtered Docker client environment;
+            # never place credentials in argv, where process/log inspection sees them.
+            argv += ["--env", name]
+    for candidate in roots:
+        if "," in str(candidate):
+            raise SandboxUnavailable("Docker 允许目录包含不支持的逗号")
+        argv += ["--mount", "type=bind,src=%s,dst=/workspace" % str(candidate)]
+    if container_workdir is None:
+        rel_workdir = root.relative_to(selected_root).as_posix()
+        container_workdir = "/workspace" + ("/" + rel_workdir if rel_workdir != "." else "")
+    if not str(container_workdir).startswith("/") or ".." in Path(container_workdir).parts:
+        raise SandboxUnavailable("Docker 容器工作目录无效")
+    argv += ["--workdir", str(container_workdir), *list(extra_args), image]
+    if isinstance(command, (list, tuple)):
+        argv += [str(x) for x in command]
+    else:
+        argv += list(container_command) + [str(command)]
+    return argv
+
+
+def docker_env(sandbox):
+    """Docker receives only explicitly allowed host environment values."""
+    out = {"PATH": "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
+           "HOME": "/tmp", "TMPDIR": "/tmp"}
+    for name in (sandbox or {}).get("env_allowlist") or []:
+        if name in os.environ:
+            out[str(name)] = os.environ[str(name)]
+    return out

package/app/core/store.py

@@ -145,8 +145,15 @@ def create_task(payload):
     goal = _text(payload.get("goal"), "goal")
     workdir = _text(payload.get("workdir"), "workdir")
     if not goal:
-        raise ValueError("目标描述不能为空")
-    title = title or goal.splitlines()[0][:30]  # 标题可省略，自动取目标首行
+        # 扫榜选材的菜单承诺「方向可留空，默认分析总榜热门题材」——
+        # paihang.rank_scan_prompt 与 pipeline 两侧均已支持空 goal，这里放行；
+        # 其余类型目标必填不变。
+        if payload.get("type") == "rank_scan":
+            title = title or flow.get("name") or "扫榜选材"
+        else:
+            raise ValueError("目标描述不能为空")
+    else:
+        title = title or goal.splitlines()[0][:30]  # 标题可省略，自动取目标首行
     if not workdir:
         # 未指定目录 → 用「默认保存路径」（设置里可改；内置回落 <数据目录>/workspace）。
         # 默认路径允许自动创建；用户显式给的目录仍必须已存在。
@@ -2128,7 +2135,7 @@ def clear_stream_state(run_id=None, n=None):
 
 def finish_step(run_id, n, status, summary="", exit_code=None,
                 cost_usd=0.0, tokens=0.0, duration_s=None, model=None, output=None,
-                followups=None, thinking=None, partial=False):
+                followups=None, thinking=None, partial=False, acp_events=None):
     with LOCK:
         run = _RUNS.get(run_id)
         if not run:
@@ -2163,6 +2170,9 @@ def finish_step(run_id, n, status, summary="", exit_code=None,
                     s["partial"] = True
                 else:
                     s.pop("partial", None)
+                if acp_events:
+                    s["acp_events"] = [dict(item) for item in acp_events[:200]
+                                       if isinstance(item, dict)]
                 # 收尾即清运行中态：stream/activity/live 只是过程快照，留着会让
                 # 前端把「已结束」的步骤仍当实时流渲染（也白占 run.json 体积）
                 s.pop("stream", None)

package/app/main.py

@@ -2848,6 +2848,7 @@ class Handler(BaseHTTPRequestHandler):
                 "thinking": s.get("thinking") or "",
                 "stream": (s.get("stream") or "") if running else "",
                 "activity": (s.get("activity") or []) if running else [],
+                "acp_events": s.get("acp_events") or [],
                 "live": s.get("live") or 0,
             })