sermo 0.1.0__tar.gz

sermo-0.1.0/PKG-INFO

@@ -0,0 +1,142 @@
+Metadata-Version: 2.4
+Name: sermo
+Version: 0.1.0
+Summary: Command-line Sermo client
+Author: Sermo
+Project-URL: Homepage, https://sermo.jyonn.space
+Keywords: sermo,chat,cli
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Natural Language :: Chinese (Simplified)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Communications :: Chat
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# sermo
+
+Sermo 的命令行客户端。它直接接入 `sermo-backend` API，适合在终端里快速查看会话、发送文字消息和检查好友信息。
+
+当前版本先聚焦文字体验：
+
+- 支持进入空间并保存登录状态。
+- 支持查看当前账户、聊天列表、好友列表、好友申请。
+- 支持查看聊天记录、发送文字消息、持续刷新新消息。
+- 图片、视频、语音、文件等多媒体消息暂不下载，统一展示为 `[图片]`、`[视频]`、`[语音]`、`[文件]`。
+- 暂不展示头像。
+
+## 安装
+
+开发环境下可以直接运行：
+
+```bash
+python -m sermo_cli --help
+```
+
+也可以安装为本地命令：
+
+```bash
+pip install -e .
+sermo --help
+```
+
+从 PyPI 安装：
+
+```bash
+pip install sermo
+sermo --help
+```
+
+## API 地址
+
+默认 API 地址是：
+
+```text
+https://api.sermo.jyonn.space
+```
+
+可以用环境变量或参数覆盖：
+
+```bash
+SERMO_API_BASE=http://localhost:8000 python -m sermo_cli chats
+python -m sermo_cli --api http://localhost:8000 chats
+```
+
+## 常用命令
+
+登录 / 进入空间：
+
+```bash
+sermo login --space yuanmeng --name 软糖大啾咪
+```
+
+如果昵称需要访问密码，CLI 会自动提示输入密码。
+
+查看当前账户：
+
+```bash
+sermo me
+```
+
+查看聊天列表：
+
+```bash
+sermo chats
+```
+
+打开聊天：
+
+```bash
+sermo chat 1
+```
+
+在聊天界面里：
+
+- 直接输入文字并回车即可发送。
+- 输入 `/refresh` 刷新新消息。
+- 输入 `/quit` 退出。
+
+只发送一条消息：
+
+```bash
+sermo send 1 你好
+```
+
+持续刷新聊天：
+
+```bash
+sermo chat 1 --follow
+```
+
+查看好友：
+
+```bash
+sermo friends
+```
+
+查看好友申请：
+
+```bash
+sermo requests
+```
+
+退出：
+
+```bash
+sermo logout
+```
+
+## 登录状态
+
+登录状态默认保存到：
+
+```text
+~/.sermo-cli/config.json
+```
+
+可以用 `SERMO_CLI_CONFIG` 指定其他路径，便于测试或多账号切换。

sermo-0.1.0/README.md

@@ -0,0 +1,122 @@
+# sermo
+
+Sermo 的命令行客户端。它直接接入 `sermo-backend` API，适合在终端里快速查看会话、发送文字消息和检查好友信息。
+
+当前版本先聚焦文字体验：
+
+- 支持进入空间并保存登录状态。
+- 支持查看当前账户、聊天列表、好友列表、好友申请。
+- 支持查看聊天记录、发送文字消息、持续刷新新消息。
+- 图片、视频、语音、文件等多媒体消息暂不下载，统一展示为 `[图片]`、`[视频]`、`[语音]`、`[文件]`。
+- 暂不展示头像。
+
+## 安装
+
+开发环境下可以直接运行：
+
+```bash
+python -m sermo_cli --help
+```
+
+也可以安装为本地命令：
+
+```bash
+pip install -e .
+sermo --help
+```
+
+从 PyPI 安装：
+
+```bash
+pip install sermo
+sermo --help
+```
+
+## API 地址
+
+默认 API 地址是：
+
+```text
+https://api.sermo.jyonn.space
+```
+
+可以用环境变量或参数覆盖：
+
+```bash
+SERMO_API_BASE=http://localhost:8000 python -m sermo_cli chats
+python -m sermo_cli --api http://localhost:8000 chats
+```
+
+## 常用命令
+
+登录 / 进入空间：
+
+```bash
+sermo login --space yuanmeng --name 软糖大啾咪
+```
+
+如果昵称需要访问密码，CLI 会自动提示输入密码。
+
+查看当前账户：
+
+```bash
+sermo me
+```
+
+查看聊天列表：
+
+```bash
+sermo chats
+```
+
+打开聊天：
+
+```bash
+sermo chat 1
+```
+
+在聊天界面里：
+
+- 直接输入文字并回车即可发送。
+- 输入 `/refresh` 刷新新消息。
+- 输入 `/quit` 退出。
+
+只发送一条消息：
+
+```bash
+sermo send 1 你好
+```
+
+持续刷新聊天：
+
+```bash
+sermo chat 1 --follow
+```
+
+查看好友：
+
+```bash
+sermo friends
+```
+
+查看好友申请：
+
+```bash
+sermo requests
+```
+
+退出：
+
+```bash
+sermo logout
+```
+
+## 登录状态
+
+登录状态默认保存到：
+
+```text
+~/.sermo-cli/config.json
+```
+
+可以用 `SERMO_CLI_CONFIG` 指定其他路径，便于测试或多账号切换。

