xiumiagent 0.1.0__tar.gz

xiumiagent-0.1.0/.env.example

@@ -0,0 +1,14 @@
+# ===== LLM (OpenAI 兼容接口) =====
+# 智谱示例: https://open.bigmodel.cn/api/paas/v4  模型: glm-4.6
+# DeepSeek:  https://api.deepseek.com             模型: deepseek-chat
+OPENAI_BASE_URL=https://open.bigmodel.cn/api/paas/v4
+OPENAI_API_KEY=sk-xxx
+MODEL=glm-4.6
+
+# ===== 浏览器 =====
+# 留空则自动探测常见 Edge 安装路径
+EDGE_PATH=
+CDP_PORT=9222
+
+# ===== Agent =====
+MAX_STEPS=40

xiumiagent-0.1.0/MANIFEST.in

@@ -0,0 +1,5 @@
+include README.md
+include .env.example
+include TESTING.md
+recursive-include examples *.md
+recursive-include plugins *.json

xiumiagent-0.1.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: xiumiagent
+Version: 0.1.0
+Summary: TUI agent that drives your Edge browser via CDP to auto-produce WeChat article layouts on xiumi.us (command: xiumi)
+Requires-Python: >=3.10
+Requires-Dist: textual>=0.60
+Requires-Dist: openai>=1.40
+Requires-Dist: websockets>=12
+Requires-Dist: python-dotenv>=1.0
+Provides-Extra: dev

xiumiagent-0.1.0/README.md

@@ -0,0 +1,79 @@
+# xiumi-agent
+
+终端 TUI 形态的公众号排版 Agent：通过 CDP 直接驱动你本机的 **Edge** 打开 **秀米（xiumi.us）**，由 LLM 调用插件工具自动完成「写稿 → 排版 → 插图 → 保存草稿」。
+
+## 架构
+
+```
+TUI (Textual) ──事件总线──▶ Agent 主循环 (OpenAI 兼容 function calling)
+                                  │ 工具调用
+                            插件管理器（browser / xiumi_login / xiumi_editor）
+                                  │ JS 模拟用户操作 + CDP 特例(截图/上传文件/真实按键)
+                          Edge (msedge.exe, 独立 profile, CDP 9222)
+```
+
+- **插件化**：核心只有主循环+注册表；所有网页能力都是 `plugins/*/plugin.py` 里的 Plugin，挂载即用
+- **凭据安全**：账号密码只在 TUI 模态框输入，直达登录插件执行，不进 LLM 上下文
+- **选择器可维护**：`plugins/*/selectors.json` 集中管理，`recon` 踩点后直接改 JSON
+
+## 快速开始
+
+**方式一：一条命令远程安装（推荐，无需克隆）**
+
+```powershell
+pip install git+https://github.com/ZMJJKK123-hub/xiumi_agent.git
+xiumi                      # 任意目录、任意终端直接进入 TUI
+```
+
+首次运行会在 `~/.xiumi-agent/.env` 自动生成配置模板，填入 `OPENAI_API_KEY` 后重启即可。
+
+**方式二：源码运行**
+
+```bash
+git clone https://github.com/ZMJJKK123-hub/xiumi_agent.git
+cd xiumi_agent
+pip install -r requirements.txt
+pip install -e .            # 安装全局命令 xiumi（一次性）
+copy .env.example .env      # 填 OPENAI_API_KEY / OPENAI_BASE_URL / MODEL
+xiumi                       # 或 python main.py
+```
+
+`xiumi recon` = 页面踩点，`xiumi version` = 版本。
+
+首次使用：TUI 弹出登录窗口 → 选「微信扫码」（二维码图片自动弹出）或「账号密码」→ 登录一次长期保留。
+
+## 用法
+
+```
+输入任务回车：写一篇秋天咖啡店探店推文，主色暖棕，结尾引导关注
+/file examples/task.md      载入文件任务（支持 [img:路径] 图片位置标记）
+/login                      重新打开登录窗口
+/shot                       截图当前页面
+Ctrl+Q 退出 · Ctrl+L 清屏
+```
+
+任务两种姿势：
+- **全自动**：只给主题 → Agent 写全文 + 排版 + 保存
+- **只排版**：给正文 → Agent 只做排版加工
+
+图片：在正文任意位置写 `[img:D:\pics\a.jpg]`，Agent 会上传到秀米图库并插入该位置（无需多模态模型）。
+
+## 踩点（重要）
+
+插件里的选择器是启发式默认值。如果页面操作失败，运行：
+
+```bash
+python main.py recon        # dump 登录页/首页 DOM 树 + 截图到 recon/
+```
+
+人工确认选择器后更新 `plugins/xiumi_login/selectors.json` 与 `plugins/xiumi_editor/selectors.json`。手动登录秀米后，把编辑器 URL 加进 `scripts/recon.py` 的 `TARGETS` 再跑一次即可踩编辑器。
+
+## 目录
+
+```
+core/      agent 主循环 / LLM 客户端 / 工具注册表 / 插件契约 / 事件总线
+cdp/       CDP 连接 / Edge 管理 / Tab 封装 / 注入式 JS 操作库
+tui/       Textual 界面（聊天面板、动作面板、登录/账密模态屏）
+plugins/   browser 通用操控 · tool_browser 后台浏览器(dsh适配) · xiumi_login 登录 · xiumi_editor 排版
+scripts/   recon.py 页面踩点
+```

