codebee 0.1.17 → 0.1.19

package/app/main.py

@@ -24,6 +24,7 @@ from core import automation, catalog, flows, jobs, manager, market, market_remot
 from core import paths
 from core import health
 import pick_dialog
+import pet
 
 log = logging.getLogger(__name__)
 
@@ -233,6 +234,9 @@ class Handler(BaseHTTPRequestHandler):
             if path == "/api/skills":
                 from core import skills
                 return self._json(200, skills.view())
+            if path == "/api/knowledge":
+                from core import knowledge
+                return self._json(200, knowledge.view())
             if path == "/api/settings":
                 return self._json(200, dict(settings.load(), **jobs.workers_info()))
             if path == "/api/settings-v2":
@@ -261,6 +265,8 @@ class Handler(BaseHTTPRequestHandler):
                 return self._json(200, {"ok": True, "catalog": manager.catalog_view()})
             if path == "/api/runs":
                 return self._json(200, {"runs": store.list_runs()})
+            if path == "/api/pet_state":
+                return self._api_pet_state()
             if path == "/api/usage":
                 from core import usage
                 q = parse_qs(urlparse(self.path).query)
@@ -462,12 +468,27 @@ class Handler(BaseHTTPRequestHandler):
             if path == "/api/zentao":
                 from core import zentao
                 return self._json(200, zentao.view())
+            if path == "/api/wxdigest":
+                from core import wxdigest
+                try:
+                    return self._json(200, wxdigest.view())
+                except Exception:
+                    log.exception("wxdigest: view 失败")
+                    return self._json(500, {"error": "群摘要视图生成失败"})
             m = re.match(r"^/api/automation/([^/]+)$", path)
             if m:
                 t = automation.get_task(m.group(1))
                 return self._json(200, {"task": t}) if t else self._json(404, {"error": "not found"})
             if path == "/api/market":
                 return self._json(200, market.view())