sermo-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sermo"
+version = "0.1.0"
+description = "Command-line Sermo client"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = []
+authors = [
+  { name = "Sermo" },
+]
+keywords = ["sermo", "chat", "cli"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Environment :: Console",
+  "Intended Audience :: End Users/Desktop",
+  "Natural Language :: Chinese (Simplified)",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Communications :: Chat",
+]
+
+[project.urls]
+Homepage = "https://sermo.jyonn.space"
+
+[project.scripts]
+sermo = "sermo_cli.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["sermo_cli*"]

sermo-0.1.0/sermo.egg-info/PKG-INFO

@@ -0,0 +1,142 @@
+Metadata-Version: 2.4
+Name: sermo
+Version: 0.1.0
+Summary: Command-line Sermo client
+Author: Sermo
+Project-URL: Homepage, https://sermo.jyonn.space
+Keywords: sermo,chat,cli
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Natural Language :: Chinese (Simplified)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Communications :: Chat
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# sermo
+
+Sermo 的命令行客户端。它直接接入 `sermo-backend` API，适合在终端里快速查看会话、发送文字消息和检查好友信息。
+
+当前版本先聚焦文字体验：
+
+- 支持进入空间并保存登录状态。
+- 支持查看当前账户、聊天列表、好友列表、好友申请。
+- 支持查看聊天记录、发送文字消息、持续刷新新消息。
+- 图片、视频、语音、文件等多媒体消息暂不下载，统一展示为 `[图片]`、`[视频]`、`[语音]`、`[文件]`。
+- 暂不展示头像。
+
+## 安装
+
+开发环境下可以直接运行：
+
+```bash
+python -m sermo_cli --help
+```
+
+也可以安装为本地命令：
+
+```bash
+pip install -e .
+sermo --help
+```
+
+从 PyPI 安装：
+
+```bash
+pip install sermo
+sermo --help
+```
+
+## API 地址
+
+默认 API 地址是：
+
+```text
+https://api.sermo.jyonn.space
+```
+
+可以用环境变量或参数覆盖：
+
+```bash
+SERMO_API_BASE=http://localhost:8000 python -m sermo_cli chats
+python -m sermo_cli --api http://localhost:8000 chats
+```
+
+## 常用命令
+
+登录 / 进入空间：
+
+```bash
+sermo login --space yuanmeng --name 软糖大啾咪
+```
+
+如果昵称需要访问密码，CLI 会自动提示输入密码。
+
+查看当前账户：
+
+```bash
+sermo me
+```
+
+查看聊天列表：
+
+```bash
+sermo chats
+```
+
+打开聊天：
+
+```bash
+sermo chat 1
+```
+
+在聊天界面里：
+
+- 直接输入文字并回车即可发送。
+- 输入 `/refresh` 刷新新消息。
+- 输入 `/quit` 退出。
+
+只发送一条消息：
+
+```bash
+sermo send 1 你好
+```
+
+持续刷新聊天：
+
+```bash
+sermo chat 1 --follow
+```
+
+查看好友：
+
+```bash
+sermo friends
+```
+
+查看好友申请：
+
+```bash
+sermo requests
+```
+
+退出：
+
+```bash
+sermo logout
+```
+
+## 登录状态
+
+登录状态默认保存到：
+
+```text
+~/.sermo-cli/config.json
+```
+
+可以用 `SERMO_CLI_CONFIG` 指定其他路径，便于测试或多账号切换。

