goofish-cli 0.1.0__py3-none-any.whl

goofish_cli/commands/message/history.py

@@ -0,0 +1,23 @@
+"""message history — 拉取指定会话的历史消息。
+
+走 WebSocket LWP `/r/MessageManager/listUserMessages`（官方没有对应的 HTTP 版）。
+一次性命令：连 → reg → 翻页直到 hasMore=0 → 断开。
+"""
+
+import asyncio
+from typing import Any
+
+from goofish_cli.core import Session, Strategy, command
+from goofish_cli.core.ws import list_user_messages
+
+
+@command(
+    namespace="message",
+    name="history",
+    description="拉取指定 cid 会话的历史消息（翻页到底）",
+    strategy=Strategy.COOKIE,
+    columns=["send_user_id", "send_user_name", "message"],
+)
+def history(cid: str, limit_per_page: int = 20) -> list[dict[str, Any]]:
+    session = Session.load()
+    return asyncio.run(list_user_messages(session, cid, limit_per_page=limit_per_page))

goofish_cli/commands/message/send.py

@@ -0,0 +1,102 @@
+"""message send — 向指定会话发送一条消息（文本/图片）。
+
+写操作，走限流 + 熔断。未知 cid 时可传 --item-id 自动创建单聊。
+"""
+
+import asyncio
+from typing import Any, Literal
+
+from goofish_cli.core import Session, Strategy, command
+from goofish_cli.core.guard import watch
+from goofish_cli.core.limiter import acquire
+from goofish_cli.core.token import get_access_token
+from goofish_cli.core.ws import (
+    connect,
+    create_chat,
+    heartbeat_loop,
+    register,
+    send_image,
+    send_text,
+)
+
+
+@command(
+    namespace="message",
+    name="send",
+    description="向会话发送消息（text/image）。text 必填，image 走 url+wh",
+    strategy=Strategy.COOKIE,
+    columns=["cid", "toid", "kind", "ok", "mid"],
+    write=True,
+)
+def send(
+    cid: str,
+    toid: str,
+    text: str = "",
+    *,
+    kind: Literal["text", "image"] = "text",
+    image_url: str = "",
+    image_width: int = 0,
+    image_height: int = 0,
+    item_id: str = "",
+) -> dict[str, Any]:
+    session = Session.load()
+    with acquire("message.write"), watch():
+        return asyncio.run(_send(
+            session,
+            cid=cid,
+            toid=toid,
+            text=text,
+            kind=kind,
+            image_url=image_url,
+            image_width=image_width,
+            image_height=image_height,
+            item_id=item_id,
+        ))
+
+
+async def _send(
+    session: Session,
+    *,
+    cid: str,
+    toid: str,
+    text: str,
+    kind: str,
+    image_url: str,
+    image_width: int,
+    image_height: int,
+    item_id: str,
+) -> dict[str, Any]:
+    token = get_access_token(session)
+    async with connect(session) as ws:
+        await register(ws, session, token)
+        hb = asyncio.create_task(heartbeat_loop(ws))
+        try:
+            if item_id:
+                await create_chat(ws, myid=session.unb, toid=toid, item_id=item_id)
+                await asyncio.sleep(0.5)
+
+            if kind == "text":
+                if not text:
+                    raise ValueError("kind=text 需要 --text")
+                mid = await send_text(
+                    ws, myid=session.unb, cid=cid, toid=toid, text=text
+                )
+            elif kind == "image":
+                if not (image_url and image_width and image_height):
+                    raise ValueError("kind=image 需要 --image-url/--image-width/--image-height")
+                mid = await send_image(
+                    ws,
+                    myid=session.unb,
+                    cid=cid,
+                    toid=toid,
+                    url=image_url,
+                    width=image_width,
+                    height=image_height,
+                )
+            else:
+                raise ValueError(f"不支持的 kind: {kind}")
+            # 等一轮 ack 回包，避免 WS 提前关
+            await asyncio.sleep(1.0)
+        finally:
+            hb.cancel()
+    return {"cid": cid, "toid": toid, "kind": kind, "ok": True, "mid": mid}

goofish_cli/commands/message/watch.py

