codebee 0.1.54 → 0.1.56

package/app/core/store.py

@@ -28,7 +28,11 @@ _RUNS = {}
 # 长跑也不会无限增长（finish_step 里调 clear_stream_state）。
 _STREAM_LOCK = threading.Lock()
 _STREAM_TS = {}
-LIVE_TEXT_MAX = 20000   # 单步骤实时思考/正文的保留上限（与 builtin_agent 同口径）
+LIVE_TEXT_MAX = 20000   # 单步骤实时思考/正文的保留上限（与 builtin_agent 同口径）
+
+DEFAULT_TASK_TIMEOUT_S = 3600
+MIN_TASK_TIMEOUT_S = 1
+MAX_TASK_TIMEOUT_S = 7 * 24 * 3600
 
 # ---------------------------------------------------------------- 状态版本（SSE 事件驱动）
 # 任何落盘写都算状态变化：SSE 连接等版本号变化才构建/推送全量状态，
@@ -57,12 +61,38 @@ def wait_state_change(last_ver, timeout):
         return _STATE_VER
 
 
-def _new_id(prefix):
-    return "%s-%s-%04d" % (prefix, time.strftime("%Y%m%d-%H%M%S"), secrets.randbelow(10000))
-
-
-def _safe_name(s):
-    return re.sub(r"[^0-9A-Za-z_-]+", "-", str(s))[:40].strip("-") or "x"
+def _new_id(prefix):
+    stamp = time.strftime("%Y%m%d-%H%M%S")
+    # 10k random suffixes are not unique under a burst of task/run creation.
+    # Reserve against both indexes and disk so a collision cannot silently
+    # overwrite a queued run and make one of several submissions disappear.
+    with LOCK:
+        for _ in range(100):
+            candidate = "%s-%s-%04d" % (prefix, stamp, secrets.randbelow(10000))
+            if candidate in _TASKS or candidate in _RUNS:
+                continue
+            if (paths.TASKS_DIR / (candidate + ".json")).exists():
+                continue
+            if (paths.RUNS_DIR / candidate).exists():
+                continue
+            return candidate
+    raise RuntimeError("无法生成唯一记录 ID")
+
+
+def _safe_name(s):
+    return re.sub(r"[^0-9A-Za-z_-]+", "-", str(s))[:40].strip("-") or "x"
+
+
+def _task_timeout_s(value=None):
+    """Resolve one bounded wall-clock budget for a task."""
+    raw = value
+    if raw in (None, ""):
+        raw = os.environ.get("TUTTI_TASK_TIMEOUT_S", DEFAULT_TASK_TIMEOUT_S)
+    try:
+        seconds = int(float(raw))
+    except (TypeError, ValueError):
+        seconds = DEFAULT_TASK_TIMEOUT_S
+    return max(MIN_TASK_TIMEOUT_S, min(MAX_TASK_TIMEOUT_S, seconds))
 
 
 # ---------------------------------------------------------------- 任务
@@ -128,7 +158,8 @@ def create_task(payload):
         "status": "created",
     }
     thinking = str(payload.get("thinking") or "standard").strip().lower()
-    task["thinking"] = thinking if thinking in ("auto", "low", "standard", "high") else "auto"
+    task["thinking"] = thinking if thinking in ("auto", "low", "standard", "high") else "auto"
+    task["timeout_s"] = _task_timeout_s(payload.get("timeout_s"))
     if flow["engine"] == "direct":
         task["direct_provider_id"] = _text(payload.get("direct_provider_id"),
                                             "direct_provider_id")[:80]
@@ -515,7 +546,7 @@ def load_all():
                 _save_json(paths.TASKS_DIR / (t["id"] + ".json"), t)
                 continue
             latest = max(runs, key=lambda r: r["id"])
-            if latest.get("status") in ("done", "failed", "cancelled"):
+            if latest.get("status") in ("done", "failed", "cancelled", "timeout"):
                 t["status"] = latest["status"]
                 _save_json(paths.TASKS_DIR / (t["id"] + ".json"), t)
 
@@ -531,7 +562,7 @@ def set_run_estimator(estimator):
     _RUN_ESTIMATOR = estimator if callable(estimator) else None
 
 