sermo-0.1.0/sermo.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+sermo.egg-info/PKG-INFO
+sermo.egg-info/SOURCES.txt
+sermo.egg-info/dependency_links.txt
+sermo.egg-info/entry_points.txt
+sermo.egg-info/top_level.txt
+sermo_cli/__init__.py
+sermo_cli/__main__.py
+sermo_cli/api.py
+sermo_cli/cli.py
+sermo_cli/formatting.py
+sermo_cli/store.py

sermo-0.1.0/sermo.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sermo-0.1.0/sermo.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sermo = sermo_cli.cli:main

sermo-0.1.0/sermo.egg-info/top_level.txt

@@ -0,0 +1 @@
+sermo_cli

sermo-0.1.0/sermo_cli/__init__.py

@@ -0,0 +1,4 @@
+"""Command-line client for Sermo."""
+
+__version__ = "0.1.0"
+

sermo-0.1.0/sermo_cli/__main__.py

@@ -0,0 +1,6 @@
+from .cli import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+

sermo-0.1.0/sermo_cli/api.py

@@ -0,0 +1,164 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import Any
+from urllib import error, parse, request
+
+from .store import SessionStore
+
+
+@dataclass
+class SermoApiError(Exception):
+    message: str
+    identifier: str = "ERROR"
+    status: int = 500
+
+    def __str__(self) -> str:
+        return f"{self.message} ({self.identifier}, HTTP {self.status})"
+
+
+class ApiClient:
+    def __init__(self, store: SessionStore, api_base_url: str):
+        self.store = store
+        self.api_base_url = api_base_url.rstrip("/")
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        body: dict[str, Any] | None = None,
+        query: dict[str, Any] | None = None,
+        auth: bool = False,
+        retry_on_unauthorized: bool = True,
+    ) -> Any:
+        session = self.store.session() if auth else None
+        try:
+            return self._request_once(method, path, body=body, query=query, token=session.get("access_token") if session else None)
+        except SermoApiError as exc:
+            if exc.status != 401 or not auth or not retry_on_unauthorized or not session or not session.get("refresh_token"):
+                raise
+            refreshed = self.refresh(session["refresh_token"])
+            return self._request_once(method, path, body=body, query=query, token=refreshed["access_token"])
+
+    def _request_once(
+        self,
+        method: str,
+        path: str,
+        *,
+        body: dict[str, Any] | None,
+        query: dict[str, Any] | None,
+        token: str | None,
+    ) -> Any:
+        url = f"{self.api_base_url}{self._with_query(path, query)}"
+        payload = None if body is None else json.dumps(body).encode("utf-8")
+        headers = {
+            "Accept": "application/json",
+            "User-Agent": "sermo-cli/0.1",
+        }
+        if payload is not None:
+            headers["Content-Type"] = "application/json"
+        if token:
+            headers["Authorization"] = f"Bearer {token}"
+
+        req = request.Request(url, data=payload, headers=headers, method=method.upper())
+        try:
+            with request.urlopen(req, timeout=20) as response:
+                text = response.read().decode("utf-8")
+                return self._parse_response(text, response.status)
+        except error.HTTPError as exc:
+            text = exc.read().decode("utf-8", errors="replace")
+            return self._parse_response(text, exc.code)
+        except error.URLError as exc:
+            raise SermoApiError(f"无法连接 Sermo API：{exc.reason}", "NETWORK_ERROR", 0) from exc
+
+    def _parse_response(self, text: str, status: int) -> Any:
+        if not text:
+            if 200 <= status < 300:
+                return None
+            raise SermoApiError(f"HTTP {status}", "HTTP_ERROR", status)
+        try:
+            payload = json.loads(text)
+        except json.JSONDecodeError as exc:
+            if 200 <= status < 300:
+                return text
+            raise SermoApiError(f"HTTP {status}", "HTTP_ERROR", status) from exc
+
+        identifier = payload.get("identifier", "ERROR")
+        if not (200 <= status < 300) or identifier != "OK":
+            message = payload.get("user_message") or payload.get("message") or "请求失败"
+            raise SermoApiError(message, identifier, status)
+        return payload.get("body")
+
+    @staticmethod
+    def _with_query(path: str, query: dict[str, Any] | None) -> str:
+        if not query:
+            return path
+        filtered = {key: value for key, value in query.items() if value is not None and value != ""}
+        if not filtered:
+            return path
+        return f"{path}?{parse.urlencode(filtered)}"
+
+    def refresh(self, refresh_token: str) -> dict[str, Any]:
+        body = self.request(
+            "POST",
+            "/users/refresh",
+            body={"refresh": refresh_token},
+            retry_on_unauthorized=False,
+        )
+        session = {
+            "access_token": body["auth"],
+            "refresh_token": body["refresh"],
+            "user": body["data"],
+            "space": self.store.session().get("space") if self.store.session() else None,
+        }
+        self.store.set_session(session, self.api_base_url)
+        return session
+
+    def join(self, slug: str, name: str, password: str | None, language: str) -> dict[str, Any]:
+        return self.request(
+            "POST",
+            "/spaces/join",
+            body={"slug": slug, "name": name, "password": password or None, "language": language},
+        )
+
+    def logout(self) -> None:
+        session = self.store.session()
+        refresh = session.get("refresh_token") if session else None
+        if refresh:
+            try:
+                self.request("POST", "/users/logout", body={"refresh": refresh}, retry_on_unauthorized=False)
+            except SermoApiError:
+                pass
+        self.store.clear()
+
+    def me(self) -> dict[str, Any]:
+        return self.request("GET", "/users/me", auth=True)
+
+    def space_me(self) -> dict[str, Any]:
+        return self.request("GET", "/spaces/me", auth=True)
+
+    def chats(self) -> list[dict[str, Any]]:
+        return self.request("GET", "/chats/", auth=True)
+
+    def messages(self, chat_id: int, limit: int = 30, before: int | None = None, after: int | None = None) -> list[dict[str, Any]]:
+        return self.request(
+            "GET",
+            "/messages/",
+            auth=True,
+            query={"chat_id": chat_id, "limit": limit, "before": before, "after": after},
+        )
+
+    def send_text(self, chat_id: int, text: str) -> dict[str, Any]:
+        return self.request("POST", "/messages/", auth=True, query={"chat_id": chat_id}, body={"type": 0, "content": text})
+
+    def mark_read(self, chat_id: int) -> None:
+        self.request("POST", "/chats/read", auth=True, query={"chat_id": chat_id})
+
+    def friends(self) -> list[dict[str, Any]]:
+        return self.request("GET", "/friends/", auth=True)
+
+    def friend_requests(self) -> dict[str, list[dict[str, Any]]]:
+        return self.request("GET", "/friends/requests", auth=True)
+

