codebee 0.1.29 → 0.1.30

package/app/core/usage.py

@@ -655,11 +655,19 @@ def summary(days=30, recent_limit=30):
     }
 
 
-def estimate(task_type="", days=90):
-    """同类任务开跑前成本预估（借鉴 omnigent 的 pre-run estimate；数据源就是本台账）。
-
-    同一 run 的多条步骤记录加总为一个样本，优先用成功 run，给中位数/平均/P90。
-    task_type 为空=全类型。无样本时 samples=0，前端不展示。"""
+_DURATION_BASELINES = {
+    "direct": 90, "rank_scan": 240, "email": 180, "weekly_report": 240,
+    "translation": 240, "speech": 360, "video_script": 360, "article": 480,
+    "doc": 480, "resume": 420, "code": 600, "tech_proposal": 720,
+    "research": 900, "novel": 720, "serial_novel": 2400,
+}
+
+
+def estimate(task_type="", days=90, mode="auto", thinking="standard", rounds=None):
+    """同类任务开跑前成本与耗时预估（数据源为本地用量台账）。
+
+    同一 run 的多条步骤记录加总为一个样本，优先用成功 run，给中位数/平均/P90。
+    无历史样本时使用流程级保守基线；模式与思考程度只做透明倍率修正。"""
     span = max(1, min(3650, int(days or 90)))
     with LOCK:
         records = _iter_records(span)
@@ -671,24 +679,53 @@ def estimate(task_type="", days=90):
         rid = str(r.get("run_id") or "")
         if not rid:
             continue
-        g = runs.setdefault(rid, {"tokens": 0, "cost": 0.0, "ok": False})
-        g["tokens"] += _num(r, "total")
-        g["cost"] += _parse_float(r.get("cost_usd"))
+        g = runs.setdefault(rid, {"tokens": 0, "cost": 0.0,
+                                  "duration": 0.0, "ok": False})
+        g["tokens"] += _num(r, "total")
+        g["cost"] += _parse_float(r.get("cost_usd"))
+        g["duration"] += max(0.0, _parse_float(r.get("duration_s")))
         if r.get("ok"):
             g["ok"] = True
     ok_runs = [g for g in runs.values() if g["ok"]]
     basis = ok_runs or list(runs.values())
-    if not basis:
-        return {"task_type": task_type or "", "days": span, "samples": 0}
+    mode_factor = {"fast": 0.60, "auto": 1.0, "expert": 1.65,
+                   "manual": 1.0}.get(str(mode or "auto"), 1.0)
+    thinking_factor = {"low": 0.78, "standard": 1.0, "high": 1.45,
+                       "auto": 1.0}.get(str(thinking or "standard"), 1.0)
+    factor = mode_factor * thinking_factor
+    try:
+        if rounds is not None and int(rounds) > 2:
+            factor *= 1.0 + min(3, int(rounds) - 2) * 0.18
+    except (TypeError, ValueError):
+        pass
+    if not basis:
+        baseline = _DURATION_BASELINES.get(task_type, 480)
+        median_s = max(30, int(baseline * factor))
+        return {"task_type": task_type or "", "days": span, "samples": 0,
+                "estimated_duration_s": median_s,
+                "p90_duration_s": max(median_s + 30, int(median_s * 1.7)),
+                "duration_source": "baseline"}
     toks = sorted(g["tokens"] for g in basis)
-    costs = sorted(g["cost"] for g in basis)
+    costs = sorted(g["cost"] for g in basis)
+    durations = sorted(g["duration"] for g in basis if g["duration"] > 0)
     n = len(toks)
     mid = n // 2
     med = toks[mid] if n % 2 else (toks[mid - 1] + toks[mid]) / 2.0
     med_c = costs[mid] if n % 2 else (costs[mid - 1] + costs[mid]) / 2.0
     import datetime