+            if path == "/api/cleanup":
+                # 数据与备份页：清理配置 + 上次清理状态 + 当前可清理预估
+                from core import cleanup
+                try:
+                    return self._json(200, cleanup.status())
+                except Exception:
+                    log.exception("cleanup: status 失败")
+                    return self._json(500, {"error": "清理状态生成失败"})
             if path == "/api/market/remote":
                 q = parse_qs(urlparse(self.path).query)
                 return self._json(200, market_remote.view(
@@ -622,6 +643,9 @@ class Handler(BaseHTTPRequestHandler):
         m = re.match(r"^/api/publish/task/([^/]+)/(create-book|chapter|auto-publish)$", path)
         if m:
             return self._api_publish_task_op(m.group(1), m.group(2))
+        m = re.match(r"^/api/publish/task/([^/]+)/register-book$", path)
+        if m:
+            return self._api_publish_register_book(m.group(1))
         m = re.match(r"^/api/publish/task/([^/]+)/publish-all$", path)
         if m:
             return self._api_publish_auto(m.group(1))
@@ -835,6 +859,16 @@ class Handler(BaseHTTPRequestHandler):
             from core import skills
             n = skills.learn_from_run((self._body().get("run_id") or ""))
             return self._json(200, {"ok": True, "learned": n})
+        if path == "/api/knowledge/op":
+            from core import knowledge
+            body = self._body()
+            err = knowledge.entry_op(body.get("id") or "", body.get("op") or "",
+                                     fields=body.get("fields"))
+            return self._json(400, {"error": err}) if err else self._json(200, {"ok": True})
+        if path == "/api/knowledge/learn":
+            from core import knowledge
+            n = knowledge.learn_from_run((self._body().get("run_id") or ""))
+            return self._json(200, {"ok": True, "learned": n})
         m = re.match(r"^/api/flows/([^/]+)/reset$", path)
         if m:
             err = flows.reset_flow(m.group(1))
@@ -991,6 +1025,89 @@ class Handler(BaseHTTPRequestHandler):
             except ValueError as e:
                 return self._json(400, {"error": str(e)})
             return self._json(200, {"ok": True, "config": cfg})
+        if path == "/api/wxdigest/config":
+            from core import wxdigest
+            try:
+                cfg = wxdigest.save_config(self._body())
+            except ValueError as e:
+                return self._json(400, {"error": str(e)})
+            return self._json(200, {"ok": True, "config": cfg})
+        if path == "/api/wxdigest/scan":
+            from core import wxdigest
+            res = wxdigest.scan_now()    # 含模型调用，同步做（ThreadingHTTPServer 不堵别的请求）
+            return self._json(200, dict(res, ok=bool(res.get("ok"))))
+        if path == "/api/wxdigest/seen":
+            from core import wxdigest
+            return self._json(200, {"ok": True, "view": wxdigest.seen_clear()})
+        if path == "/api/wxdigest/groups":
+            from core import wxdigest
+            try:
+                groups = wxdigest.refresh_groups()   # sidecar 调用，秒级到几十秒（ThreadingHTTPServer 不堵）
+            except Exception as e:
+                return self._json(500, {"error": str(e)})
+            return self._json(200, {"ok": True, "groups": groups})
+        if path == "/api/wxdigest/to-knowledge":
+            from core import wxdigest
+            body = self._body()
+            try:
+                entry = wxdigest.digest_to_knowledge(str(body.get("id") or ""))
+            except Exception as e:
+                return self._json(400, {"error": str(e)})
+            return self._json(200, {"ok": True, "entry": entry})
+        if path == "/api/cleanup":
+            # op=run 立即清理（include_profiles=true 连浏览器缓存一起清，
+            # 平台登录态会丢需重新扫码）；否则只重扫预估不落盘
+            from core import cleanup
+            body = self._body()
+            try:
+                if body.get("op") == "run":
+                    r = cleanup.run_cleanup(
+                        include_profiles=bool(body.get("include_profiles")))
+                    return self._json(200, {"ok": True, "result": r})
+                return self._json(200, {"ok": True,
+                                        "plan": cleanup.plan(
+                                            include_profiles=bool(
+                                                body.get("include_profiles")))})
+            except Exception as e:
+                log.exception("cleanup: 执行失败")
+                return self._json(500, {"error": "清理执行失败：%s" % e})
+        if path == "/api/data/export":
+            # 整机备份导出：数据目录 + 任务工作目录打包 zip（含密钥，提示用户妥善保管）
+            from core import backup
+            body = self._body()
+            try:
+                info = backup.export_data(
+                    target_dir=str(body.get("target_dir") or ""),
+                    include_logs=body.get("include_logs", True),
+                    include_workspace=body.get("include_workspace", True))
+            except ValueError as e:
+                return self._json(400, {"error": str(e)})
+            except Exception as e:
+                log.exception("backup: 导出失败")
+                return self._json(500, {"error": "导出失败：%s" % e})
+            return self._json(200, {"ok": True, **info})
+        if path == "/api/data/import":
+            # op=inspect 预览（不落盘）；op=apply 应用（merge/replace + 路径重映射）
+            from core import backup
+            body = self._body()
+            try:
+                if body.get("op") == "apply":
+                    r = backup.apply_import(
+                        str(body.get("path") or ""),
+                        mode=str(body.get("mode") or "merge"),
+                        remap=body.get("remap", True),
+                        include_workspace=body.get("include_workspace", True))
+                    return self._json(200, {"ok": True, **r})
+                return self._json(200, {"ok": True,
+                                        "preview": backup.inspect_backup(
+                                            str(body.get("path") or ""))})
+            except ValueError as e:
+                return self._json(400, {"error": str(e)})
+            except Exception as e:
+                log.exception("backup: 导入失败")
+                return self._json(500, {"error": "导入失败：%s" % e})
+        if path == "/api/pick_file":
+            return self._api_pick_file()
         if path == "/api/zentao/test":
             from core import zentao
             body = self._body()
@@ -998,7 +1115,14 @@ class Handler(BaseHTTPRequestHandler):
             ok, msg = zentao.test_connection(
                 base_url=body.get("base_url"), account=body.get("account"),
                 password=pw or None)     # 空 = 用已保存密码
-            return self._json(200, {"ok": ok, "message": msg})
+            res = {"ok": ok, "message": msg}
+            if ok:
+                # 子路径部署被自动探测补全时回传有效地基，前端回填表单提醒保存
+                eff = zentao.resolved_base_url(body.get("base_url")) or \
+                    zentao.resolved_base_url(zentao.view()["config"].get("base_url"))
+                if eff:
+                    res["base_url"] = eff
+            return self._json(200, res)
         if path == "/api/zentao/scan":
             from core import zentao
             res = zentao.scan_now()      # 网络操作同步做（ThreadingHTTPServer 不堵别的请求）
@@ -1008,6 +1132,12 @@ class Handler(BaseHTTPRequestHandler):
             pid = (self._body() or {}).get("product")
             res = zentao.fetch_modules(pid)
             return self._json(200, dict(res, ok=bool(res.get("ok"))))
+        if path == "/api/zentao/products":
+            from core import zentao
+            return self._json(200, zentao.fetch_products())
+        if path == "/api/zentao/users":
+            from core import zentao
+            return self._json(200, zentao.fetch_users())
         # 外部目录路由必须在通配的 market/<id>/(install|remove) 之前——
         # 否则 "remote" 会被当成包名吞掉
         if path == "/api/market/remote/refresh":
@@ -1175,6 +1305,20 @@ class Handler(BaseHTTPRequestHandler):
             return self._json(400, {"error": err or "操作失败"})
         return self._json(200, {"ok": True, "started": True})
 
+    def _api_publish_register_book(self, task_id):
+        """人工登记平台已有作品（建书流程没走通/手工建书后的补账口）。"""
+        from core import store
+        from core.publish import manager as pub
+        if not store.get_task(task_id):
+            return self._json(404, {"error": "任务不存在"})
+        body = self._body() or {}
+        ok, err = pub.register_book(task_id, (body.get("platform") or "").strip(),
+                                    str(body.get("title") or ""),
+                                    book_id=str(body.get("book_id") or ""))
+        if not ok:
+            return self._json(400, {"error": err or "登记失败"})
+        return self._json(200, {"ok": True})
+
     def _api_publish_auto(self, task_id):
         """批量发布全部待发章节（publish/auto.py）。
 
@@ -1273,6 +1417,54 @@ class Handler(BaseHTTPRequestHandler):
         parent = "" if p.parent == p else str(p.parent)
         return self._json(200, {"path": str(p), "parent": parent, "dirs": dirs})
 
+    def _api_pet_state(self):
+        """桌面蜜蜂（app/pet.py 子进程）的喂食端点：任务近况最小集 + 相关设置。
+
+        数据与 /api/runs 同源（latest_run_by_task 全量扫描，内存操作），但只裁
+        出桌宠需要的字段；每任务一条（封顶 200），蜜蜂在进程内自行差分出
+        「刚完工/刚出事」。设置随响应回传，蜜蜂轮询到 pet_enabled=false 自行
+        退出——关闭桌宠不需要专门的信号通道。
+        """
+        st = settings.load()
+        rows = []
+        n_run = n_q = 0
+        latest = store.latest_run_by_task()
+        for tid in sorted(latest.keys(), reverse=True)[:200]:
+            run = latest[tid]
+            task = store.get_task(tid) or {}
+            rs = str(run.get("status") or "")
+            if rs == "running":
+                n_run += 1
+            elif rs == "queued":
+                n_q += 1
+            steps = run.get("steps") or []
+            cur = next((s for s in steps if s.get("status") == "running"), None)
+            rows.append({
+                "id": tid,
+                "title": str(task.get("title") or tid),
+                "type": str(task.get("type") or ""),
+                "run_status": rs,
+                "steps_done": sum(1 for s in steps if s.get("status") == "done"),
+                "steps_total": len(steps),
+                "step_current": str((cur.get("summary") or cur.get("agent_label")
+                                     or "") if cur else ""),
+                "error": str(run.get("error") or "")[:160],
+            })
+        try:
+            from core import wxdigest as _wxd   # 群摘要喂食：未读数+最新一条（失败兜底零值）
+            dg = _wxd.pet_digest()
+        except Exception:
+            dg = {"unseen": 0, "latest": None}
+        return self._json(200, {
+            "ok": True, "ts": int(time.time()), "port": PORT,
+            "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")},
+            "workers": {"running": n_run, "queued": n_q},
+            "tasks": rows,
+            "digest": dg,
+        })
+
     def _api_pick_folder(self):
         """系统原生「选择文件夹」对话框（工作目录「选择…」/点输入框用）。仅限本机：
         对话框弹在服务所在机器上，远端触发等于替别人开窗。pick_dialog.ask_directory
@@ -1293,6 +1485,24 @@ class Handler(BaseHTTPRequestHandler):
             return self._json(200, {"path": "", "fallback": fb, "error": err})
         return self._json(200, {"path": path or ""})
 
+    def _api_pick_file(self):
+        """系统原生「选择文件」对话框（导入备份包用）。仅限本机，同 _api_pick_folder；
+        没有 tkinter 时 fallback=true（本场景没有网页回落，前端提示手输路径）。"""
+        ip, fw = self._forwarded_ip()
+        if ip not in ("127.0.0.1", "::1") or fw:
+            return self._json(403, {"error": "文件选择仅限本机使用，请手动输入路径"})
+        body = self._body()
+        if not _PICK_LOCK.acquire(blocking=False):
+            return self._json(200, {"path": "", "busy": True})
+        try:
+            path, err, fb = pick_dialog.ask_file(str(body.get("initial") or ""),
+                                                 str(body.get("title") or "选择文件"))
+        finally:
+            _PICK_LOCK.release()
+        if err:
+            return self._json(200, {"path": "", "fallback": fb, "error": err})
+        return self._json(200, {"path": path or ""})
+
     def _api_dir_scan(self):
         """侧栏文件夹「查看文件」：递归列出该工作目录下的全部文件（左侧文件页树形展示）。
 
@@ -1970,6 +2180,56 @@ class ThreadedServer(ThreadingHTTPServer):
         super().server_bind()
 
 
+# ---------------------------------------------------------------- 桌面蜜蜂
+
+_PET_PROC = None   # 蜜蜂子进程句柄（看护线程专用，别的线程别碰）
+
+
+def _spawn_pet(port):
+    """拉起桌面蜜蜂子进程（app/pet.py：tkinter 自绘，死活不影响服务）。"""
+    global _PET_PROC
+    pet_py = Path(__file__).resolve().parent / "pet.py"
+    if not pet_py.exists():
+        return
+    env = dict(os.environ, PYTHONIOENCODING="utf-8")
+    # CREATE_NO_WINDOW 同 pick_dialog：控制台宿主下不给蜜蜂弹黑框
+    kw = {"creationflags": 0x08000000} if os.name == "nt" else {}
+    try:
+        _PET_PROC = subprocess.Popen(
+            [sys.executable, str(pet_py), "--port", str(port),
+             "--data-dir", str(paths.DATA_DIR)], env=env, **kw)
+        print("[CodeBee] 桌面蜜蜂已起飞（右键蜜蜂可设置；设置页可关闭）", flush=True)
+    except Exception as e:
+        print("[CodeBee] 桌面蜜蜂未能起飞（不影响其他功能）：%s" % e, flush=True)
+
+
+def _start_pet_keeper(port):
+    """蜜蜂看护线程：按设置自愈拉起（崩溃/被杀 5s 内补位）。
+
+    TUTTI_PET_DISABLED=1 完全静默（测试/无桌面环境）；关闭走设置
+    pet_enabled=false——蜜蜂轮询到后自离，看护线程也不再拉起，不存在
+    「关了又复活」。子进程与服务的生命周期解耦：服务被杀蜜蜂 1 分钟内
+    自灭（MAX_MISS），不留孤儿窗口。
+    """
+    if os.environ.get("TUTTI_PET_DISABLED") == "1":
+        return
+
+    def _loop():
+        while True:
+            try:
+                if settings.load().get("pet_enabled", True):
+                    if _PET_PROC is None or _PET_PROC.poll() is not None:
+                        # 全机唯一蜜蜂：别的服务实例（不同数据目录）已养蜂时
+                        # 不再拉起，否则桌面会出现多只（用户实测踩坑）
+                        if not pet.global_lock_held():
+                            _spawn_pet(port)
+            except Exception:
+                pass
+            time.sleep(5)
+
+    threading.Thread(target=_loop, name="pet-keeper", daemon=True).start()
+
+
 def main():
     parser = argparse.ArgumentParser(description="CodeBee 多智能体编排台")
     parser.add_argument("--host", default="0.0.0.0",
@@ -2034,6 +2294,13 @@ def main():
     n_lc = skills.migrate_lesson_categories()  # 分类字段上线前的教训按关键词回填（幂等，带备份）
     if n_lc:
         print("[CodeBee] 经验库：%d 条历史教训已自动归类" % n_lc)
+    try:
+        from core import knowledge
+        n_kd = knowledge.migrate_drafts_approved()  # 草稿闸门退役：历史草稿一次性转正（幂等）
+        if n_kd:
+            print("[CodeBee] 知识库：%d 条历史草稿已转正（默认直接参与注入）" % n_kd)
+    except Exception:
+        pass
     from core import usage
     _step("正在回填用量台账…")
     n_bf = usage.backfill_from_runs()  # 历史运行 token 回填台账（幂等，仅补缺失步骤）
@@ -2107,6 +2374,13 @@ def main():
             print("[CodeBee] 禅道集成：%d 条认领记录已加载" % n_zt)
     except Exception:
         pass
+    try:
+        from core import wxdigest
+        n_wx = wxdigest.start()   # 群摘要：加载监控配置与游标（调度挂在 automation tick）
+        if n_wx:
+            print("[CodeBee] 群摘要：%d 个群游标已加载" % n_wx)
+    except Exception:
+        pass
     tok = remote.token()
     import atexit
     import os as _os
@@ -2147,6 +2421,7 @@ def main():
         faulthandler.cancel_dump_traceback_later()  # 启动完成，看门狗退役（否则运行期每 20s 误报堆栈）
     except Exception:
         pass
+    _start_pet_keeper(args.port)   # 桌面蜜蜂：端口就绪后放出（设置可关；测试可禁）
     if remote.PUBLIC_URL:
         print("[CodeBee] 公网     %s/?token=%s   ← 任何网络可访问（反代回源已强制校验令牌）"
               % (remote.PUBLIC_URL, tok))