@@ -0,0 +1,58 @@
+"""message watch — 常驻接收消息，每条解密后以 JSONL 打到 stdout。
+
+不做自动回复；Agent 自己拿 JSONL 决策再调 message send。
+Ctrl-C 退出。
+"""
+
+import asyncio
+import json
+import sys
+from typing import Any
+
+from loguru import logger
+
+from goofish_cli.core import Session, Strategy, command
+from goofish_cli.core.ws import (
+    extract_incoming_text,
+    extract_meta_event,
+    extract_push_messages,
+    run_forever,
+)
+
+
+@command(
+    namespace="message",
+    name="watch",
+    description="常驻 IM 长连接，下行事件以 JSONL 输出到 stdout（Ctrl-C 退出）",
+    strategy=Strategy.COOKIE,
+    columns=[],
+)
+def watch() -> dict[str, Any]:
+    session = Session.load()
+    logger.info(f"[watch] unb={session.unb} tracknick={session.tracknick}")
+
+    async def _handler(msg: dict[str, Any], _ws) -> None:
+        # /s/para 是对方"正在输入"状态通知，跳过避免噪音
+        if msg.get("lwp") == "/s/para":
+            return
+        for decoded in extract_push_messages(msg):
+            # 优先识别元事件（read / new_msg 通知）
+            meta = extract_meta_event(decoded)
+            if meta is not None:
+                sys.stdout.write(json.dumps(meta, ensure_ascii=False) + "\n")
+                sys.stdout.flush()
+                continue
+            # 再尝试嵌套消息正文
+            item = extract_incoming_text(decoded)
+            if item is None:
+                continue
+            # 真消息：send_message 非空 或 contentType=1
+            if item.get("send_message") or item.get("content_type") == 1:
+                sys.stdout.write(json.dumps(item, ensure_ascii=False) + "\n")
+                sys.stdout.flush()
+
+    try:
+        asyncio.run(run_forever(session, handler=_handler))
+    except KeyboardInterrupt:
+        logger.info("[watch] 用户中断")
+    return {"ok": True}

goofish_cli/core/__init__.py

@@ -0,0 +1,26 @@
+from goofish_cli.core.errors import (
+    AuthRequiredError,
+    GoofishError,
+    NotFoundError,
+    RateLimitedError,
+    RiskControlError,
+    SignError,
+)
+from goofish_cli.core.registry import Command, command, iter_commands, registry
+from goofish_cli.core.session import Session
+from goofish_cli.core.strategy import Strategy
+
+__all__ = [
+    "AuthRequiredError",
+    "Command",
+    "GoofishError",
+    "NotFoundError",
+    "RateLimitedError",
+    "RiskControlError",
+    "Session",
+    "SignError",
+    "Strategy",
+    "command",
+    "iter_commands",
+    "registry",
+]

goofish_cli/core/errors.py

@@ -0,0 +1,31 @@
+"""统一异常体系。driver 层根据响应体 ret 或状态自动抛对应异常。"""
+from __future__ import annotations
+
+
+class GoofishError(Exception):
+    exit_code = 1
+
+    def __init__(self, message: str, *, raw: dict | None = None):
+        super().__init__(message)
+        self.raw = raw
+
+
+class AuthRequiredError(GoofishError):
+    exit_code = 77
+
+
+class SignError(GoofishError):
+    exit_code = 78
+
+
+class RateLimitedError(GoofishError):
+    exit_code = 75
+
+
+class RiskControlError(GoofishError):
+    """触发风控：RGV587 / punish / FAIL_SYS_USER_VALIDATE 等。"""
+    exit_code = 76
+
+
+class NotFoundError(GoofishError):
+    exit_code = 79

goofish_cli/core/guard.py