xiumiagent-0.1.0/TESTING.md

@@ -0,0 +1,56 @@
+# 自测指南
+
+## 安装与一次性准备
+
+```powershell
+pip install git+https://github.com/ZMJJKK123-hub/xiumi_agent.git   # 远程一条命令安装
+notepad %USERPROFILE%\.xiumi-agent\.env                            # 首次运行 xiumi 后自动生成，填 OPENAI_API_KEY
+xiumi                                                               # 任意目录直接进
+```
+
+首次启动会自动拉起 Edge 打开秀米 → 弹登录窗口（**扫码**：二维码自动弹出系统看图器；**账密**：弹输入框，滑块验证码需你在浏览器里手动拖一下）。登录一次长期保留在 `.edge-profile/`。
+
+**登录成功后强烈建议做一次编辑器踩点**（当前编辑器选择器是启发式，踩点后更稳）：
+在 `scripts/recon.py` 的 `TARGETS` 里加一行（去掉注释）：`("editor", "https://xiumi.us/studio/v5"),`，然后：
+
+```powershell
+python main.py recon
+```
+
+把 `recon/editor_outline.json` 里确认的选择器更新到 `plugins/xiumi_editor/selectors.json`。
+
+## 逐项测试清单
+
+### 启动与登录
+- [ ] 欢迎卡：橙色圆角框、标题嵌上边框、左栏 Welcome back!/模型/目录，右栏 Tips / What's new
+- [ ] 未登录时弹登录窗（居中、深色按钮）；「账号密码登录」→ 填入 → 返回 → 「跳过」仍可点击（不卡死）
+- [ ] 扫码登录：二维码图片自动弹出
+
+### 输入与命令
+- [ ] 输入任务回车 → 灰底 `> 任务` 命令条回显
+- [ ] `/file examples/task.md` → 命令条折叠显示 `⏎ …(N 行)`（先把示例里的图片路径改成真实存在的）
+- [ ] `/shot` → 截图路径回显；`/login` → 登录窗弹出；`/file 不存在.md` → 红色 `X` 错误行
+- [ ] 空输入/纯空格回车 → 无任何输出且输入框被清空
+- [ ] 纯空格状态按 `?` → 帮助浮层（输入非空时 `?` 是普通字符）
+
+### Agent 任务（需 .env 已配）
+- [ ] 输入「写一篇秋天咖啡店探店推文，主色暖棕」→ spinner（橙符号+动词+秒数）+ 底栏变「esc 中断任务」
+- [ ] 工具行 `└ 工具名(参数)`、结果灰字折叠、空结果 `(no content)`
+- [ ] 任务中按 `esc` → 立即中断并显示提示；中断后再提交新任务正常
+- [ ] 完成后汇总 + `✻ 共 N 次工具调用` 统计行，底栏回到「? 快捷键」
+
+### 快捷键
+- [ ] `↑/↓` 翻输入历史（连按不越界，↓ 到底恢复未提交草稿）
+- [ ] `ctrl+l` 清屏重绘欢迎卡；`ctrl+q` 退出
+
+### 任务后检查
+- [ ] Edge 里秀米草稿已保存：标题、正文块、图片位置正确
+- [ ] `screenshots/` 下有预览截图
+
+## 排错
+
+| 现象 | 处理 |
+|---|---|
+| 启动失败「端口 9222」 | 关掉残留 Edge（任务管理器搜 msedge）后重跑 |
+| 编辑器操作总失败 | 重跑 `python main.py recon` 更新选择器（秀米改版了） |
+| 改了代码想快速自检 | `python scripts/tui_smoke_test.py`（无头一键回归，不弹窗） |