sermo-0.1.0/sermo_cli/cli.py

@@ -0,0 +1,260 @@
+from __future__ import annotations
+
+import argparse
+import getpass
+import sys
+import time
+from typing import Any
+
+from .api import ApiClient, SermoApiError
+from .formatting import chat_title, format_time, message_text, print_header, style, user_name
+from .store import SessionStore
+
+
+def build_client(args: argparse.Namespace) -> ApiClient:
+    store = SessionStore()
+    return ApiClient(store, store.api_base_url(getattr(args, "api", None)))
+
+
+def require_session(client: ApiClient) -> dict[str, Any]:
+    session = client.store.session()
+    if not session:
+        raise SermoApiError("还没有登录。请先运行 sermo login。", "NOT_LOGGED_IN", 0)
+    return session
+
+
+def prompt_if_missing(value: str | None, label: str) -> str:
+    if value:
+        return value
+    while True:
+        entered = input(f"{label}: ").strip()
+        if entered:
+            return entered
+
+
+def command_login(args: argparse.Namespace) -> int:
+    client = build_client(args)
+    slug = prompt_if_missing(args.space, "空间 slug")
+    name = prompt_if_missing(args.name, "昵称")
+    password = args.password
+
+    try:
+        payload = client.join(slug, name, password, args.language)
+    except SermoApiError as exc:
+        if exc.identifier == "USER@PASSWORD_REQUIRED":
+            password = getpass.getpass("这个昵称需要访问密码: ")
+            payload = client.join(slug, name, password, args.language)
+        else:
+            raise
+
+    session = {
+        "access_token": payload["auth"]["auth"],
+        "refresh_token": payload["auth"]["refresh"],
+        "user": payload["auth"]["data"],
+        "space": payload["space"],
+    }
+    client.store.set_session(session, client.api_base_url)
+    print(style.green("已进入空间"))
+    print(f"{payload['space']['name']} @{payload['space']['slug']} · {payload['auth']['data']['name']}")
+    return 0
+
+
+def command_logout(args: argparse.Namespace) -> int:
+    client = build_client(args)
+    client.logout()
+    print("已退出登录。")
+    return 0
+
+
+def command_me(args: argparse.Namespace) -> int:
+    client = build_client(args)
+    require_session(client)
+    me = client.me()
+    space = client.space_me()
+    print_header(f"{me.get('name')} @ {space.get('slug')}", space.get("name"))
+    print(f"用户 ID: {me.get('user_id')}")
+    print(f"身份: {'Official' if me.get('official') else 'Member'}")
+    print(f"认证: {'已认证' if me.get('verified') else '未认证'}")
+    print(f"密码: {'已设置' if me.get('has_password') else '未设置'}")
+    return 0
+
+
+def command_chats(args: argparse.Namespace) -> int:
+    client = build_client(args)
+    session = require_session(client)
+    chats = client.chats()
+    self_user_id = session.get("user", {}).get("user_id")
+    if not chats:
+        print("暂无会话。")
+        return 0
+    print_header("聊天")
+    for chat in chats:
+        last = chat.get("last_message")
+        preview = message_text(last) if last else "暂无消息"
+        unread = chat.get("unread_count") or 0
+        badge = style.green(f" +{unread}") if unread else ""
+        print(f"{style.cyan(str(chat['chat_id']).rjust(4))}  {chat_title(chat, self_user_id)}{badge}")
+        print(f"      {style.muted(format_time(chat.get('last_chat_at')))}  {preview}")
+    return 0
+
+
+def render_messages(messages: list[dict[str, Any]], self_user_id: int | None) -> None:
+    for message in sorted(messages, key=lambda item: item.get("message_id") or 0):
+        author = "我" if message.get("user", {}).get("user_id") == self_user_id else user_name(message.get("user"))
+        text = message_text(message)
+        timestamp = format_time(message.get("created_at"), full=True)
+        print(f"{style.muted(timestamp)} {style.bold(author)}: {text}")
+
+
+def command_chat(args: argparse.Namespace) -> int:
+    client = build_client(args)
+    session = require_session(client)
+    self_user_id = session.get("user", {}).get("user_id")
+    messages = client.messages(args.chat_id, limit=args.limit)
+    render_messages(messages, self_user_id)
+    if not args.no_mark_read:
+        client.mark_read(args.chat_id)
+
+    if args.follow:
+        last_seen = max((item.get("message_id") or 0 for item in messages), default=0)
+        print(style.muted("进入实时刷新模式，按 Ctrl+C 退出。"))
+        try:
+            while True:
+                time.sleep(args.interval)
+                newer = client.messages(args.chat_id, limit=50, after=last_seen)
+                if newer:
+                    render_messages(newer, self_user_id)
+                    last_seen = max(item.get("message_id") or last_seen for item in newer)
+                    if not args.no_mark_read:
+                        client.mark_read(args.chat_id)
+        except KeyboardInterrupt:
+            print()
+        return 0
+
+    if not sys.stdin.isatty():
+        return 0
+
+    print(style.muted("输入消息并回车发送；/refresh 刷新；/quit 退出。"))
+    last_seen = max((item.get("message_id") or 0 for item in messages), default=0)
+    while True:
+        try:
+            text = input("> ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print()
+            return 0
+        if not text:
+            continue
+        if text in {"/q", "/quit", "退出"}:
+            return 0
+        if text == "/refresh":
+            newer = client.messages(args.chat_id, limit=50, after=last_seen)
+            render_messages(newer, self_user_id)
+            if newer:
+                last_seen = max(item.get("message_id") or last_seen for item in newer)
+            continue
+        message = client.send_text(args.chat_id, text)
+        render_messages([message], self_user_id)
+        last_seen = max(last_seen, message.get("message_id") or last_seen)
+
+
+def command_send(args: argparse.Namespace) -> int:
+    client = build_client(args)
+    session = require_session(client)
+    text = " ".join(args.text).strip()
+    if not text:
+        text = prompt_if_missing(None, "消息")
+    message = client.send_text(args.chat_id, text)
+    render_messages([message], session.get("user", {}).get("user_id"))
+    return 0
+
+
+def command_friends(args: argparse.Namespace) -> int:
+    client = build_client(args)
+    require_session(client)
+    friends = client.friends()
+    if not friends:
+        print("暂无好友。")
+        return 0
+    print_header("好友")
+    for friend in friends:
+        online = style.green("在线") if friend.get("is_alive") else style.muted("离线")
+        print(f"{str(friend.get('user_id')).rjust(4)}  {user_name(friend)}  {online}")
+    return 0
+
+
+def command_requests(args: argparse.Namespace) -> int:
+    client = build_client(args)
+    require_session(client)
+    payload = client.friend_requests()
+    incoming = payload.get("incoming") or []
+    outgoing = payload.get("outgoing") or []
+    print_header("好友申请")
+    print(style.bold("收到的"))
+    if incoming:
+        for item in incoming:
+            print(f"{item.get('request_id')}: {user_name(item.get('from_user'))} -> 我")
+    else:
+        print(style.muted("暂无"))
+    print(style.bold("发出的"))
+    if outgoing:
+        for item in outgoing:
+            print(f"{item.get('request_id')}: 我 -> {user_name(item.get('to_user'))}")
+    else:
+        print(style.muted("暂无"))
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="sermo", description="Sermo 命令行客户端")
+    parser.add_argument("--api", help="Sermo API 地址，默认读取 SERMO_API_BASE 或 https://api.sermo.jyonn.space")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    login = subparsers.add_parser("login", help="进入空间 / 登录昵称")
+    login.add_argument("-s", "--space", help="空间 slug")
+    login.add_argument("-n", "--name", help="昵称")
+    login.add_argument("-p", "--password", help="访问密码")
+    login.add_argument("--language", default="zh-CN", choices=["zh-CN", "en"], help="偏好语言")
+    login.set_defaults(func=command_login)
+
+    logout = subparsers.add_parser("logout", help="退出登录")
+    logout.set_defaults(func=command_logout)
+
+    me = subparsers.add_parser("me", help="查看当前账户")
+    me.set_defaults(func=command_me)
+
+    chats = subparsers.add_parser("chats", help="查看聊天列表")
+    chats.set_defaults(func=command_chats)
+
+    chat = subparsers.add_parser("chat", help="打开聊天并发送文字")
+    chat.add_argument("chat_id", type=int)
+    chat.add_argument("-n", "--limit", type=int, default=30)
+    chat.add_argument("--follow", action="store_true", help="持续刷新新消息")
+    chat.add_argument("--interval", type=float, default=5.0, help="follow 刷新间隔秒数")
+    chat.add_argument("--no-mark-read", action="store_true", help="不标记已读")
+    chat.set_defaults(func=command_chat)
+
+    send = subparsers.add_parser("send", help="发送一条文字消息")
+    send.add_argument("chat_id", type=int)
+    send.add_argument("text", nargs="*")
+    send.set_defaults(func=command_send)
+
+    friends = subparsers.add_parser("friends", help="查看好友")
+    friends.set_defaults(func=command_friends)
+
+    requests = subparsers.add_parser("requests", help="查看好友申请")
+    requests.set_defaults(func=command_requests)
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    try:
+        return args.func(args)
+    except SermoApiError as exc:
+        print(style.red(str(exc)), file=sys.stderr)
+        return 1
+    except KeyboardInterrupt:
+        print()
+        return 130
+