-    import math
-    return {
+    import math
+    if durations:
+        dn = len(durations)
+        dmid = dn // 2
+        dmed = (durations[dmid] if dn % 2
+                else (durations[dmid - 1] + durations[dmid]) / 2.0)
+        dp90 = durations[max(0, min(dn - 1, math.ceil(0.9 * dn) - 1))]
+        duration_source = "history"
+    else:
+        dmed = _DURATION_BASELINES.get(task_type, 480)
+        dp90 = dmed * 1.7
+        duration_source = "baseline"
+    return {
         "task_type": task_type or "",
         "days": span,
         "samples": n,
@@ -697,6 +734,10 @@ def estimate(task_type="", days=90):
         "median_tokens": int(med),
         "p90_tokens": toks[max(0, min(n - 1, math.ceil(0.9 * n) - 1))],
         "avg_cost_usd": round(sum(costs) / n, 4),
-        "median_cost_usd": round(med_c, 4),
+        "median_cost_usd": round(med_c, 4),
+        "estimated_duration_s": max(30, int(dmed * factor)),
+        "p90_duration_s": max(60, int(dp90 * factor)),
+        "duration_samples": len(durations),
+        "duration_source": duration_source,
         "since": (datetime.date.today() - datetime.timedelta(days=span - 1)).isoformat(),
     }

package/app/core/wxdigest.py

@@ -20,6 +20,7 @@ import json
 import logging
 import os
 import re
+import subprocess
 import threading
 import time
 from datetime import datetime, timedelta
@@ -708,3 +709,142 @@ def _test_reset():
         _STATE["groups_cache"] = []
         _STATE["last_scan"] = _STATE["next_scan"] = _STATE["last_error"] = ""
         globals()["_LOADED"] = True
+
+
+# ---- 64 位 Python 自动扫描 + wechatauto-replica 一键安装（2026-09-21 用户诉求：
+#      别让用户手填解释器路径、别让用户自己开 conda 装依赖）----
+
+_PY_SCAN = {"scanning": False, "done": True, "results": []}
+_PY_INSTALL = {"running": False, "ok": None, "python": "", "log": []}
+_REPLICA_PKG = "wechatauto-replica"
+
+
+def _candidate_pythons():
+    """收集本机候选解释器路径（去重、存在性过滤）。只列不判，位数/依赖交给探测。"""
+    import glob
+    cands = []
+
+    def _add(p):
+        p = str(p).strip().strip('"')
+        if p and os.path.isfile(p) and p.lower().endswith((".exe",)) is not False:
+            if p not in cands and "python" in os.path.basename(p).lower():
+                cands.append(p)
+
+    if os.name == "nt":
+        home = os.environ.get("USERPROFILE") or ""
+        patterns = [
+            os.path.join(home, "anaconda3", "envs", "*", "python.exe"),
+            os.path.join(home, "miniconda3", "envs", "*", "python.exe"),
+            os.path.join(home, ".conda", "envs", "*", "python.exe"),
+            os.path.join(os.environ.get("LOCALAPPDATA") or "", "Programs",
+                         "Python", "*", "python.exe"),
+            r"C:\Python*\python.exe",
+            os.path.join(home, "AppData", "Local", "anaconda3", "python.exe"),
+            os.path.join(home, "anaconda3", "python.exe"),
+            os.path.join(home, "miniconda3", "python.exe"),
+        ]
+        for pat in patterns:
+            for p in glob.glob(pat):
+                _add(p)
+        try:
+            r = subprocess.run(["cmd", "/c", "where", "python"],
+                               capture_output=True, timeout=15)
+            for ln in r.stdout.decode("utf-8", "replace").splitlines():
+                _add(ln)
+        except Exception:
+            pass
+    else:
+        import glob as _g
+        for pat in ("/usr/bin/python3*", "/usr/local/bin/python3*",
+                    os.path.expanduser("~/.conda/envs/*/bin/python3"),
+                    os.path.expanduser("~/miniconda3/envs/*/bin/python3"),
+                    os.path.expanduser("~/anaconda3/envs/*/bin/python3")):
+            for p in _g.glob(pat):
+                _add(p)
+    return cands[:24]
+
+
+def _probe_python(py):
+    """探测解释器：返回 {path, version, bits} 或 None（跑不动/不是 python）。"""
+    try:
+        r = subprocess.run(
+            [py, "-c", "import sys,struct;print('%d.%d'%sys.version_info[:2],"
+                       "struct.calcsize('P')*8)"],
+            capture_output=True, timeout=20,
+            creationflags=CREATE_NO_WINDOW if os.name == "nt" else 0)
+        out = (r.stdout or b"").decode("utf-8", "replace").strip()
+        ver, bits = out.split()
+        return {"path": py, "version": ver, "bits": int(bits)}
+    except Exception:
+        return None
+
+
+def _has_replica(py):
+    """该环境是否已装 wechatauto-replica（pip show 探测，失败视为未装）。"""
+    try:
+        r = subprocess.run([py, "-m", "pip", "show", _REPLICA_PKG],
+                           capture_output=True, timeout=60,
+                           creationflags=CREATE_NO_WINDOW if os.name == "nt" else 0)
+        return r.returncode == 0
+    except Exception:
+        return False
+
+
+def scan_pythons():
+    """启动后台扫描（幂等：扫描中重复调用直接忽略）。返回当前状态。"""
+    if _PY_SCAN["scanning"]:
+        return dict(_PY_SCAN)
+
+    def _run():
+        _PY_SCAN.update(scanning=True, done=False, results=[])
+        found = []
+        for py in _candidate_pythons():
+            info = _probe_python(py)
+            if not info:
+                continue
+            info["has_replica"] = _has_replica(py)
+            found.append(info)
+        # 排序：64 位优先 → 已装 replica 优先 → 版本新优先 → 路径短优先
+        found.sort(key=lambda x: (x["bits"] < 64, not x["has_replica"],
+                                  x["version"], len(x["path"])), reverse=False)
+        found.sort(key=lambda x: (x["bits"] >= 64, x["has_replica"]))
+        _PY_SCAN.update(scanning=False, done=True, results=found)
+
+    threading.Thread(target=_run, name="wx-py-scan", daemon=True).start()
+    return dict(_PY_SCAN)
+
+
+def pythons_status():
+    return dict(_PY_SCAN)
+
+
+def install_replica(py):
+    """一键安装 wechatauto-replica 到指定解释器（后台 pip，状态可轮询）。"""
+    py = str(py or "").strip()
+    if not py or not os.path.isfile(py):
+        return {"ok": False, "error": "解释器路径无效"}
+    if _PY_INSTALL["running"]:
+        return {"ok": False, "error": "已有安装在跑，请等它结束"}
+
+    def _run():
+        _PY_INSTALL.update(running=True, ok=None, python=py, log=[])
+        try:
+            r = subprocess.run(
+                [py, "-m", "pip", "install", _REPLICA_PKG],
+                capture_output=True, timeout=900,
+                creationflags=CREATE_NO_WINDOW if os.name == "nt" else 0)
+            ok = r.returncode == 0
+            tail = ((r.stderr or b"").decode("utf-8", "replace")
+                    or (r.stdout or b"").decode("utf-8", "replace"))[-1500:]
+        except Exception as e:
+            ok, tail = False, str(e)[:500]
+        _PY_INSTALL.update(running=False, ok=ok, log=tail.strip().splitlines()[-25:])
+        if ok:
+            scan_pythons()   # 装完自动重扫，has_replica 标记即时生效
+
+    threading.Thread(target=_run, name="wx-replica-install", daemon=True).start()
+    return {"ok": True}
+
+
+def install_status():
+    return dict(_PY_INSTALL)

package/app/main.py

@@ -284,7 +284,12 @@ class Handler(BaseHTTPRequestHandler):
                     edays = max(1, min(3650, int((q.get("days") or ["90"])[0])))
                 except ValueError:
                     edays = 90
-                return self._json(200, usage.estimate(task_type=ttype, days=edays))
+                mode = (q.get("mode") or ["auto"])[0][:16]
+                thinking = (q.get("thinking") or ["standard"])[0][:16]
+                rounds = (q.get("rounds") or [None])[0]
+                return self._json(200, usage.estimate(
+                    task_type=ttype, days=edays, mode=mode,
+                    thinking=thinking, rounds=rounds))
             if path == "/api/dispatch/replay":
                 from core import dispatch_log
                 q = parse_qs(urlparse(self.path).query)
@@ -313,6 +318,13 @@ class Handler(BaseHTTPRequestHandler):
                 # 偏好记忆：上次创建任务的类型/参数（新建表单预填用）
                 from core import prefs
                 return self._json(200, {"prefs": prefs.load()})
+            if path == "/api/wxdigest/pythons":
+                # 64 位 Python 候选（蜜蜂坞微信直连配置）：扫描后台跑，此端点轮询
+                from core import wxdigest
+                return self._json(200, wxdigest.pythons_status())
+            if path == "/api/wxdigest/replica/status":
+                from core import wxdigest
+                return self._json(200, wxdigest.install_status())
             if path == "/api/ports":
                 # 端口占用诊断（借鉴 leftopen）：谁在听、PID/进程/项目归属、
                 # 是否仅本机。?port=N 只看单端口。只读，不碰任何进程。
@@ -1080,6 +1092,15 @@ class Handler(BaseHTTPRequestHandler):
             from core import wxdigest
             res = wxdigest.scan_now()    # 含模型调用，同步做（ThreadingHTTPServer 不堵别的请求）
             return self._json(200, dict(res, ok=bool(res.get("ok"))))
+        if path == "/api/wxdigest/pythons/scan":
+            # 64 位 Python 自动扫描（后台线程，GET /api/wxdigest/pythons 轮询）
+            from core import wxdigest
+            return self._json(200, wxdigest.scan_pythons())
+        if path == "/api/wxdigest/replica/install":
+            # 一键安装 wechatauto-replica 到指定解释器（后台 pip，状态可轮询）
+            from core import wxdigest
+            res = wxdigest.install_replica(self._body().get("python"))
+            return self._json(200 if res.get("ok") else 400, res)
         if path == "/api/wxdigest/seen":
             from core import wxdigest
             return self._json(200, {"ok": True, "view": wxdigest.seen_clear()})

package/app/pet.py

@@ -168,6 +168,7 @@ def _short(text, limit=22):
 LANG = {
     "zh": {
         "open": "打开 CodeBee",
+        "digest": "群摘要",
         "mode": "显示模式",
         "always": "常驻显示",
         "tasks_only": "仅任务运行时出现",
@@ -197,6 +198,7 @@ LANG = {
     },
     "en": {
         "open": "Open CodeBee",
+        "digest": "Group Digests",
         "mode": "Display mode",
         "always": "Always visible",
         "tasks_only": "Only when tasks run",
@@ -404,10 +406,8 @@ def _window_process_name(hwnd):
     return ""
 
 
-def _focus_codebee_window(ignore_hwnd=None):
-    """Windows：已打开过 CodeBee 浏览器页时，把那个窗口找出来还原并置前，
-    避免每点一次桌宠就新开一个浏览器窗口。返回 True 表示已找到并尝试置前；
-    False 表示没有现成窗口，调用方应回退 webbrowser.open 新开。"""
+def _find_codebee_window(port, ignore_hwnd=None):
+    """查找当前端口对应的 CodeBee 浏览器顶层窗口，找不到返回 None。"""
     try:
         import ctypes
         from ctypes import wintypes
@@ -426,23 +426,22 @@ def _focus_codebee_window(ignore_hwnd=None):
                 return True
             buf = ctypes.create_unicode_buffer(length + 1)
             user32.GetWindowTextW(hwnd, buf, length + 1)
-            if "CodeBee" in buf.value:
+            title = buf.value
+            # 页面启动时把端口写入 document.title。只匹配当前服务端口，避免
+            # 把标题里碰巧含 CodeBee 的文档/仓库页或另一套本地实例抢到前台。
+            if "CodeBee" in title and ("[%s]" % int(port)) in title:
                 found.append(hwnd)
             return True
 
         user32.EnumWindows(EnumWindowsProc(_cb), 0)
         if not found:
-            return False
-        target = found[0]
-        if user32.IsIconic(target):
-            user32.ShowWindow(target, 9)      # SW_RESTORE：最小化先还原
-        user32.SetForegroundWindow(target)
-        return True
+            return None
+        return found[0]
     except Exception:
-        return False
+        return None
 
 
-def _show_pet_window(ignore_hwnd=None):
+def _show_pet_window(port, ignore_hwnd=None):
     """复用桌宠拉起的 CodeBee 浏览器窗口；窗口已关闭时返回 False。"""
     global petWindow
     try:
@@ -456,7 +455,7 @@ def _show_pet_window(ignore_hwnd=None):
             user32.SetForegroundWindow(petWindow)
             return True
         petWindow = None
-        hwnd = _find_codebee_window(ignore_hwnd)
+        hwnd = _find_codebee_window(port, ignore_hwnd)
         if not hwnd:
             return False
         petWindow = hwnd
@@ -468,10 +467,12 @@ def _show_pet_window(ignore_hwnd=None):
         return False
 
 
-def openPetWindow(port, ignore_hwnd=None):
-    if os.name == "nt" and _show_pet_window(ignore_hwnd):
+def openPetWindow(port, ignore_hwnd=None, url=None):
+    """打开 CodeBee 网页：Windows 先置前已打开的窗口（用户拍板「已打开就不重复
+    开」），找不到才用默认浏览器新开。url 可带锚点（如 #bee=1 直达蜜蜂坞）。"""
+    if os.name == "nt" and _show_pet_window(port, ignore_hwnd):
         return
-    webbrowser.open("http://127.0.0.1:%d" % port)
+    webbrowser.open(url or ("http://127.0.0.1:%d" % port))
 
 
 class PetApp:
@@ -629,7 +630,26 @@ class PetApp:
         try:
             from PIL import Image, ImageEnhance, ImageTk
         except Exception:
-            return None
+            # 无 Pillow：用 Tk 原生 PhotoImage 直接贴 PNG（Tk 8.6+ 原生解码，
+            # 零依赖）——此前直接回落手绘蜂，普通用户 npm 装完没有 Pillow，
+            # 看到的永远是手绘丑蜂（同事「还是老的丑蜜蜂」的真凶）。
+            # 限制：无平滑缩放/旋转，动画帧退化为静态贴图 + 位移点缀。
+            fname = SKINS.get(skin, SKINS[DEFAULT_SKIN])[0]
+            try:
+                img = self.tk.PhotoImage(file=str(SPRITE_DIR / fname))
+            except Exception:
+                return None
+            h0 = max(1, img.height())
+            disp_h = max(60, int(SPRITE_DISP_H * SIZES.get(self.size_key, 1.0)))
+            scale = disp_h / h0
+            if scale < 0.9:
+                k = max(1, round(1 / scale))
+                img = img.subsample(k, k)
+            elif scale > 1.1:
+                k = max(1, round(scale))
+                img = img.zoom(k, k)
+            return {"alert": [img], "sleep": [img], "dead": [img],
+                    "work": [img], "cheer": [img]}
         fname = SKINS.get(skin, SKINS[DEFAULT_SKIN])[0]
         try:
             base0 = Image.open(SPRITE_DIR / fname).convert("RGBA")
@@ -1343,6 +1363,7 @@ class PetApp:
         self._lang_var.set(self.lang)
         m = self.tk.Menu(self.root, tearoff=0)
         m.add_command(label=self._L("open"), command=self._open_ui)
+        m.add_command(label=self._L("digest"), command=self._open_digest)
         m.add_separator()
         m.add_command(label="◎ " + self._L("mode"), state="disabled")
         m.add_radiobutton(label="    " + self._L("always"),
@@ -1386,12 +1407,20 @@ class PetApp:
         self.lang = lang
         self._save_cfg(lang=lang)
 
-    def _open_ui(self):
+    def _open_ui(self, hash_part=""):
         try:
-            openPetWindow(self.port, self.root.winfo_id())
+            if hash_part:
+                openPetWindow(self.port, self.root.winfo_id(),
+                              url="http://127.0.0.1:%d/%s" % (self.port, hash_part))
+            else:
+                openPetWindow(self.port, self.root.winfo_id())
         except Exception:
             pass
 
+    def _open_digest(self):
+        """群摘要：打开网页并自动展开蜜蜂坞面板（样式与网页端统一）。"""
+        self._open_ui("#bee=1")
+
     def _bind_input(self):
         # 菜单变量须先于 _menu 存在
         self._mode_var = self.tk.StringVar(value="always")