xiumiagent-0.1.0/cdp/browser.py

@@ -0,0 +1,98 @@
+"""Edge 启动与标签页管理（独立自动化 profile）。"""
+from __future__ import annotations
+
+import subprocess
+from typing import Any
+
+from core.config import Config
+
+from .connection import CDPConnection
+from .helpers import Tab
+
+
+class BrowserNotReady(RuntimeError):
+    pass
+
+
+class EdgeBrowser:
+    def __init__(self, config: Config):
+        self.config = config
+        self.cdp: CDPConnection | None = None
+        self._proc: subprocess.Popen | None = None
+
+    # ---- 启动 ----
+    async def ensure_started(self) -> None:
+        """端口活着就复用已有 Edge；否则用独立 profile 启动一个。"""
+        if await self._port_alive():
+            return
+        if not self.config.edge_path:
+            raise BrowserNotReady(
+                "未找到 Edge，请在 .env 的 EDGE_PATH 指定 msedge.exe 路径"
+            )
+        args = [
+            self.config.edge_path,
+            f"--remote-debugging-port={self.config.cdp_port}",
+            f"--user-data-dir={self.config.profile_dir}",
+            "--remote-allow-origins=*",
+            "--no-first-run",
+            "--no-default-browser-check",
+            "--disable-session-crashed-bubble",
+            "--hide-crash-restore-bubble",
+            "--restore-last-session=false",
+            "about:blank",
+        ]
+        self._proc = subprocess.Popen(args, creationflags=subprocess.DETACHED_PROCESS | subprocess.CREATE_NEW_PROCESS_GROUP)
+        for _ in range(80):  # 最多等 20 秒
+            if await self._port_alive():
+                return
+            import asyncio
+
+            await asyncio.sleep(0.25)
+        raise BrowserNotReady(f"Edge 调试端口 {self.config.cdp_port} 未就绪")
+
+    async def _port_alive(self) -> bool:
+        probe: CDPConnection | None = None
+        try:
+            probe = await CDPConnection.connect(self.config.cdp_port, timeout=1.5)
+            return True
+        except Exception:
+            return False
+        finally:
+            if probe:
+                try:
+                    await probe.close()
+                except Exception:
+                    pass
+
+    async def connect(self) -> None:
+        self.cdp = await CDPConnection.connect(self.config.cdp_port)
+
+    # ---- 标签页 ----
+    async def get_or_create_tab(self, url_contains: str = "xiumi.us", default_url: str = "https://xiumi.us/") -> Tab:
+        """找 url 含 url_contains 的标签页；找不到就新建并导航到 default_url。"""
+        if not self.cdp:
+            raise BrowserNotReady("CDP 未连接")
+        pages = await self.cdp.list_pages()
+        for p in pages:
+            url = p.get("url", "")
+            if url_contains in url and "devtools" not in url:
+                return await self.attach_tab(p)
+        page = await self.cdp.new_tab(default_url)
+        return await self.attach_tab(page)
+
+    async def open_tab(self, url: str) -> Tab:
+        if not self.cdp:
+            raise BrowserNotReady("CDP 未连接")
+        page = await self.cdp.new_tab(url)
+        return await self.attach_tab(page)
+
+    async def attach_tab(self, target_info: dict[str, Any]) -> Tab:
+        session_id = await self.cdp.attach(target_info["targetId"])
+        tab = Tab(self.cdp, session_id, target_info)
+        await tab.enable()
+        return tab
+
+    async def shutdown(self) -> None:
+        if self.cdp:
+            await self.cdp.close()
+            self.cdp = None

xiumiagent-0.1.0/cdp/connection.py

