codebee 0.1.28 → 0.1.30

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

@@ -52,6 +52,7 @@ def _utf8_bytes(data):
         return data.decode("utf-8", "replace").encode("utf-8")
 
 PORT = 8765  # main() 启动时更新；/api/connect 组装扫码地址用
+_BOOT_TS = time.time()  # 服务进程启动时间戳：/api/pet_state 下发，蜜蜂据此识别「服务换人了」并让位
 
 # 写接口统一限制 JSON 请求体，避免误传文件或异常客户端把 worker 线程和
 # 内存拖垮。16 MiB 足够覆盖任务上下文、故事圣经和附件清单（附件本体走
@@ -283,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)
@@ -312,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 只看单端口。只读，不碰任何进程。
@@ -1079,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()})
@@ -1468,6 +1490,7 @@ class Handler(BaseHTTPRequestHandler):
         「刚完工/刚出事」。设置随响应回传，蜜蜂轮询到 pet_enabled=false 自行
         退出——关闭桌宠不需要专门的信号通道。
         """
+        global _BOOT_TS
         st = settings.load()
         rows = []
         n_run = n_q = 0
@@ -1500,6 +1523,10 @@ class Handler(BaseHTTPRequestHandler):
             dg = {"unseen": 0, "latest": None}
         return self._json(200, {
             "ok": True, "ts": int(time.time()), "port": PORT,
+            # boot：本服务进程的启动时间戳。蜜蜂记住首次见到的值，值变了说明
+            # 服务换了个进程（升级重启）——旧蜜蜂自行退场让新服务 spawn 新蜜蜂
+            # （旧形象常驻的根因：同端口轮询永远正常，旧进程从不自离）。
+            "boot": _BOOT_TS,
             "settings": {"pet_enabled": bool(st.get("pet_enabled", True)),
                          "pet_mode": str(st.get("pet_mode") or "always"),
                          "pet_skin": str(st.get("pet_skin") or "plush")},

package/app/pet.py

@@ -82,6 +82,8 @@ def parse_snapshot(raw):
             "error": str(t.get("error") or ""),
         })
     return {
+        # boot：服务进程启动标识（值变化=服务换人，本宠让位给新服务的蜜蜂）
+        "boot": raw.get("boot") or None,
         "settings": {
             "pet_enabled": bool(st.get("pet_enabled", True)),
             "pet_mode": str(st.get("pet_mode") or "always"),
@@ -166,6 +168,7 @@ def _short(text, limit=22):
 LANG = {
     "zh": {
         "open": "打开 CodeBee",
+        "digest": "群摘要",
         "mode": "显示模式",
         "always": "常驻显示",
         "tasks_only": "仅任务运行时出现",
@@ -195,6 +198,7 @@ LANG = {
     },
     "en": {
         "open": "Open CodeBee",
+        "digest": "Group Digests",
         "mode": "Display mode",
         "always": "Always visible",
         "tasks_only": "Only when tasks run",
@@ -309,7 +313,6 @@ KEY_RGB = (1, 2, 3)
 WIN_W, WIN_H = 170, 150          # 手绘回落模式的窗口尺寸
 SPRITE_DIR = Path(__file__).resolve().parent
 SPRITE_DISP_H = 112              # 精灵显示高度（宽等比）
-PROG_H = 16                      # 底部进度条预留高度（有进度时才显示）
 
 
 def _pid_alive(pid):
@@ -371,6 +374,9 @@ _BROWSER_EXES = {
 }
 
 
+petWindow = None
+
+
 def _window_process_name(hwnd):
     """取顶层窗口所属进程的可执行文件名（小写）；失败返回空串。"""
     try:
@@ -400,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
@@ -422,22 +426,55 @@ 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 None
+        return found[0]
+    except Exception:
+        return None
+
+
+def _show_pet_window(port, ignore_hwnd=None):
+    """复用桌宠拉起的 CodeBee 浏览器窗口；窗口已关闭时返回 False。"""
+    global petWindow
+    try:
+        if os.name != "nt":
+            return False
+        import ctypes
+        user32 = ctypes.windll.user32
+        if petWindow and user32.IsWindow(petWindow):
+            if user32.IsIconic(petWindow):
+                user32.ShowWindow(petWindow, 9)   # SW_RESTORE
+            user32.SetForegroundWindow(petWindow)
+            return True
+        petWindow = None
+        hwnd = _find_codebee_window(port, ignore_hwnd)
+        if not hwnd:
             return False
-        target = found[0]
-        if user32.IsIconic(target):
-            user32.ShowWindow(target, 9)      # SW_RESTORE：最小化先还原
-        user32.SetForegroundWindow(target)
+        petWindow = hwnd
+        if user32.IsIconic(hwnd):
+            user32.ShowWindow(hwnd, 9)
+        user32.SetForegroundWindow(hwnd)
         return True
     except Exception:
         return False
 
 
+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(url or ("http://127.0.0.1:%d" % port))
+
+
 class PetApp:
     """蜜蜂窗口：蜜蜂本体（精灵/手绘）+ 状态机动画 + 悬停任务清单 + 右键菜单。"""
 
@@ -485,6 +522,7 @@ class PetApp:
         # 运行态
         self.snap = None
         self.miss = 0
+        self.boot = None    # 首次见到的服务 boot 标识；变化=服务换进程，本宠让位
         self.prev_active = set()
         self.mood_kind, self.mood_until = "", 0.0
         self.last_busy = time.time()
@@ -592,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")
@@ -638,18 +695,19 @@ class PetApp:
     def _size_for(self, frames):
         fw = max(f.width() for lst in frames.values() for f in lst)
         fh = max(f.height() for lst in frames.values() for f in lst)
-        return int(fw) + 8, int(fh) + PROG_H + 4
+        return int(fw) + 8, int(fh) + 4
 
     # ---- 蜜蜂绘制（精灵模式：贴图 + 状态点缀画件）----
-    # 用户拍板去掉：右上徽章、左侧速度线、底部影子（真机截图圈删）——
-    # 窗口贴着蜂体开，点缀只留睡觉 Zzz / 庆祝星光 / 底部进度条。
+    # 用户拍板去掉：右上徽章、左侧速度线、底部影子（真机截图圈删）、
+    # 底部任务进度条（2026-09-21 真机截图圈删）——
+    # 窗口贴着蜂体开，点缀只留睡觉 Zzz / 庆祝星光。
     def _build_sprite(self):
         cv = self.cv
-        cx, cy = self.win_w // 2, (self.win_h - PROG_H) // 2 + 2
+        cx, cy = self.win_w // 2, self.win_h // 2 + 2
         self._spr_c = (cx, cy)
         self.spr = cv.create_image(cx, cy, image=self.frames["alert"][0],
                                    anchor="center")
-        hw, hh = self.win_w / 2, (self.win_h - PROG_H) / 2
+        hw, hh = self.win_w / 2, self.win_h / 2
         self.zzz = [cv.create_text(cx + hw - 12, cy - hh + 14, text="z",
                                    fill="#8A93A6",
                                    font=("Segoe UI", 11, "italic bold")),
@@ -671,15 +729,6 @@ class PetApp:
         for grp in (self.zzz, self.spark):
             for i in grp:
                 cv.itemconfigure(i, state="hidden")
-        # 底部进度条（工作且有步骤进度才出现）
-        self.pbar_bg = cv.create_rectangle(cx - 34, self.win_h - 7,
-                                           cx + 34, self.win_h - 2,
-                                           fill="#202A36", outline="#3A4654")
-        self.pbar_fg = cv.create_rectangle(cx - 33, self.win_h - 6,
-                                           cx - 32, self.win_h - 3,
-                                           fill="#7ED07E", outline="")
-        cv.itemconfigure(self.pbar_bg, state="hidden")
-        cv.itemconfigure(self.pbar_fg, state="hidden")
         self.ox = self.oy = 0.0
         self._t0 = time.time()
 
@@ -867,14 +916,6 @@ class PetApp:
         self._palette = {i: cv.itemcget(i, "fill")
                          for i in (self.body, self.belly)}
 
-        # —— 贴地件：进度条（用户拍板去掉影子）——
-        self.pbar_bg = cv.create_rectangle(46, 139, 128, 147, fill="#202A36",
-                                           outline="#3A4654")
-        self.pbar_fg = cv.create_rectangle(47, 140, 48, 146, fill="#7ED07E",
-                                           outline="")
-        cv.itemconfigure(self.pbar_bg, state="hidden")
-        cv.itemconfigure(self.pbar_fg, state="hidden")
-
         # 动画游标
         self.ox = self.oy = 0.0
         self._t0 = time.time()
@@ -923,26 +964,9 @@ class PetApp:
                 cv.itemconfigure(self.body, fill=self._palette[self.body])
                 cv.itemconfigure(self.belly, fill=self._palette[self.belly])
                 cv.itemconfigure(self.gloss, state="normal")
-        # —— 共同：Zzz / 星光 / 进度条（徽章与速度线已按用户要求移除）——
+        # —— 共同：Zzz / 星光（徽章、速度线、进度条均已按用户要求移除）——
         self._show(self.zzz, False)
         self._show(self.spark, False)
-        prog = []
-        if st == "work" and self.snap:
-            prog = [t for t in self.snap["tasks"]
-                    if t["run_status"] == "running" and t["steps_total"]]
-        if prog:
-            done = sum(t["steps_done"] for t in prog)
-            total = sum(t["steps_total"] for t in prog)
-            ratio = max(0.0, min(1.0, done / float(total)))
-            x0 = (self.win_w // 2) - 34
-            cv.itemconfigure(self.pbar_bg, state="normal")
-            cv.itemconfigure(self.pbar_fg, state="normal")
-            cv.coords(self.pbar_bg, x0, self.win_h - 7, x0 + 68,
-                      self.win_h - 2)
-            cv.coords(self.pbar_fg, x0 + 1, self.win_h - 6,
-                      x0 + 1 + 66 * ratio, self.win_h - 3)
-        else:
-            self._show([self.pbar_bg, self.pbar_fg], False)
 
     def _post_settings(self, body):
         """合并并串行发送设置，保证快速连点时最后一次选择最终生效。"""
@@ -1029,6 +1053,15 @@ class PetApp:
         else:
             self.miss = 0
         if snap is not None:
+            # 服务换人检测（升级重启同端口场景）：boot 与首次见到的不一致，
+            # 说明响应来自新进程——本进程是旧代码的遗老，立即让位，新服务的
+            # 看护会 spawn 带新形象的新蜜蜂（旧形象常驻的根因修复）。
+            boot = snap.get("boot")
+            if boot:
+                if self.boot is None:
+                    self.boot = boot
+                elif boot != self.boot:
+                    return self._bye()
             self._reconcile_desired_settings(snap, confirmed_at_poll_start)
             if not snap["settings"]["pet_enabled"]:
                 return self._bye()
@@ -1330,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"),
@@ -1373,17 +1407,20 @@ class PetApp:
         self.lang = lang
         self._save_cfg(lang=lang)
 
-    def _open_ui(self):
+    def _open_ui(self, hash_part=""):
         try:
-            url = "http://127.0.0.1:%d" % self.port
-            # 已开过就不新开：Windows 上先找现有 CodeBee 浏览器窗口置前，
-            # 找不到（没开/标签不在前台）才回退 webbrowser.open 新开。
-            if os.name == "nt" and _focus_codebee_window(self.root.winfo_id()):
-                return
-            webbrowser.open(url)
+            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")