@@ -0,0 +1,63 @@
+"""风控熔断。检测到 RiskControlError 后写入熔断时间戳，后续请求直接拒绝。"""
+from __future__ import annotations
+
+import json
+import os
+import time
+from contextlib import contextmanager
+from pathlib import Path
+
+from goofish_cli.core.errors import RiskControlError
+
+STATE_PATH = Path.home() / ".goofish-cli" / "circuit.json"
+DEFAULT_BREAK_MINUTES = 10
+
+
+def _break_seconds() -> int:
+    try:
+        return max(60, int(os.environ.get("GOOFISH_CIRCUIT_BREAK_MINUTES", DEFAULT_BREAK_MINUTES)) * 60)
+    except ValueError:
+        return DEFAULT_BREAK_MINUTES * 60
+
+
+def _load() -> float:
+    if not STATE_PATH.exists():
+        return 0.0
+    try:
+        return float(json.loads(STATE_PATH.read_text()).get("until", 0))
+    except (json.JSONDecodeError, OSError, ValueError):
+        return 0.0
+
+
+def _save(until: float) -> None:
+    STATE_PATH.parent.mkdir(parents=True, exist_ok=True)
+    STATE_PATH.write_text(json.dumps({"until": until}))
+
+
+def check() -> None:
+    until = _load()
+    if until and time.time() < until:
+        remain = int(until - time.time())
+        raise RiskControlError(
+            f"风控熔断中，剩余 {remain}s。触发后自动冷却，可通过 `goofish auth reset-guard` 手动解除。"
+        )
+
+
+def trip(reason: str = "") -> None:
+    _save(time.time() + _break_seconds())
+
+
+def reset() -> None:
+    if STATE_PATH.exists():
+        STATE_PATH.unlink()
+
+
+@contextmanager
+def watch():
+    """包住写操作：命中 RGV587 自动熔断。"""
+    check()
+    try:
+        yield
+    except RiskControlError:
+        trip()
+        raise

goofish_cli/core/limiter.py

@@ -0,0 +1,60 @@
+"""令牌桶限流。单账号 + 单命名空间，默认 1 写/分钟（可配）。
+
+写入 ~/.goofish-cli/limiter.json 做进程间共享（单机多进程场景）。
+"""
+from __future__ import annotations
+
+import json
+import os
+import time
+from contextlib import contextmanager
+from pathlib import Path
+
+from goofish_cli.core.errors import RateLimitedError
+
+STATE_PATH = Path.home() / ".goofish-cli" / "limiter.json"
+DEFAULT_WRITE_RPM = 1
+
+
+def _rpm() -> int:
+    try:
+        return max(1, int(os.environ.get("GOOFISH_WRITE_RPM", DEFAULT_WRITE_RPM)))
+    except ValueError:
+        return DEFAULT_WRITE_RPM
+
+
+def _load() -> dict[str, list[float]]:
+    if not STATE_PATH.exists():
+        return {}
+    try:
+        return json.loads(STATE_PATH.read_text())
+    except (json.JSONDecodeError, OSError):
+        return {}
+
+
+def _save(state: dict[str, list[float]]) -> None:
+    STATE_PATH.parent.mkdir(parents=True, exist_ok=True)
+    STATE_PATH.write_text(json.dumps(state))
+
+
+def check(bucket: str) -> None:
+    """消耗一个令牌。超限抛 RateLimitedError。"""
+    now = time.time()
+    window = 60.0
+    rpm = _rpm()
+    state = _load()
+    hits = [t for t in state.get(bucket, []) if now - t < window]
+    if len(hits) >= rpm:
+        wait = window - (now - hits[0])
+        raise RateLimitedError(
+            f"限流：bucket={bucket} 每 {window:.0f}s 上限 {rpm}，再等 {wait:.1f}s"
+        )
+    hits.append(now)
+    state[bucket] = hits
+    _save(state)
+
+
+@contextmanager
+def acquire(bucket: str):
+    check(bucket)
+    yield

goofish_cli/core/mtop.py