@@ -0,0 +1,158 @@
+"""CDP 浏览器级 WebSocket 连接（flat session 模式）。
+
+一条浏览器级连接即可操作所有标签页：Target.attachToTarget(flatten=True)
+拿到 sessionId 后，send() 携带 sessionId 即面向该标签页。
+"""
+from __future__ import annotations
+
+import asyncio
+import itertools
+import json
+import urllib.request
+from typing import Any, Callable
+
+import websockets
+
+DEFAULT_TIMEOUT = 60.0
+
+
+class CDPError(RuntimeError):
+    pass
+
+
+class CDPProtocolError(CDPError):
+    """CDP 返回了 error 结果。"""
+
+    def __init__(self, method: str, code: int, message: str):
+        super().__init__(f"CDP {method} 失败 [{code}]: {message}")
+        self.method, self.code, self.message = method, code, message
+
+
+class CDPEvalError(CDPError):
+    """页面内 JS 抛出异常。"""
+
+    def __init__(self, expression: str, detail: str):
+        super().__init__(f"JS 执行出错: {detail}\n--- 表达式 ---\n{expression[:500]}")
+        self.detail = detail
+
+
+EventCallback = Callable[[str | None, str, dict], None]
+
+
+class CDPConnection:
+    def __init__(self, ws_url: str, port: int):
+        self._ws_url = ws_url
+        self.port = port
+        self._ws: websockets.WebSocketCommonProtocol | None = None
+        self._ids = itertools.count(1)
+        self._pending: dict[int, asyncio.Future] = {}
+        self._event_cbs: list[EventCallback] = []
+        self._recv_task: asyncio.Task | None = None
+        self._closed = False
+
+    # ---- 生命周期 ----
+    @classmethod
+    async def connect(cls, port: int, timeout: float = 15.0) -> "CDPConnection":
+        version = await asyncio.wait_for(
+            asyncio.to_thread(cls._http_get, port, "/json/version"), timeout=timeout
+        )
+        ws_url = version.get("webSocketDebuggerUrl")
+        if not ws_url:
+            raise CDPError("未能从 /json/version 获取 webSocketDebuggerUrl")
+        self = cls(ws_url, port)
+        await self._open()
+        return self
+
+    @staticmethod
+    def _http_get(port: int, path: str) -> dict:
+        with urllib.request.urlopen(f"http://127.0.0.1:{port}{path}", timeout=3) as resp:
+            return json.loads(resp.read().decode("utf-8"))
+
+    async def _open(self) -> None:
+        self._ws = await websockets.connect(self._ws_url, max_size=64 * 1024 * 1024, ping_interval=20)
+        self._recv_task = asyncio.create_task(self._recv_loop())
+
+    async def close(self) -> None:
+        self._closed = True
+        if self._recv_task:
+            self._recv_task.cancel()
+        if self._ws:
+            await self._ws.close()
+
+    def http_get(self, path: str) -> dict:
+        return self._http_get(self.port, path)
+
+    # ---- 消息收发 ----
+    async def send(
+        self,
+        method: str,
+        params: dict | None = None,
+        *,
+        session_id: str | None = None,
+        timeout: float = DEFAULT_TIMEOUT,
+    ) -> Any:
+        if not self._ws:
+            raise CDPError("CDP 连接未打开")
+        mid = next(self._ids)
+        msg: dict[str, Any] = {"id": mid, "method": method, "params": params or {}}
+        if session_id:
+            msg["sessionId"] = session_id
+        fut: asyncio.Future = asyncio.get_running_loop().create_future()
+        self._pending[mid] = fut
+        try:
+            await self._ws.send(json.dumps(msg))
+            result = await asyncio.wait_for(fut, timeout=timeout)
+        finally:
+            self._pending.pop(mid, None)
+        return result
+
+    def on_event(self, callback: EventCallback) -> None:
+        """callback(session_id, method, params) —— 同步回调。"""
+        self._event_cbs.append(callback)
+
+    async def _recv_loop(self) -> None:
+        try:
+            async for raw in self._ws:
+                msg = json.loads(raw)
+                if "id" in msg:
+                    fut = self._pending.get(msg["id"])
+                    if fut and not fut.done():
+                        if "error" in msg:
+                            fut.set_exception(
+                                CDPProtocolError(msg.get("method", "?"), msg["error"].get("code", -1), msg["error"].get("message", ""))
+                            )
+                        else:
+                            fut.set_result(msg.get("result"))
+                else:
+                    sid = msg.get("sessionId")
+                    method = msg.get("method", "")
+                    params = msg.get("params") or {}
+                    for cb in list(self._event_cbs):
+                        try:
+                            cb(sid, method, params)
+                        except Exception:
+                            pass
+        except asyncio.CancelledError:
+            pass
+        except Exception:
+            if not self._closed:
+                for fut in self._pending.values():
+                    if not fut.done():
+                        fut.set_exception(CDPError("CDP 连接断开"))
+
+    # ---- Target 管理 ----
+    async def list_pages(self) -> list[dict]:
+        res = await self.send("Target.getTargets")
+        return [t for t in res.get("targetInfos", []) if t.get("type") == "page"]
+
+    async def new_tab(self, url: str = "about:blank") -> dict:
+        res = await self.send("Target.createTarget", {"url": url})
+        tid = res["targetId"]
+        for t in await self.list_pages():
+            if t["targetId"] == tid:
+                return t
+        return {"targetId": tid, "url": url}
+
+    async def attach(self, target_id: str) -> str:
+        res = await self.send("Target.attachToTarget", {"targetId": target_id, "flatten": True})
+        return res["sessionId"]