sermo-0.1.0/sermo_cli/formatting.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+import sys
+from datetime import datetime
+from typing import Any
+
+
+MESSAGE_PLACEHOLDERS = {
+    "image": "[图片]",
+    "video": "[视频]",
+    "audio": "[语音]",
+    "file": "[文件]",
+    "system": "[系统消息]",
+}
+
+TYPE_PLACEHOLDERS = {
+    1: "[图片]",
+    2: "[文件]",
+    3: "[系统消息]",
+    4: "[视频]",
+    5: "[语音]",
+}
+
+
+class Style:
+    def __init__(self):
+        self.enabled = sys.stdout.isatty()
+
+    def wrap(self, text: str, code: str) -> str:
+        if not self.enabled:
+            return text
+        return f"\033[{code}m{text}\033[0m"
+
+    def bold(self, text: str) -> str:
+        return self.wrap(text, "1")
+
+    def muted(self, text: str) -> str:
+        return self.wrap(text, "90")
+
+    def green(self, text: str) -> str:
+        return self.wrap(text, "32")
+
+    def cyan(self, text: str) -> str:
+        return self.wrap(text, "36")
+
+    def red(self, text: str) -> str:
+        return self.wrap(text, "31")
+
+
+style = Style()
+
+
+def format_time(value: float | int | None, full: bool = False) -> str:
+    if not value:
+        return "-"
+    fmt = "%Y-%m-%d %H:%M" if full else "%m-%d %H:%M"
+    return datetime.fromtimestamp(float(value)).strftime(fmt)
+
+
+def user_name(user: dict[str, Any] | None) -> str:
+    if not user:
+        return "未知用户"
+    return str(user.get("name") or f"User#{user.get('user_id', '?')}")
+
+
+def chat_title(chat: dict[str, Any], self_user_id: int | None = None) -> str:
+    if chat.get("group"):
+        title = chat.get("title") or "群聊"
+        count = len(chat.get("members") or [])
+        return f"{title} ({count}人)"
+    owner = chat.get("owner")
+    if owner:
+        return user_name(owner)
+    members = chat.get("members") or []
+    for member in members:
+        if member.get("user_id") != self_user_id:
+            return user_name(member)
+    return chat.get("title") or "私聊"
+
+
+def message_text(message: dict[str, Any]) -> str:
+    payload = message.get("payload") or {}
+    kind = payload.get("kind")
+    if kind == "text":
+        return str(payload.get("text") or message.get("content") or "")
+    if kind in MESSAGE_PLACEHOLDERS:
+        if kind == "audio" and payload.get("duration_seconds"):
+            return f"[语音 {int(payload['duration_seconds'])}s]"
+        return MESSAGE_PLACEHOLDERS[kind]
+    msg_type = message.get("type")
+    if msg_type in TYPE_PLACEHOLDERS:
+        return TYPE_PLACEHOLDERS[msg_type]
+    return str(message.get("content") or "")
+
+
+def print_header(title: str, subtitle: str | None = None) -> None:
+    print(style.bold(title))
+    if subtitle:
+        print(style.muted(subtitle))
+