@@ -0,0 +1,131 @@
+"""统一 mtop 调用模板。抽出 headers/params/sign 流程。
+
+要点：
+- `t` 取真实毫秒：`int(time.time() * 1000)`，而不是 `int(time.time()) * 1000`（后者末三位恒为 0）
+- 自动识别风控关键字抛 RiskControlError
+- 自动识别令牌过期抛 AuthRequiredError
+"""
+from __future__ import annotations
+
+import json
+import time
+from typing import Any
+
+from goofish_cli.core.errors import (
+    AuthRequiredError,
+    GoofishError,
+    NotFoundError,
+    RiskControlError,
+    SignError,
+)
+from goofish_cli.core.session import USER_AGENT, Session
+from goofish_cli.core.sign import generate_sign
+
+APP_KEY = "34839810"
+MTOP_HOST = "https://h5api.m.goofish.com"
+
+_RISK_KEYWORDS = (
+    "RGV587_ERROR",
+    "FAIL_SYS_USER_VALIDATE",
+    "哎哟喂",
+    "/punish",
+)
+_AUTH_KEYWORDS = (
+    "FAIL_SYS_SESSION_EXPIRED",
+    "FAIL_SYS_TOKEN_EXOIRED",
+    "FAIL_SYS_TOKEN_EMPTY",
+    "令牌过期",
+    "FAIL_SYS_ILLEGAL_ACCESS",
+)
+
+
+def default_headers() -> dict[str, str]:
+    return {
+        "accept": "application/json",
+        "accept-language": "en,zh-CN;q=0.9,zh;q=0.8,zh-TW;q=0.7,ja;q=0.6",
+        "cache-control": "no-cache",
+        "content-type": "application/x-www-form-urlencoded",
+        "origin": "https://www.goofish.com",
+        "pragma": "no-cache",
+        "priority": "u=1, i",
+        "referer": "https://www.goofish.com/",
+        "sec-ch-ua": '"Chromium";v="146", "Not-A.Brand";v="24", "Google Chrome";v="146"',
+        "sec-ch-ua-mobile": "?0",
+        "sec-ch-ua-platform": '"macOS"',
+        "sec-fetch-dest": "empty",
+        "sec-fetch-mode": "cors",
+        "sec-fetch-site": "same-site",
+        "user-agent": USER_AGENT,
+    }
+
+
+def call(
+    session: Session,
+    api: str,
+    data: dict[str, Any] | list[Any] | str,
+    *,
+    version: str = "1.0",
+    spm_cnt: str = "a21ybx.home.0.0",
+    extra_params: dict[str, str] | None = None,
+    headers: dict[str, str] | None = None,
+) -> dict[str, Any]:
+    """调用 mtop 接口。返回原始 JSON。失败抛 GoofishError 子类。"""
+    url = f"{MTOP_HOST}/h5/{api}/{version}/"
+    t_ms = str(int(time.time() * 1000))
+    data_val = data if isinstance(data, str) else json.dumps(data, separators=(",", ":"))
+
+    token = session.h5_token
+    if not token:
+        raise AuthRequiredError("_m_h5_tk 缺失，请重新登录并导出 cookie")
+    sign = generate_sign(t_ms, token, data_val)
+
+    params = {
+        "jsv": "2.7.2",
+        "appKey": APP_KEY,
+        "t": t_ms,
+        "sign": sign,
+        "v": version,
+        "type": "originaljson",
+        "accountSite": "xianyu",
+        "dataType": "json",
+        "timeout": "20000",
+        "api": api,
+        "sessionOption": "AutoLoginOnly",
+        "spm_cnt": spm_cnt,
+    }
+    if extra_params:
+        params.update(extra_params)
+
+    resp = session.http.post(
+        url,
+        params=params,
+        headers=headers or default_headers(),
+        data={"data": data_val},
+        timeout=30,
+    )
+    raw = resp.json()
+    _classify_error(raw, api)
+    return raw
+
+
+def _classify_error(raw: dict[str, Any], api: str) -> None:
+    """根据 ret 字段分类抛异常。成功则不抛。"""
+    ret = raw.get("ret") or []
+    ret_str = " | ".join(ret) if isinstance(ret, list) else str(ret)
+    if not ret_str or "SUCCESS" in ret_str:
+        return
+
+    for kw in _RISK_KEYWORDS:
+        if kw in ret_str:
+            raise RiskControlError(
+                f"[{api}] 触发风控：{ret_str}",
+                raw=raw,
+            )
+    for kw in _AUTH_KEYWORDS:
+        if kw in ret_str:
+            raise AuthRequiredError(f"[{api}] 登录态失效：{ret_str}", raw=raw)
+    if "ILLEGAL_REQUEST" in ret_str or "sign" in ret_str.lower():
+        raise SignError(f"[{api}] 签名错误：{ret_str}", raw=raw)
+    if "NOT_FOUND" in ret_str or "不存在" in ret_str:
+        raise NotFoundError(f"[{api}] 未找到：{ret_str}", raw=raw)
+    raise GoofishError(f"[{api}] 调用失败：{ret_str}", raw=raw)

goofish_cli/core/output.py