xiumiagent-0.1.0/cdp/helpers.py

@@ -0,0 +1,175 @@
+"""Tab：面向单个标签页的高级封装（evaluate / 注入 JS 库 / 截图 / 文件注入 / 真实按键）。"""
+from __future__ import annotations
+
+import base64
+import json
+from pathlib import Path
+from typing import Any
+
+from .connection import CDPConnection, CDPError, CDPEvalError
+from .jslib import AGENT_JS, call_expr
+
+_KEY_MAP = {
+    "Enter": ("\r", "Enter", 13),
+    "Tab": ("\t", "Tab", 9),
+    "Escape": ("", "Escape", 27),
+    "Backspace": ("\b", "Backspace", 8),
+    "Delete": ("", "Delete", 46),
+    "ArrowLeft": ("", "Left", 37),
+    "ArrowRight": ("", "Right", 39),
+    "ArrowUp": ("", "Up", 38),
+    "ArrowDown": ("", "Down", 40),
+}
+
+
+class Tab:
+    def __init__(self, conn: CDPConnection, session_id: str, target_info: dict):
+        self.conn = conn
+        self.session_id = session_id
+        self.target_info = target_info
+        self._lib_injected = False
+
+    # ---- 基础 ----
+    async def send(self, method: str, params: dict | None = None, timeout: float = 60.0) -> Any:
+        return await self.conn.send(method, params, session_id=self.session_id, timeout=timeout)
+
+    async def enable(self) -> None:
+        for m in ("Runtime.enable", "Page.enable", "DOM.enable"):
+            try:
+                await self.send(m)
+            except CDPError:
+                pass
+        self._lib_injected = False
+
+    @property
+    def url(self) -> str:
+        return self.target_info.get("url", "")
+
+    async def current_url(self) -> str:
+        try:
+            return await self.evaluate("location.href")
+        except Exception:
+            return self.url
+
+    # ---- JS ----
+    async def evaluate(self, expression: str, await_promise: bool = False, timeout: float = 60.0) -> Any:
+        res = await self.send(
+            "Runtime.evaluate",
+            {
+                "expression": expression,
+                "awaitPromise": await_promise,
+                "returnByValue": True,
+                "userGesture": True,
+            },
+            timeout=timeout,
+        )
+        if res.get("exceptionDetails"):
+            d = res["exceptionDetails"]
+            detail = d.get("exception", {}).get("description") or d.get("text", "unknown")
+            raise CDPEvalError(expression, detail)
+        result = res.get("result", {})
+        return result.get("value")
+
+    async def ensure_lib(self) -> None:
+        if self._lib_injected:
+            return
+        state = await self.evaluate(AGENT_JS)
+        self._lib_injected = state in ("ok", "already")
+        if not self._lib_injected:
+            raise CDPError("agent JS 库注入失败")
+
+    async def agent(self, fn: str, *args: Any) -> Any:
+        """调用 window.__agent.fn(...)，返回 JSON 可序列化结果。"""
+        await self.ensure_lib()
+        return await self.evaluate(call_expr(fn, *args))
+
+    # ---- 导航 ----
+    async def navigate(self, url: str, settle: float = 1.5, timeout: float = 30.0) -> dict:
+        self._lib_injected = False
+        res = await self.send("Page.navigate", {"url": url}, timeout=timeout)
+        import asyncio
+
+        await asyncio.sleep(0.3)
+        deadline = asyncio.get_event_loop().time() + timeout
+        while asyncio.get_event_loop().time() < deadline:
+            state = await self.evaluate("document.readyState")
+            if state == "complete":
+                break
+            await asyncio.sleep(0.3)
+        await asyncio.sleep(settle)  # SPA 渲染缓冲
+        self.target_info["url"] = url
+        return res
+
+    async def wait_selector(self, selector: str, timeout: float = 10.0) -> bool:
+        import asyncio
+
+        deadline = asyncio.get_event_loop().time() + timeout
+        while asyncio.get_event_loop().time() < deadline:
+            found = await self.evaluate(f"!!document.querySelector({json.dumps(selector)})")
+            if found:
+                return True
+            await asyncio.sleep(0.4)
+        return False
+
+    # ---- 截图 ----
+    async def screenshot(self, path: Path | None = None, selector: str | None = None) -> Path:
+        params: dict[str, Any] = {"format": "png"}
+        if selector:
+            rect = await self.evaluate(
+                f"(() => {{ const el = document.querySelector({json.dumps(selector)});"
+                f" if (!el) return null; const r = el.getBoundingClientRect();"
+                f" return {{x: r.x, y: r.y + window.scrollY, width: r.width, height: r.height}}; }})()"
+            )
+            if not rect or rect["width"] < 2:
+                raise CDPError(f"截图失败：找不到可见元素 {selector}")
+            params["clip"] = {**rect, "scale": 1}
+            params["captureBeyondViewport"] = True
+        res = await self.send("Page.captureScreenshot", params, timeout=60)
+        data = base64.b64decode(res["data"])
+        if path is None:
+            from core.config import PROJECT_ROOT
+
+            path = PROJECT_ROOT / "screenshots" / "shot.png"
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_bytes(data)
+        return path
+
+    # ---- 文件上传（纯 JS 做不到，必须走 CDP）----
+    async def set_files(self, selector: str, file_paths: list[str | Path]) -> None:
+        """把本地文件塞进页面 file input（如秀米图库上传）。"""
+        # 先确保 input 存在
+        exists = await self.evaluate(f"!!document.querySelector({json.dumps(selector)})")
+        if not exists:
+            raise CDPError(f"file input 不存在: {selector}")
+        res = await self.send(
+            "Runtime.evaluate",
+            {
+                "expression": f"document.querySelector({json.dumps(selector)})",
+                "returnByValue": False,
+            },
+        )
+        object_id = res.get("result", {}).get("objectId")
+        if not object_id:
+            raise CDPError("无法获取 file input 的 objectId")
+        node = await self.send("DOM.requestNode", {"objectId": object_id})
+        abs_paths = [str(Path(p).resolve()) for p in file_paths]
+        for p in abs_paths:
+            if not Path(p).exists():
+                raise CDPError(f"文件不存在: {p}")
+        await self.send("DOM.setFileInputFiles", {"files": abs_paths, "nodeId": node["nodeId"]})
+        # 通知框架文件已选择
+        await self.agent("triggerChange", selector)
+
+    # ---- 真实按键兜底（isTrusted，合成事件不生效时用）----
+    async def real_press(self, key: str) -> None:
+        text, key_name, vk = _KEY_MAP.get(key, ("", key, 0))
+        for type_ in ("keyDown", "keyUp") if not text else (("keyDown", "char", "keyUp")):
+            params: dict[str, Any] = {"type": type_, "key": key_name, "windowsVirtualKeyCode": vk}
+            if type_ == "char":
+                params["text"] = text
+            await self.send("Input.dispatchKeyEvent", params)
+
+    async def real_type(self, text: str) -> None:
+        """逐字符发送真实键盘输入（焦点必须在目标输入框上）。"""
+        for ch in text:
+            await self.send("Input.dispatchKeyEvent", {"type": "char", "text": ch})