livsyn-rdp-cli 0.1.0__tar.gz

livsyn_rdp_cli-0.1.0/PKG-INFO

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: livsyn-rdp-cli
+Version: 0.1.0
+Summary: RDP signed API client and managed SSH connection
+Home-page: https://git.lingrobotics.com/cloud_service/rdp-cli
+Author: Livsyn Robotics
+Project-URL: Source, https://git.lingrobotics.com/cloud_service/rdp-cli
+Classifier: Environment :: Console
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: System :: Networking
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: http-message-signatures==2.0.0
+Requires-Dist: typing-extensions==4.16.0
+
+# RDP CLI
+
+通过个人 AK/SK 查询授权设备、建立 SSH 连接并自动续租。Python 包名为 `livsyn-rdp-cli`，安装后的命令为 `rdp`。
+
+客户端从 RDP 仓库拆出，后续在此独立维护。服务端采用管理员代发模式：技术管理员为技术员签发凭据，技术员使用本人凭据；超管保留管理权限。
+
+## 安装
+
+需要 Python 3.10+ 和本机 OpenSSH。支持 Linux/macOS，Windows 使用 WSL。
+
+推荐使用 pipx 安装，安装后可以直接执行 `rdp`：
+
+```bash
+pipx install livsyn-rdp-cli
+rdp --help
+```
+
+也可以安装到 Python 虚拟环境：
+
+```bash
+python3 -m venv .venv
+.venv/bin/python -m pip install livsyn-rdp-cli
+.venv/bin/rdp --help
+```
+
+升级时执行 `pipx upgrade livsyn-rdp-cli`，或在虚拟环境中执行 `.venv/bin/python -m pip install --upgrade livsyn-rdp-cli`。
+
+从 PyPI 安装无需 GitLab 权限。需要从源码安装时，使用具有仓库读取权限的 Git 账号：
+
+```bash
+git clone https://git.lingrobotics.com/cloud_service/rdp-cli.git
+cd rdp-cli
+python3 -m venv .venv
+.venv/bin/pip install .
+.venv/bin/rdp --help
+```
+
+也可以直接从 GitLab 安装：
+
+```bash
+pipx install 'git+https://git.lingrobotics.com/cloud_service/rdp-cli.git'
+```
+
+仓库认证使用已有 Git 凭据，不要把密码或访问令牌写进安装 URL。安装包仅包含客户端；连接设备仍需要平台签发的有效 AK/SK。
+
+## 配置凭据
+
+1. 由技术管理员登录 [RDP](https://rdp.lingrobotics.com)，进入右上角“API 凭据”→“签发凭据”。
+2. 选择技术员和有效期即可，名称自动生成，权限及客户范围自动带入，无需重复配置。将 AK 和仅显示一次的 SK 安全交付本人。
+3. 技术员在运行客户端的机器上执行 `rdp configure`，按提示输入地址、AK、SK。默认地址为 `https://rdp.lingrobotics.com`；使用虚拟环境安装时执行 `.venv/bin/rdp configure`。
+
+技术员可在平台查看和撤销本人凭据，不能自行签发、重置或扩权；重置请联系技术管理员。收回客户权限会实时生效，新增客户不会自动扩大旧凭据范围，需要签发新凭据。
+
+SK 仅在创建时显示一次。配置程序交互读取 SK，优先使用已安装且可用的 Python keyring；否则保存到权限 `0600` 的 `~/.config/rdp/credentials.json`。可通过 `RDP_CREDENTIAL_FILE` 指定私有配置路径。不要把 SK 放入命令参数、源码、聊天或日志。
+
+后续示例使用已加入 PATH 的 `rdp`；从仓库虚拟环境运行时，将其替换为 `.venv/bin/rdp`。
+
+## 使用
+
+```bash
+rdp devices
+rdp ssh 221
+rdp ssh DEVICE_REF_UUID
+rdp ssh 唯一设备名称
+rdp sessions
+rdp sessions close SESSION_ID
+```
+
+节点号和名称需要 `devices:read`；只有 `ssh:connect` 的凭据可以直接连接已知的稳定 `device_ref`。长期脚本优先保存稳定引用，每个窗口对应独立会话。
+
+SSH 用户和端口由平台管理。CLI 自动签名、获取一次性票据、校验 Gateway 主机公钥并续租；退出后回收会话。网络故障按租约过期收回，不自动重跑远程命令。单个会话仍有 24 小时绝对上限。
+
+当前支持交互 shell 和通过标准输入执行命令。检查命令示例（设备编号替换为本人有权访问的设备）：
+
+```bash
+printf 'hostname\nuptime\ndf -h\nexit\n' | rdp ssh 221
+```
+
+当前没有独立的 `rdp exec` 子命令。新模式不支持 SFTP/SCP、VS Code Remote、端口转发或 SSH 连接复用。直接使用 API 票据运行裸 SSH 不会自动续租。
+
+## Codex 使用
+
+在哪台机器运行 Codex，就在哪台机器安装并配置本客户端。凭据由用户在终端配置，模型无需读取或输出凭据文件。可以给 Codex 这样的指令：
+
+> 使用本机 RDP CLI 查询授权设备，再连接设备 #221，检查主机名、运行时间和磁盘使用情况，完成后退出。凭据已经配置，不要读取或输出凭据文件。若命令不在 PATH，使用客户端虚拟环境中的 rdp 绝对路径。
+
+## Python SDK
+
+```python
+from rdp_cli import Client
+
+# 从调用端私有凭据配置取得以下值，不写进源码。
+client = Client(origin, access_key, secret_key)
+devices = client.request("GET", "/api/automation/v1/devices")
+```
+
+SDK 负责 RFC 9421 签名、正文摘要、防重放 nonce 和 POST 幂等键。429/503 有限重试，每次重试使用新签名；SDK 不跟随重定向。创建会话的响应包含短期票据，不要直接打印或记录。
+
+SDK 本身不启动 SSH 或续租线程；需要在线续租的交互连接使用 `rdp ssh`。CLI 已封装接口调用，技术员无需查看接口文档。完整契约见仅技术管理员和超管可访问的 [RDP OpenAPI 文档](https://rdp.lingrobotics.com/api-docs/automation)。
+
+## 开发与打包
+
+```bash
+python3 -m venv .venv
+.venv/bin/pip install . build
+.venv/bin/python -m unittest discover -s tests
+.venv/bin/python -m build
+```
+
+构建后，使用 `python -m twine check --strict dist/*` 检查分发包，再通过已配置的 PyPI 发布凭据上传。发布 Token 不写入仓库或命令参数。
+
+运行时代码最初取自 `cloud_service/rdp` 的提交 `e2766b6b4f0d313e3d2b45810726c7a437701c6a`，目录为 `cli/`。独立仓库不包含 RDP 后端、私有配置或运行时凭据。

livsyn_rdp_cli-0.1.0/README.md

@@ -0,0 +1,112 @@
+# RDP CLI
+
+通过个人 AK/SK 查询授权设备、建立 SSH 连接并自动续租。Python 包名为 `livsyn-rdp-cli`，安装后的命令为 `rdp`。
+
+客户端从 RDP 仓库拆出，后续在此独立维护。服务端采用管理员代发模式：技术管理员为技术员签发凭据，技术员使用本人凭据；超管保留管理权限。
+
+## 安装
+
+需要 Python 3.10+ 和本机 OpenSSH。支持 Linux/macOS，Windows 使用 WSL。
+
+推荐使用 pipx 安装，安装后可以直接执行 `rdp`：
+
+```bash
+pipx install livsyn-rdp-cli
+rdp --help
+```
+
+也可以安装到 Python 虚拟环境：
+
+```bash
+python3 -m venv .venv
+.venv/bin/python -m pip install livsyn-rdp-cli
+.venv/bin/rdp --help
+```
+
+升级时执行 `pipx upgrade livsyn-rdp-cli`，或在虚拟环境中执行 `.venv/bin/python -m pip install --upgrade livsyn-rdp-cli`。
+
+从 PyPI 安装无需 GitLab 权限。需要从源码安装时，使用具有仓库读取权限的 Git 账号：
+
+```bash
+git clone https://git.lingrobotics.com/cloud_service/rdp-cli.git
+cd rdp-cli
+python3 -m venv .venv
+.venv/bin/pip install .
+.venv/bin/rdp --help
+```
+
+也可以直接从 GitLab 安装：
+
+```bash
+pipx install 'git+https://git.lingrobotics.com/cloud_service/rdp-cli.git'
+```
+
+仓库认证使用已有 Git 凭据，不要把密码或访问令牌写进安装 URL。安装包仅包含客户端；连接设备仍需要平台签发的有效 AK/SK。
+
+## 配置凭据
+
+1. 由技术管理员登录 [RDP](https://rdp.lingrobotics.com)，进入右上角“API 凭据”→“签发凭据”。
+2. 选择技术员和有效期即可，名称自动生成，权限及客户范围自动带入，无需重复配置。将 AK 和仅显示一次的 SK 安全交付本人。
+3. 技术员在运行客户端的机器上执行 `rdp configure`，按提示输入地址、AK、SK。默认地址为 `https://rdp.lingrobotics.com`；使用虚拟环境安装时执行 `.venv/bin/rdp configure`。
+
+技术员可在平台查看和撤销本人凭据，不能自行签发、重置或扩权；重置请联系技术管理员。收回客户权限会实时生效，新增客户不会自动扩大旧凭据范围，需要签发新凭据。
+
+SK 仅在创建时显示一次。配置程序交互读取 SK，优先使用已安装且可用的 Python keyring；否则保存到权限 `0600` 的 `~/.config/rdp/credentials.json`。可通过 `RDP_CREDENTIAL_FILE` 指定私有配置路径。不要把 SK 放入命令参数、源码、聊天或日志。
+
+后续示例使用已加入 PATH 的 `rdp`；从仓库虚拟环境运行时，将其替换为 `.venv/bin/rdp`。
+
+## 使用
+
+```bash
+rdp devices
+rdp ssh 221
+rdp ssh DEVICE_REF_UUID
+rdp ssh 唯一设备名称
+rdp sessions
+rdp sessions close SESSION_ID
+```
+
+节点号和名称需要 `devices:read`；只有 `ssh:connect` 的凭据可以直接连接已知的稳定 `device_ref`。长期脚本优先保存稳定引用，每个窗口对应独立会话。
+
+SSH 用户和端口由平台管理。CLI 自动签名、获取一次性票据、校验 Gateway 主机公钥并续租；退出后回收会话。网络故障按租约过期收回，不自动重跑远程命令。单个会话仍有 24 小时绝对上限。
+
+当前支持交互 shell 和通过标准输入执行命令。检查命令示例（设备编号替换为本人有权访问的设备）：
+
+```bash
+printf 'hostname\nuptime\ndf -h\nexit\n' | rdp ssh 221
+```
+
+当前没有独立的 `rdp exec` 子命令。新模式不支持 SFTP/SCP、VS Code Remote、端口转发或 SSH 连接复用。直接使用 API 票据运行裸 SSH 不会自动续租。
+
+## Codex 使用
+
+在哪台机器运行 Codex，就在哪台机器安装并配置本客户端。凭据由用户在终端配置，模型无需读取或输出凭据文件。可以给 Codex 这样的指令：
+
+> 使用本机 RDP CLI 查询授权设备，再连接设备 #221，检查主机名、运行时间和磁盘使用情况，完成后退出。凭据已经配置，不要读取或输出凭据文件。若命令不在 PATH，使用客户端虚拟环境中的 rdp 绝对路径。
+
+## Python SDK
+
+```python
+from rdp_cli import Client
+
+# 从调用端私有凭据配置取得以下值，不写进源码。
+client = Client(origin, access_key, secret_key)
+devices = client.request("GET", "/api/automation/v1/devices")
+```
+
+SDK 负责 RFC 9421 签名、正文摘要、防重放 nonce 和 POST 幂等键。429/503 有限重试，每次重试使用新签名；SDK 不跟随重定向。创建会话的响应包含短期票据，不要直接打印或记录。
+
+SDK 本身不启动 SSH 或续租线程；需要在线续租的交互连接使用 `rdp ssh`。CLI 已封装接口调用，技术员无需查看接口文档。完整契约见仅技术管理员和超管可访问的 [RDP OpenAPI 文档](https://rdp.lingrobotics.com/api-docs/automation)。
+
+## 开发与打包
+
+```bash
+python3 -m venv .venv
+.venv/bin/pip install . build
+.venv/bin/python -m unittest discover -s tests
+.venv/bin/python -m build
+```
+
+构建后，使用 `python -m twine check --strict dist/*` 检查分发包，再通过已配置的 PyPI 发布凭据上传。发布 Token 不写入仓库或命令参数。
+
+运行时代码最初取自 `cloud_service/rdp` 的提交 `e2766b6b4f0d313e3d2b45810726c7a437701c6a`，目录为 `cli/`。独立仓库不包含 RDP 后端、私有配置或运行时凭据。

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

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: livsyn-rdp-cli
+Version: 0.1.0
+Summary: RDP signed API client and managed SSH connection
+Home-page: https://git.lingrobotics.com/cloud_service/rdp-cli
+Author: Livsyn Robotics
+Project-URL: Source, https://git.lingrobotics.com/cloud_service/rdp-cli
+Classifier: Environment :: Console
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: System :: Networking
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: http-message-signatures==2.0.0
+Requires-Dist: typing-extensions==4.16.0
+
+# RDP CLI
+
+通过个人 AK/SK 查询授权设备、建立 SSH 连接并自动续租。Python 包名为 `livsyn-rdp-cli`，安装后的命令为 `rdp`。
+
+客户端从 RDP 仓库拆出，后续在此独立维护。服务端采用管理员代发模式：技术管理员为技术员签发凭据，技术员使用本人凭据；超管保留管理权限。
+
+## 安装
+
+需要 Python 3.10+ 和本机 OpenSSH。支持 Linux/macOS，Windows 使用 WSL。
+
+推荐使用 pipx 安装，安装后可以直接执行 `rdp`：
+
+```bash
+pipx install livsyn-rdp-cli
+rdp --help
+```
+
+也可以安装到 Python 虚拟环境：
+
+```bash
+python3 -m venv .venv
+.venv/bin/python -m pip install livsyn-rdp-cli
+.venv/bin/rdp --help
+```
+
+升级时执行 `pipx upgrade livsyn-rdp-cli`，或在虚拟环境中执行 `.venv/bin/python -m pip install --upgrade livsyn-rdp-cli`。
+
+从 PyPI 安装无需 GitLab 权限。需要从源码安装时，使用具有仓库读取权限的 Git 账号：
+
+```bash
+git clone https://git.lingrobotics.com/cloud_service/rdp-cli.git
+cd rdp-cli
+python3 -m venv .venv
+.venv/bin/pip install .
+.venv/bin/rdp --help
+```
+
+也可以直接从 GitLab 安装：
+
+```bash
+pipx install 'git+https://git.lingrobotics.com/cloud_service/rdp-cli.git'
+```
+
+仓库认证使用已有 Git 凭据，不要把密码或访问令牌写进安装 URL。安装包仅包含客户端；连接设备仍需要平台签发的有效 AK/SK。
+
+## 配置凭据
+
+1. 由技术管理员登录 [RDP](https://rdp.lingrobotics.com)，进入右上角“API 凭据”→“签发凭据”。
+2. 选择技术员和有效期即可，名称自动生成，权限及客户范围自动带入，无需重复配置。将 AK 和仅显示一次的 SK 安全交付本人。
+3. 技术员在运行客户端的机器上执行 `rdp configure`，按提示输入地址、AK、SK。默认地址为 `https://rdp.lingrobotics.com`；使用虚拟环境安装时执行 `.venv/bin/rdp configure`。
+
+技术员可在平台查看和撤销本人凭据，不能自行签发、重置或扩权；重置请联系技术管理员。收回客户权限会实时生效，新增客户不会自动扩大旧凭据范围，需要签发新凭据。
+
+SK 仅在创建时显示一次。配置程序交互读取 SK，优先使用已安装且可用的 Python keyring；否则保存到权限 `0600` 的 `~/.config/rdp/credentials.json`。可通过 `RDP_CREDENTIAL_FILE` 指定私有配置路径。不要把 SK 放入命令参数、源码、聊天或日志。
+
+后续示例使用已加入 PATH 的 `rdp`；从仓库虚拟环境运行时，将其替换为 `.venv/bin/rdp`。
+
+## 使用
+
+```bash
+rdp devices
+rdp ssh 221
+rdp ssh DEVICE_REF_UUID
+rdp ssh 唯一设备名称
+rdp sessions
+rdp sessions close SESSION_ID
+```
+
+节点号和名称需要 `devices:read`；只有 `ssh:connect` 的凭据可以直接连接已知的稳定 `device_ref`。长期脚本优先保存稳定引用，每个窗口对应独立会话。
+
+SSH 用户和端口由平台管理。CLI 自动签名、获取一次性票据、校验 Gateway 主机公钥并续租；退出后回收会话。网络故障按租约过期收回，不自动重跑远程命令。单个会话仍有 24 小时绝对上限。
+
+当前支持交互 shell 和通过标准输入执行命令。检查命令示例（设备编号替换为本人有权访问的设备）：
+
+```bash
+printf 'hostname\nuptime\ndf -h\nexit\n' | rdp ssh 221
+```
+
+当前没有独立的 `rdp exec` 子命令。新模式不支持 SFTP/SCP、VS Code Remote、端口转发或 SSH 连接复用。直接使用 API 票据运行裸 SSH 不会自动续租。
+
+## Codex 使用
+
+在哪台机器运行 Codex，就在哪台机器安装并配置本客户端。凭据由用户在终端配置，模型无需读取或输出凭据文件。可以给 Codex 这样的指令：
+
+> 使用本机 RDP CLI 查询授权设备，再连接设备 #221，检查主机名、运行时间和磁盘使用情况，完成后退出。凭据已经配置，不要读取或输出凭据文件。若命令不在 PATH，使用客户端虚拟环境中的 rdp 绝对路径。
+
+## Python SDK
+
+```python
+from rdp_cli import Client
+
+# 从调用端私有凭据配置取得以下值，不写进源码。
+client = Client(origin, access_key, secret_key)
+devices = client.request("GET", "/api/automation/v1/devices")
+```
+
+SDK 负责 RFC 9421 签名、正文摘要、防重放 nonce 和 POST 幂等键。429/503 有限重试，每次重试使用新签名；SDK 不跟随重定向。创建会话的响应包含短期票据，不要直接打印或记录。
+
+SDK 本身不启动 SSH 或续租线程；需要在线续租的交互连接使用 `rdp ssh`。CLI 已封装接口调用，技术员无需查看接口文档。完整契约见仅技术管理员和超管可访问的 [RDP OpenAPI 文档](https://rdp.lingrobotics.com/api-docs/automation)。
+
+## 开发与打包
+
+```bash
+python3 -m venv .venv
+.venv/bin/pip install . build
+.venv/bin/python -m unittest discover -s tests
+.venv/bin/python -m build
+```
+
+构建后，使用 `python -m twine check --strict dist/*` 检查分发包，再通过已配置的 PyPI 发布凭据上传。发布 Token 不写入仓库或命令参数。
+
+运行时代码最初取自 `cloud_service/rdp` 的提交 `e2766b6b4f0d313e3d2b45810726c7a437701c6a`，目录为 `cli/`。独立仓库不包含 RDP 后端、私有配置或运行时凭据。

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

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+setup.cfg
+livsyn_rdp_cli.egg-info/PKG-INFO
+livsyn_rdp_cli.egg-info/SOURCES.txt
+livsyn_rdp_cli.egg-info/dependency_links.txt
+livsyn_rdp_cli.egg-info/entry_points.txt
+livsyn_rdp_cli.egg-info/requires.txt
+livsyn_rdp_cli.egg-info/top_level.txt
+rdp_cli/__init__.py
+rdp_cli/client.py
+rdp_cli/main.py
+tests/test_client.py

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,2 @@
+[console_scripts]
+rdp = rdp_cli.main:main

livsyn_rdp_cli-0.1.0/livsyn_rdp_cli.egg-info/requires.txt

@@ -0,0 +1,2 @@
+http-message-signatures==2.0.0
+typing-extensions==4.16.0

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

@@ -0,0 +1 @@
+rdp_cli

livsyn_rdp_cli-0.1.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"

livsyn_rdp_cli-0.1.0/rdp_cli/__init__.py

@@ -0,0 +1,3 @@
+from .client import Client, ApiError
+
+__all__ = ['Client', 'ApiError']

livsyn_rdp_cli-0.1.0/rdp_cli/client.py

@@ -0,0 +1,94 @@
+import base64
+import hashlib
+import json
+import secrets
+import time
+import uuid
+from datetime import datetime, timedelta, timezone
+from types import SimpleNamespace
+from urllib.error import HTTPError
+from urllib.parse import urlencode, urlsplit
+from urllib.request import HTTPRedirectHandler, Request, build_opener
+
+from http_message_signatures import HTTPMessageSigner, HTTPSignatureKeyResolver, algorithms, http_sfv
+
+BASE = '/api/automation/v1'
+
+
+class ApiError(Exception):
+    def __init__(self, code, message, status=0, details=None):
+        super().__init__(message)
+        self.code, self.status, self.details = code, status, details or {}
+
+
+class NoRedirect(HTTPRedirectHandler):
+    def redirect_request(self, *args, **kwargs):
+        return None
+
+
+class KeyResolver(HTTPSignatureKeyResolver):
+    def __init__(self, key):
+        self.key = key
+
+    def resolve_private_key(self, key_id):
+        return self.key
+
+
+class Client:
+    def __init__(self, origin, access_key, secret_key):
+        parsed = urlsplit(origin)
+        if parsed.scheme != 'https' or not parsed.hostname or parsed.username or parsed.password or parsed.query or parsed.fragment or parsed.path not in ('', '/'):
+            raise ValueError('平台地址必须是 HTTPS origin')
+        self.origin, self.access_key = origin.rstrip('/'), access_key
+        key = base64.urlsafe_b64decode(secret_key + '=')
+        if len(key) != 32:
+            raise ValueError('SK 格式不正确')
+        self.signer = HTTPMessageSigner(signature_algorithm=algorithms.HMAC_SHA256, key_resolver=KeyResolver(key))
+        self.opener = build_opener(NoRedirect())
+
+    def signed_request(self, method, path, body, idempotency_key=None):
+        headers = {'Accept': 'application/json', 'Content-Digest': str(http_sfv.Dictionary({'sha-256': hashlib.sha256(body).digest()}))}
+        components = ['@method', '@target-uri', 'content-digest']
+        if method == 'POST':
+            headers.update({'Content-Type': 'application/json', 'Idempotency-Key': idempotency_key})
+            components += ['content-type', 'idempotency-key']
+        message = SimpleNamespace(method=method, url=self.origin + path, headers=headers)
+        created = datetime.now(timezone.utc)
+        self.signer.sign(message, key_id=self.access_key, created=created, expires=created + timedelta(seconds=60),
+                         nonce=secrets.token_urlsafe(18), label='rdp', tag='rdp-automation-v1', covered_component_ids=components)
+        return Request(message.url, data=body if method == 'POST' else None, method=method, headers=message.headers)
+
+    def request(self, method, path, payload=None, query=None, *, deadline=None, idempotency_key=None):
+        if not path.startswith(BASE + '/'):
+            raise ValueError('SDK 仅调用已授权的自动化 API')
+        if query:
+            path += '?' + urlencode({key: str(value).lower() if isinstance(value, bool) else value for key, value in query.items() if value is not None})
+        body = json.dumps(payload or {}, ensure_ascii=False, separators=(',', ':')).encode() if method == 'POST' else b''
+        key = idempotency_key or str(uuid.uuid4())
+        for attempt in range(3):
+            remaining = deadline - time.monotonic() if deadline is not None else 30
+            if remaining <= 0:
+                raise ApiError('lease_expired', '连接租约已到期')
+            request = self.signed_request(method, path, body, key)
+            try:
+                with self.opener.open(request, timeout=min(10, remaining)) as response:
+                    raw = response.read(2 * 1024 * 1024 + 1)
+                if len(raw) > 2 * 1024 * 1024:
+                    raise ApiError('invalid_response', 'API 响应过大')
+                return json.loads(raw)
+            except HTTPError as error:
+                try:
+                    result = json.loads(error.read(65536)).get('error', {})
+                except (ValueError, AttributeError):
+                    result = {}
+                if not isinstance(result, dict):
+                    result = {}
+                if error.code not in (429, 503) or attempt == 2:
+                    raise ApiError(result.get('code', 'http_error'), result.get('message', f'HTTP {error.code}'), error.code, result.get('details')) from None
+                try:
+                    delay = min(5, max(1, int(error.headers.get('Retry-After', '1'))))
+                except ValueError:
+                    delay = 1
+                if deadline is not None:
+                    delay = min(delay, max(0, deadline - time.monotonic()))
+                time.sleep(delay)

livsyn_rdp_cli-0.1.0/rdp_cli/main.py

@@ -0,0 +1,198 @@
+import argparse
+import base64
+import getpass
+import hashlib
+import json
+import os
+from pathlib import Path
+import re
+import socket
+import subprocess
+import sys
+import tempfile
+import threading
+import time
+from datetime import datetime
+
+from .client import ApiError, BASE, Client
+
+
+def config_path():
+    return Path(os.environ.get('RDP_CREDENTIAL_FILE', str(Path.home() / '.config/rdp/credentials.json')))
+
+
+def configure():
+    origin = input('RDP 地址 [https://rdp.lingrobotics.com]: ').strip() or 'https://rdp.lingrobotics.com'
+    access = input('Access Key: ').strip()
+    secret = getpass.getpass('Secret Key: ').strip()
+    client = Client(origin, access, secret)
+    client.request('GET', BASE + '/me')
+    path = config_path()
+    path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+    if path.is_symlink():
+        raise ValueError('凭据文件不能为符号链接')
+    value = {'origin': origin, 'access_key': access}
+    try:
+        import keyring
+        keyring.set_password('livsyn-rdp:' + origin, access, secret)
+        value['keyring'] = True
+    except (ImportError, RuntimeError):
+        value['secret_key'] = secret
+    fd, temporary = tempfile.mkstemp(prefix='.credentials-', dir=path.parent)
+    try:
+        with os.fdopen(fd, 'w') as stream:
+            json.dump(value, stream)
+        os.replace(temporary, path)
+    finally:
+        if os.path.exists(temporary):
+            os.unlink(temporary)
+    print('凭据已验证并保存。')
+
+
+def load_client():
+    path = config_path()
+    if path.is_symlink() or path.stat().st_mode & 0o077:
+        raise ValueError('凭据文件必须为本人可读写的 0600 普通文件')
+    value = json.loads(path.read_text())
+    if value.get('keyring'):
+        import keyring
+        secret = keyring.get_password('livsyn-rdp:' + value['origin'], value['access_key'])
+    else:
+        secret = value['secret_key']
+    return Client(value['origin'], value['access_key'], secret or '')
+
+
+def timestamp(value):
+    return datetime.fromisoformat(value.replace('Z', '+00:00')).timestamp()
+
+
+def write_known_hosts(gateway, path):
+    host, port = gateway['host'], gateway['port']
+    if not re.fullmatch(r'[A-Za-z0-9][A-Za-z0-9.-]{0,252}', host) or type(port) is not int or not 1 <= port <= 65535:
+        raise ValueError('Gateway 地址不正确')
+    lines = []
+    for key in gateway['host_keys']:
+        parts = key['public_key'].split()
+        if len(parts) < 2 or parts[0] != key['algorithm']:
+            raise ValueError('Gateway 主机公钥不正确')
+        raw = base64.b64decode(parts[1], validate=True)
+        fingerprint = 'SHA256:' + base64.b64encode(hashlib.sha256(raw).digest()).decode().rstrip('=')
+        if fingerprint != key['fingerprint'].rstrip('='):
+            raise ValueError('Gateway 公钥指纹不匹配')
+        lines.append(f'[{host}]:{port} {parts[0]} {parts[1]}')
+    if not lines:
+        raise ValueError('Gateway 没有可信主机公钥')
+    path.write_text('\n'.join(lines) + '\n')
+    path.chmod(0o600)
+
+
+def resolve_device(client, selector):
+    import uuid
+    try:
+        device_ref = str(uuid.UUID(selector))
+    except ValueError:
+        device_ref = None
+    if device_ref:
+        return {'device_ref': device_ref}
+    query = {'node_id': selector} if selector.isdigit() else {'search': selector}
+    result = client.request('GET', BASE + '/devices', query=query)
+    if result['total'] != 1:
+        raise ValueError('没有唯一匹配设备，请通过 rdp devices 查询并使用 device_ref 或精确节点号')
+    return result['items'][0]
+
+
+def ssh(client, selector):
+    device = resolve_device(client, selector)
+    created = client.request('POST', BASE + '/ssh/sessions', {'device_ref': device['device_ref'], 'label': socket.gethostname()[:80]})
+    session_id = created['session']['id']
+    stop, failures = threading.Event(), []
+    process = None
+
+    def supervise():
+        lease_deadline = time.monotonic() + 30
+        warned = False
+        while not stop.is_set():
+            try:
+                state = client.request('GET', BASE + '/ssh/sessions/' + session_id, deadline=lease_deadline)
+                if state['state'] in ('pending', 'connecting'):
+                    stop.wait(1)
+                    continue
+                if state['state'] != 'active':
+                    raise ApiError('session_ended', '会话已结束：' + str(state.get('close_reason') or state['state']))
+                lease_deadline = time.monotonic() + max(0, timestamp(state['lease_expires_at']) - time.time())
+                renewed = client.request('POST', BASE + '/ssh/sessions/' + session_id + '/renew', {}, deadline=lease_deadline)
+                lease_deadline = time.monotonic() + max(0, timestamp(renewed['lease_expires_at']) - time.time())
+                if renewed['identity_status_mode'] == 'grace' and not warned:
+                    print('SSO 状态刷新故障，连接进入有限宽限期：' + renewed['identity_grace_expires_at'], file=sys.stderr)
+                    warned = True
+                if timestamp(renewed['expires_at']) - time.time() <= 300:
+                    print('当前 SSH 会话距绝对上限不足 5 分钟，请保存工作。', file=sys.stderr)
+                stop.wait(min(renewed['renew_interval_seconds'], max(0, lease_deadline - time.monotonic()) / 3))
+            except Exception as error:
+                failures.append(str(error))
+                stop.set()
+                if process and process.poll() is None:
+                    process.terminate()
+                return
+
+    try:
+        admission = created['admission']
+        if not re.fullmatch(r'rdp_api_[A-Za-z0-9_-]+', admission['username']):
+            raise ValueError('连接票据格式不正确')
+        with tempfile.TemporaryDirectory(prefix='rdp-ssh-') as directory:
+            hosts = Path(directory) / 'known_hosts'
+            write_known_hosts(admission['gateway'], hosts)
+            args = ['ssh', '-o', 'ControlMaster=no', '-o', 'ControlPath=none', '-o', 'ControlPersist=no',
+                    '-o', 'ClearAllForwardings=yes', '-o', 'StrictHostKeyChecking=yes',
+                    '-o', 'UserKnownHostsFile=' + str(hosts), '-o', 'GlobalKnownHostsFile=/dev/null',
+                    '-o', 'KnownHostsCommand=none', '-o', 'PermitLocalCommand=no',
+                    '-o', 'ProxyCommand=none', '-o', 'ProxyJump=none', '-o', 'ForwardAgent=no', '-o', 'ForwardX11=no',
+                    '-p', str(admission['gateway']['port']), '-l', admission['username'], admission['gateway']['host']]
+            worker = threading.Thread(target=supervise, daemon=True)
+            worker.start()
+            process = subprocess.Popen(args)
+            if stop.is_set():
+                process.terminate()
+            code = process.wait()
+            stop.set()
+            worker.join(timeout=12)
+            if failures:
+                print(failures[0], file=sys.stderr)
+            return code
+    finally:
+        stop.set()
+        try:
+            client.request('POST', BASE + '/ssh/sessions/' + session_id + '/close', {})
+        except Exception:
+            pass
+
+
+def main():
+    parser = argparse.ArgumentParser(description='RDP 自动化设备连接')
+    commands = parser.add_subparsers(dest='command', required=True)
+    commands.add_parser('configure')
+    commands.add_parser('devices')
+    commands.add_parser('sessions').add_argument('close', nargs='*', metavar='[close SESSION_ID]')
+    commands.add_parser('ssh').add_argument('device')
+    args = parser.parse_args()
+    try:
+        if args.command == 'configure':
+            configure()
+            return
+        client = load_client()
+        if args.command == 'ssh':
+            sys.exit(ssh(client, args.device))
+        if args.command == 'sessions' and args.close:
+            if len(args.close) != 2 or args.close[0] != 'close':
+                parser.error('用法：rdp sessions close SESSION_ID')
+            value = client.request('POST', BASE + '/ssh/sessions/' + args.close[1] + '/close', {})
+        else:
+            value = client.request('GET', BASE + ('/devices' if args.command == 'devices' else '/ssh/sessions'))
+        print(json.dumps(value, ensure_ascii=False, indent=2))
+    except (ApiError, ValueError, OSError, KeyError) as error:
+        print(str(error), file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()

livsyn_rdp_cli-0.1.0/setup.cfg

@@ -0,0 +1,36 @@
+[metadata]
+name = livsyn-rdp-cli
+version = 0.1.0
+description = RDP signed API client and managed SSH connection
+author = Livsyn Robotics
+long_description = file: README.md
+long_description_content_type = text/markdown
+url = https://git.lingrobotics.com/cloud_service/rdp-cli
+project_urls = 
+	Source = https://git.lingrobotics.com/cloud_service/rdp-cli
+classifiers = 
+	Environment :: Console
+	Operating System :: POSIX :: Linux
+	Operating System :: MacOS
+	Programming Language :: Python :: 3
+	Programming Language :: Python :: 3 :: Only
+	Topic :: System :: Networking
+
+[options]
+packages = find:
+python_requires = >=3.10
+install_requires = 
+	http-message-signatures==2.0.0
+	typing-extensions==4.16.0
+
+[options.packages.find]
+include = rdp_cli*
+
+[options.entry_points]
+console_scripts = 
+	rdp = rdp_cli.main:main
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

livsyn_rdp_cli-0.1.0/tests/test_client.py

@@ -0,0 +1,86 @@
+import base64
+from datetime import timedelta
+from io import BytesIO
+import json
+from pathlib import Path
+from types import SimpleNamespace
+import tempfile
+import unittest
+from unittest.mock import Mock, patch
+from urllib.error import HTTPError
+
+from http_message_signatures import HTTPMessageVerifier, HTTPSignatureKeyResolver, algorithms
+from http_message_signatures.structures import CaseInsensitiveDict
+
+from rdp_cli.client import ApiError, BASE, Client
+from rdp_cli.main import load_client, resolve_device
+
+
+class FixtureKey(HTTPSignatureKeyResolver):
+    def resolve_public_key(self, key_id):
+        return b't' * 32
+
+
+class ClientTest(unittest.TestCase):
+    def setUp(self):
+        self.client = Client('https://rdp.test', 'rdp_ak_TEST_ONLY', base64.urlsafe_b64encode(b't' * 32).decode().rstrip('='))
+
+    def verify(self, request):
+        message = SimpleNamespace(method=request.method, url=request.full_url, headers=CaseInsensitiveDict(dict(request.header_items())))
+        verifier = HTTPMessageVerifier(signature_algorithm=algorithms.HMAC_SHA256, key_resolver=FixtureKey())
+        verifier.verify(message, max_age=timedelta(seconds=90), expect_label='rdp', expect_tag='rdp-automation-v1')
+
+    def test_get_signature_preserves_encoded_target(self):
+        request = self.client.signed_request('GET', BASE + '/devices?search=a%2Fb&online=true', b'')
+        self.verify(request)
+        self.assertTrue(request.full_url.endswith('search=a%2Fb&online=true'))
+
+    def test_post_signature_binds_idempotency_key(self):
+        request = self.client.signed_request('POST', BASE + '/ssh/sessions', b'{}', 'test-idempotency-key')
+        self.verify(request)
+        request.add_header('Idempotency-Key', 'tampered')
+        with self.assertRaises(Exception):
+            self.verify(request)
+
+    def test_transient_retry_preserves_idempotency_and_changes_signature(self):
+        response = Mock()
+        response.__enter__ = Mock(return_value=response)
+        response.__exit__ = Mock(return_value=False)
+        response.read.return_value = b'{"state":"pending"}'
+        failure = HTTPError('https://rdp.test', 503, 'Unavailable', {}, BytesIO(b'{"error":{"code":"unavailable"}}'))
+        with patch.object(self.client.opener, 'open', side_effect=[failure, response]) as opened, patch('rdp_cli.client.time.sleep'):
+            self.assertEqual(self.client.request('POST', BASE + '/ssh/sessions', {}, idempotency_key='retry-key'), {'state': 'pending'})
+        first, second = [call.args[0] for call in opened.call_args_list]
+        for request in (first, second):
+            self.verify(request)
+            self.assertEqual(request.get_header('Idempotency-key'), 'retry-key')
+        self.assertNotEqual(first.get_header('Signature-input'), second.get_header('Signature-input'))
+
+    def test_permission_denial_is_not_retried(self):
+        failure = HTTPError('https://rdp.test', 403, 'Forbidden', {}, BytesIO(b'{"error":{"code":"scope_denied","message":"denied"}}'))
+        with patch.object(self.client.opener, 'open', side_effect=failure) as opened:
+            with self.assertRaises(ApiError) as denied:
+                self.client.request('GET', BASE + '/devices')
+        self.assertEqual(denied.exception.status, 403)
+        opened.assert_called_once()
+
+    def test_known_device_ref_does_not_require_inventory_scope(self):
+        device_ref = '00000000-0000-4000-8000-000000000001'
+        with patch.object(self.client, 'request', side_effect=AssertionError('inventory lookup')):
+            self.assertEqual(resolve_device(self.client, device_ref), {'device_ref': device_ref})
+
+    def test_credentials_require_private_file_mode(self):
+        with tempfile.TemporaryDirectory() as folder:
+            path = Path(folder) / 'credentials.json'
+            path.write_text(json.dumps({'origin': self.client.origin, 'access_key': self.client.access_key,
+                                        'secret_key': base64.urlsafe_b64encode(b't' * 32).decode().rstrip('=')}))
+            with patch('rdp_cli.main.config_path', return_value=path):
+                path.chmod(0o644)
+                with self.assertRaises(ValueError):
+                    load_client()
+                path.chmod(0o600)
+                self.assertEqual(load_client().access_key, self.client.access_key)
+
+
+if __name__ == '__main__':
+    unittest.main()