-def create_run(kind, title, task_id=None, entry_id=None, op=None):
+def create_run(kind, title, task_id=None, entry_id=None, op=None):
     run = {
         "id": _new_id("r" if kind == "orchestration" else "m"),
         "kind": kind,  # orchestration | mgmt
@@ -539,12 +570,14 @@ def create_run(kind, title, task_id=None, entry_id=None, op=None):
         "task_id": task_id, "entry_id": entry_id, "op": op,
         "status": "queued", "steps": [], "messages": [],
         "created_at": time.strftime("%Y-%m-%d %H:%M:%S"),
-        "started_at": None, "ended_at": None,
+        "started_at": None, "ended_at": None,
+        "deadline_at": None,
         "cost_usd": 0.0, "tokens": 0, "error": "",
         "verdict": None, "summary": "",
     }
-    if kind == "orchestration" and task_id:
-        task = get_task(task_id) or {}
+    if kind == "orchestration" and task_id:
+        task = get_task(task_id) or {}
+        run["deadline_at"] = time.time() + _task_timeout_s(task.get("timeout_s"))
         try:
             eta = _RUN_ESTIMATOR(
                 task_type=task.get("type") or "", mode=task.get("mode") or "auto",
@@ -729,25 +762,27 @@ def update_run(run_id, expected_status=None, **fields):
         # 这套在落终态瞬间即时收口——打磨组长被取消/异常打断时 UI 不闪
         # 假「工作中」）。run 终态后不可能还有步骤在真跑。
         st = fields.get("status")
-        if st in ("done", "failed", "cancelled"):
-            end_s = time.strftime("%H:%M:%S")
-            for s in run["steps"]:
-                if s.get("status") in ("queued", "running"):
-                    s["status"] = "cancelled"
-                    s["ended_at"] = s.get("ended_at") or end_s
-                    if not s.get("summary"):
-                        s["summary"] = "步骤未正常收尾（终态自动恢复）"
+        if st in ("done", "failed", "cancelled", "timeout"):
+            end_s = time.strftime("%H:%M:%S")
+            for s in run["steps"]:
+                if s.get("status") in ("queued", "running"):
+                    s["status"] = "timeout" if st == "timeout" else "cancelled"
+                    s["ended_at"] = s.get("ended_at") or end_s
+                    if not s.get("summary"):
+                        s["summary"] = ("步骤未正常收尾（任务总时限已到）"
+                                         if st == "timeout" else
+                                         "步骤未正常收尾（终态自动恢复）")
         _save_json(paths.RUNS_DIR / run_id / "run.json", run)
         # 状态回填：起跑与结束都同步任务状态。只回填终态的话，run 在跑、
         # 任务永远显示「排队中」（2026-09-18 实案：「# 重写·续」run 已 running
         # 写了一小时，任务卡 queued，用户以为卡死连点重试）。
-        if st in ("running", "done", "failed", "cancelled"):
+        if st in ("running", "done", "failed", "cancelled", "timeout"):
             tid = run.get("task_id")
             task = _TASKS.get(tid) if tid else None
             if task:
                 task["status"] = st
                 _save_json(paths.TASKS_DIR / (tid + ".json"), task)
-        if st in ("done", "failed", "cancelled"):
+        if st in ("done", "failed", "cancelled", "timeout"):
             # run_end 钩子（2026-09-22）：终态即触发，后台跑副作用型脚本
             # （回写知识库等）；失败/超时静默，绝不拖慢收尾路径
             try:
@@ -838,15 +873,17 @@ def recover_orphaned_runs():
     step_now = time.strftime("%H:%M:%S")
     with LOCK:
         for r in _RUNS.values():
-            if r.get("status") not in ("done", "failed", "cancelled"):
-                continue
+            if r.get("status") not in ("done", "failed", "cancelled", "timeout"):
+                continue
             changed = False
             for s in r.get("steps") or []:
                 if s.get("status") in ("queued", "running"):
-                    s["status"] = "cancelled"
+                    s["status"] = "timeout" if r.get("status") == "timeout" else "cancelled"
                     s["ended_at"] = s.get("ended_at") or step_now
                     if not s.get("summary"):
-                        s["summary"] = "步骤未正常收尾（取消/中断自动恢复）"
+                        s["summary"] = ("步骤未正常收尾（任务总时限已到）"
+                                         if r.get("status") == "timeout" else
+                                         "步骤未正常收尾（取消/中断自动恢复）")
                     changed = True
             if changed:
                 _save_json(paths.RUNS_DIR / r["id"] / "run.json", r)

package/app/core/zentao.py

@@ -66,6 +66,7 @@ from . import jobs, paths, settings, store, tlsctx
 log = logging.getLogger(__name__)
 
 _LOCK = threading.RLock()
+_SCAN_LOCK = threading.Lock()  # 手动/定时扫描单飞，避免重复拉取和重复认领
 _FILE = paths.DATA_DIR / "zentao.json"
 _STATE = {
     "config": {},        # 持久配置（_CFG_DEFAULTS）
@@ -868,12 +869,20 @@ def _claimable(bug, profile):
     return True
 
 
-def list_bugs(cfg, product_id):
-    """拉一个产品下的 bug（分页，总量封顶 MAX_BUGS）。返回原始 bug dict 列表。"""
+def list_bugs(cfg, product_id, profile=None):
+    """拉一个产品下的激活 bug（分页，总量封顶 MAX_BUGS）。
+
+    REST v1 支持时把状态/指派人过滤下推给禅道，减少无关 bug 的分页传输；
+    本地的 _claimable 仍保留，兼容老接口或禅道忽略未知查询参数的情况。
+    """
     out = []
     for page in range(1, 6):
-        d = _call("GET", "/products/%s/bugs?page=%d&limit=%d" % (product_id, page, PAGE_LIMIT),
-                  cfg=cfg)
+        query = {"page": page, "limit": PAGE_LIMIT, "status": "active"}
+        assigned = str((profile or {}).get("assigned_to") or "").strip()
+        if assigned:
+            query["assignedTo"] = assigned
+        d = _call("GET", "/products/%s/bugs?%s" % (
+            product_id, urllib.parse.urlencode(query)), cfg=cfg)
         bugs = d.get("bugs") if isinstance(d, dict) else None
         if not isinstance(bugs, list):
             raise ZenError("禅道 bug 列表响应形状不对（预期 bugs 数组）")
@@ -1038,7 +1047,7 @@ def test_connection(base_url=None, account=None, password=None):
     try:
         profiles = _profiles(c)
         if profiles:
-            bugs = list_bugs(probe, profiles[0]["product"])
+            bugs = list_bugs(probe, profiles[0]["product"], profiles[0])
             return True, "连接成功（%s），产品 %s 可访问（当前 %d 条 bug 在列表里）" % (
                 tag, profiles[0]["product"], len(bugs))
     except ZenError as e:
@@ -1712,7 +1721,7 @@ def _scan(cfg):
     if not profiles:
         raise ZenError("未配置产品档案——请先在设置页添加产品并配置仓库")
     for profile in profiles:
-        bugs = list_bugs(cfg, profile["product"])
+        bugs = list_bugs(cfg, profile["product"], profile)
         by_id = {str(b.get("id") or ""): b for b in bugs}
         with _LOCK:
             seen = set(_STATE["claims"].keys())
@@ -1735,6 +1744,17 @@ def _scan(cfg):
 
 
 def _poll(force=False):
+    """执行一次扫描；同一进程内只允许一个扫描实例。"""
+    if not _SCAN_LOCK.acquire(blocking=False):
+        return {"ok": False, "claimed": 0, "reconciled": False,
+                "error": "扫描正在进行，请稍候", "skipped": "in_progress"}
+    try:
+        return _poll_unlocked(force=force)
+    finally:
+        _SCAN_LOCK.release()
+
+
+def _poll_unlocked(force=False):
     """一次完整轮询：对账回写 + （到点/强制时）扫描认领。异常不外抛。"""
     _ensure_loaded()
     with _LOCK:
@@ -1945,6 +1965,17 @@ def save_config(patch):
     return view()["config"]
 
 
+def bug_web_base(cfg=None):
+    """给前端拼 bug 详情页用的 web 根：探测出的有效地基（含自动补的 /zentao 子路径）
+    优先，没探测过回落用户填的原始地址。返回 stripped 根或空串。"""
+    c = dict(cfg) if cfg else _cfg()
+    hit = resolved_base_url(c.get("base_url"))
+    if hit:
+        return hit
+    b = re.sub(r"/api\.php/v1$", "", str(c.get("base_url") or "").strip().rstrip("/"))
+    return b if b.startswith(("http://", "https://")) else ""
+
+
 def view():
     """前端视图：配置脱敏（password 只回是否已设）+ claims 列表（新在前）。"""
     _ensure_loaded()
@@ -1953,9 +1984,11 @@ def view():
         has_pw = bool(cfg.get("password"))
         cfg["password"] = ""
         cfg["has_password"] = has_pw
+        bug_base = bug_web_base(cfg)
         claims = sorted(_STATE["claims"].values(),
                         key=lambda c: str(c.get("claimed_at") or ""), reverse=True)
         return {"config": cfg,
+                "bug_base": bug_base,
                 "claims": [dict(c) for c in claims],
                 "last_scan": _STATE.get("last_scan") or "",
                 "next_scan": _STATE.get("next_scan") or "",

package/app/main.py

@@ -367,6 +367,12 @@ class Handler(BaseHTTPRequestHandler):
             if m:
                 run = store.get_run(m.group(1))
                 return self._json(200, {"run": run}) if run else self._json(404, {"error": "not found"})
+            m = re.match(r"^/api/runs/([^/]+)/messages$", path)
+            if m:
+                run = store.get_run(m.group(1))
+                if not run:
+                    return self._json(404, {"error": "not found"})
+                return self._json(200, {"messages": run.get("messages") or []})
             m = re.match(r"^/api/runs/([^/]+)/report$", path)
             if m:
                 run = store.get_run(m.group(1))
@@ -419,6 +425,10 @@ class Handler(BaseHTTPRequestHandler):
             if m:
                 # 任务检查器（右缘停靠列）专用：轻量聚合、可轮询，不带 diff 文本
                 return self._api_task_side(m.group(1))
+            m = re.match(r"^/api/tasks/([^/]+)/detail$", path)
+            if m:
+                task = store.get_task(m.group(1))
+                return self._json(200, {"task": task}) if task else self._json(404, {"error": "not found"})
             m = re.match(r"^/api/tasks/([^/]+)/runs$", path)
             if m:
                 # 任务级详情用：该任务全部 run（含 steps），不受前端 run 窗口限制
@@ -2365,16 +2375,20 @@ def _state_payload(client_id="", ver=None):
     agents = registry.effective_agents(catalog.load(), manager.detect_all())
     if ver is None:
         ver = store.state_version()
+    runs = store.list_runs(40)
+    latest = store.latest_run_by_task()
     return {
         "v": ver,
         "agents": agents,
         "tasks": store.list_tasks(30, archived=False),
-        "archived_tasks": store.list_tasks(30, archived=True),
+        # 归档任务默认隐藏；目标/上下文可能很大，只有查看或恢复时再按需读取。
+        "archived_tasks": [_state_task_summary(t) for t in store.list_tasks(30, archived=True)],
         # 每个任务的最近一次运行（不受 runs 窗口限制）：侧栏靠它展示各任务真实近况
-        "task_latest": store.latest_run_by_task(),
+        "task_latest": {tid: _state_run_summary(run) for tid, run in latest.items()},
         # 每个任务的运行次数/步骤总数（全量）：侧栏「查看全部」的计数来源
         "task_stats": store.task_run_stats(),
-        "runs": store.list_runs(40),
+        # 列表与 SSE 只带摘要；日志、模型输出、计划、消息正文等走详情 API。
+        "runs": [_state_run_summary(run) for run in runs],
         "control": remote.control_view(client_id),
         # 供应商健康/告警（顶栏横幅数据源；有告警时 bump_state 会推给所有端）
         "health": health.snapshot(),
@@ -2383,6 +2397,32 @@ def _state_payload(client_id="", ver=None):
     }
 
 
+def _state_task_summary(task):
+    """归档任务的最小索引；大字段由 /api/tasks/<id>/detail 按需读取。"""
+    fields = ("id", "title", "type", "engine", "workdir", "status",
+              "created_at", "archived", "git_state", "serial")
+    return {key: task[key] for key in fields if key in task}
+
+
+def _state_run_summary(run):
+    """列表/SSE 投影，不重复携带运行详情中的大字段。"""
+    fields = ("id", "task_id", "kind", "op", "title", "status", "created_at",
+              "started_at", "ended_at", "summary", "error", "paused", "direct_session",
+              "auto_resumes", "resume_enqueue_at", "cost_usd", "tokens")
+    summary = {key: run[key] for key in fields if key in run}
+    summary["step_count"] = len(run.get("steps") or [])
+    messages = run.get("messages") or []
+    summary["message_count"] = len(messages)
+    summary["pending_message_count"] = sum(1 for message in messages if not message.get("consumed"))
+    verdict = run.get("verdict") or {}
+    if isinstance(verdict, dict):
+        checks = ("pass", "publishable", "verify_pass", "review_pass")
+        compact = {key: verdict[key] for key in checks if key in verdict}
+        if compact:
+            summary["verdict"] = compact
+    return summary
+
+
 class ThreadedServer(ThreadingHTTPServer):
     """Windows 下 SO_REUSEADDR 允许两个进程同时 LISTEN 同一端口（请求随机
     分发到其中一个——服务"时好时坏"的根源）。独占锁让第二个实例在这里