@@ -0,0 +1,82 @@
+"""统一输出渲染器。支持 json/yaml/table/md/csv。非 TTY 场景 table → json 降级。"""
+from __future__ import annotations
+
+import csv
+import io
+import json
+import sys
+from enum import StrEnum
+from typing import Any
+
+import yaml
+from rich.console import Console
+from rich.table import Table
+
+
+class Format(StrEnum):
+    JSON = "json"
+    YAML = "yaml"
+    TABLE = "table"
+    MD = "md"
+    CSV = "csv"
+
+
+def _as_rows(data: Any) -> tuple[list[str], list[dict[str, Any]]]:
+    if isinstance(data, dict):
+        return list(data.keys()), [data]
+    if isinstance(data, list) and data and isinstance(data[0], dict):
+        cols: list[str] = []
+        for item in data:
+            for k in item:
+                if k not in cols:
+                    cols.append(k)
+        return cols, data
+    return [], []
+
+
+def render(data: Any, fmt: Format = Format.JSON, columns: list[str] | None = None) -> None:
+    # 非 TTY 且用户没显式指定 table → 走 json（便于管道处理）
+    if fmt is Format.TABLE and not sys.stdout.isatty():
+        fmt = Format.JSON
+
+    if fmt is Format.JSON:
+        print(json.dumps(data, ensure_ascii=False, indent=2, default=str))
+        return
+
+    if fmt is Format.YAML:
+        print(yaml.safe_dump(data, allow_unicode=True, sort_keys=False))
+        return
+
+    cols, rows = _as_rows(data)
+    if columns:
+        cols = columns
+    if not rows:
+        # 标量或空：降级为 JSON
+        print(json.dumps(data, ensure_ascii=False, indent=2, default=str))
+        return
+
+    if fmt is Format.TABLE:
+        console = Console()
+        table = Table(show_header=True, header_style="bold cyan")
+        for c in cols:
+            table.add_column(c)
+        for row in rows:
+            table.add_row(*[str(row.get(c, "")) for c in cols])
+        console.print(table)
+        return
+
+    if fmt is Format.MD:
+        print("| " + " | ".join(cols) + " |")
+        print("| " + " | ".join("---" for _ in cols) + " |")
+        for row in rows:
+            print("| " + " | ".join(str(row.get(c, "")) for c in cols) + " |")
+        return
+
+    if fmt is Format.CSV:
+        buf = io.StringIO()
+        writer = csv.DictWriter(buf, fieldnames=cols, extrasaction="ignore")
+        writer.writeheader()
+        for row in rows:
+            writer.writerow({c: row.get(c, "") for c in cols})
+        sys.stdout.write(buf.getvalue())
+        return

goofish_cli/core/registry.py

@@ -0,0 +1,78 @@
+"""命令注册中心。参照 opencli cli({...}) —— 单一 registry → CLI / MCP / Skill 共享。"""
+from __future__ import annotations
+
+import importlib
+import pkgutil
+from collections.abc import Callable, Iterator
+from dataclasses import dataclass, field
+from typing import Any
+
+from goofish_cli.core.strategy import Strategy
+
+
+@dataclass
+class Command:
+    namespace: str
+    name: str
+    description: str
+    func: Callable[..., Any]
+    strategy: Strategy = Strategy.COOKIE
+    columns: list[str] = field(default_factory=list)
+    write: bool = False
+
+    @property
+    def full_name(self) -> str:
+        return f"{self.namespace}.{self.name}"
+
+
+_REGISTRY: dict[str, Command] = {}
+
+
+def command(
+    *,
+    namespace: str,
+    name: str,
+    description: str,
+    strategy: Strategy = Strategy.COOKIE,
+    columns: list[str] | None = None,
+    write: bool = False,
+) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    """装饰器：将函数注册为命令。"""
+
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+        cmd = Command(
+            namespace=namespace,
+            name=name,
+            description=description,
+            func=func,
+            strategy=strategy,
+            columns=columns or [],
+            write=write,
+        )
+        if cmd.full_name in _REGISTRY:
+            raise RuntimeError(f"重复注册命令：{cmd.full_name}")
+        _REGISTRY[cmd.full_name] = cmd
+        return func
+
+    return decorator
+
+
+def registry() -> dict[str, Command]:
+    return dict(_REGISTRY)
+
+
+def iter_commands() -> Iterator[Command]:
+    return iter(_REGISTRY.values())
+
+
+def discover() -> None:
+    """自动扫描 goofish_cli.commands.* 所有模块，触发装饰器注册。"""
+    from goofish_cli import commands  # noqa: WPS433
+
+    def _walk(pkg: Any) -> None:
+        for info in pkgutil.iter_modules(pkg.__path__, pkg.__name__ + "."):
+            module = importlib.import_module(info.name)
+            if info.ispkg:
+                _walk(module)
+
+    _walk(commands)