sermo-0.1.0/sermo_cli/store.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+
+DEFAULT_API_BASE_URL = "https://api.sermo.jyonn.space"
+CONFIG_ENV = "SERMO_CLI_CONFIG"
+API_ENV = "SERMO_API_BASE"
+
+
+class SessionStore:
+    def __init__(self, path: Path | None = None):
+        self.path = path or self.default_path()
+        self._data: dict[str, Any] | None = None
+
+    @staticmethod
+    def default_path() -> Path:
+        configured = os.environ.get(CONFIG_ENV)
+        if configured:
+            return Path(configured).expanduser()
+        return Path.home() / ".sermo-cli" / "config.json"
+
+    def load(self) -> dict[str, Any]:
+        if self._data is not None:
+            return self._data
+        if not self.path.exists():
+            self._data = {}
+            return self._data
+        try:
+            self._data = json.loads(self.path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            self._data = {}
+        return self._data
+
+    def save(self, data: dict[str, Any]) -> None:
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self.path.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+        try:
+            self.path.chmod(0o600)
+        except OSError:
+            pass
+        self._data = data
+
+    def clear(self) -> None:
+        self._data = {}
+        if self.path.exists():
+            self.path.unlink()
+
+    def api_base_url(self, override: str | None = None) -> str:
+        raw = override or os.environ.get(API_ENV) or self.load().get("api_base_url") or DEFAULT_API_BASE_URL
+        return str(raw).rstrip("/")
+
+    def session(self) -> dict[str, Any] | None:
+        session = self.load().get("session")
+        return session if isinstance(session, dict) else None
+
+    def set_session(self, session: dict[str, Any], api_base_url: str) -> None:
+        data = self.load().copy()
+        data["api_base_url"] = api_base_url.rstrip("/")
+        data["session"] = session
+        self.save(data)
+
+    def update_session(self, patch: dict[str, Any]) -> None:
+        data = self.load().copy()
+        current = data.get("session") if isinstance(data.get("session"), dict) else {}
+        current.update(patch)
+        data["session"] = current
+        self.save(data)
+

sermo-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+