ot-cli 0.2.1__py3-none-any.whl

openterminal/config.py

@@ -0,0 +1,322 @@
+"""配置加载：.env（项目 > ~/.openterminal/.env）+ config.toml + 默认值。
+
+模型协议由 .env 的 ANTHROPIC_* / OPENAI_* 二选一决定（都配=报错，都没配=报错）；
+config.toml 只管 shell/policy/web/targets 与模型名（credentials 以 .env 为准）。
+"""
+
+from __future__ import annotations
+
+import os
+import tomllib
+import urllib.error
+import urllib.request
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+def app_dir() -> Path:
+    return Path(
+        os.environ.get("OPENTERMINAL_HOME", str(Path.home() / ".openterminal"))
+    )
+
+
+def _parse_env_file(path: Path) -> dict[str, str]:
+    """极简 .env 解析：KEY=VALUE 行、# 注释、可选引号。脏行跳过不打挂。"""
+    out: dict[str, str] = {}
+    if not path.exists():
+        return out
+    try:
+        text = path.read_text(encoding="utf-8")
+    except OSError:
+        return out
+    for raw in text.splitlines():
+        line = raw.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        key, _, val = line.partition("=")
+        key = key.strip()
+        val = val.strip()
+        if len(val) >= 2 and val[0] == val[-1] and val[0] in ("'", '"'):
+            val = val[1:-1]
+        if key:
+            out[key] = val
+    return out
+
+
+# 凭据变量名：*_API_KEY 是 SDK 正式名；*_AUTH_TOKEN 是 Anthropic 生态与各类
+# 网关的另一个标准凭据名（Claude Code、Codex 代理、本地免密网关都用它）。
+# 真机踩过：密钥只 export 了 ANTHROPIC_AUTH_TOKEN，旧实现只认 *_API_KEY，
+# 于是判「未配置模型协议」——模型其实一路跑得好好的（红警告误报）。
+_ANTHROPIC_KEY_ENVS = ("ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN")
+_OPENAI_KEY_ENVS = ("OPENAI_API_KEY", "OPENAI_AUTH_TOKEN")
+_ALL_KEY_ENVS = _ANTHROPIC_KEY_ENVS + _OPENAI_KEY_ENVS
+
+
+def _pick_key(env: dict[str, str], names: tuple[str, ...]) -> str | None:
+    """按优先级取第一个有值的凭据变量名；空值不当「配了」。"""
+    for n in names:
+        if env.get(n):
+            return n
+    return None
+
+
+def load_env() -> dict[str, str]:
+    """合并 .env：项目 .env（cwd）优先 > ~/.openterminal/.env > 系统环境变量。
+
+    「当前项目 .env 优先级最高」（用户约定）：同名键项目覆盖家目录、家目录
+    覆盖系统环境。只读不动 os.environ——副作用留给调用方决定。
+    """
+    # 三层都要看：系统环境变量 < ~/.openterminal/.env < 项目 .env。
+    # 旧实现只读两份 .env 文件、漏了系统环境变量——用户把密钥 export 在
+    # shell 里时，模型明明跑得好好的却报「未配置模型协议」（真机红警告误报）
+    merged: dict[str, str] = {k: v for k, v in os.environ.items() if v}
+    home_env = app_dir() / ".env"
+    for k, v in _parse_env_file(home_env).items():
+        merged[k] = v
+    project_env = Path.cwd() / ".env"
+    for k, v in _parse_env_file(project_env).items():
+        merged[k] = v
+    return merged
+
+
+def model_from_env(env: dict[str, str]) -> tuple[dict, list[str]]:
+    """按 ANTHROPIC_*/OPENAI_* 二选一定协议。返回 (model 字段覆盖, 错误列表)。
+
+    - 两套都配 → 报错（只能配一个）；都没配 → 报错（红色警告卡素材）；
+    - 配了哪套走哪套协议：base_url + 凭据成对才算「配了」，凭据认
+      *_API_KEY 与 *_AUTH_TOKEN 两种标准名。
+    """
+    ant_url = env.get("ANTHROPIC_BASE_URL") or ""
+    oai_url = env.get("OPENAI_BASE_URL") or ""
+    ant_key_env = _pick_key(env, _ANTHROPIC_KEY_ENVS)
+    oai_key_env = _pick_key(env, _OPENAI_KEY_ENVS)
+    ant = bool(ant_url) and bool(ant_key_env)
+    oai = bool(oai_url) and bool(oai_key_env)
+    if ant and oai:
+        return {}, ["模型协议冲突：ANTHROPIC_* 与 OPENAI_* 同时配置，只能配一个"]
+    if ant:
+        return {"provider": "anthropic",
+                "base_url": ant_url,
+                "api_key": env[ant_key_env],
+                "model": env.get("ANTHROPIC_MODEL") or env.get("MODEL_ID", "")}, []
+    if oai:
+        return {"provider": "openai",
+                "base_url": oai_url,
+                "api_key": env[oai_key_env],
+                "model": env.get("OPENAI_MODEL") or env.get("MODEL_ID", "")}, []
+    return {}, ["未配置模型协议：请在项目 .env 或 ~/.openterminal/.env 配置 "
+                "ANTHROPIC_BASE_URL+ANTHROPIC_API_KEY 或 "
+                "OPENAI_BASE_URL+OPENAI_API_KEY"]
+
+
+_DEFAULT_MODELS = [
+    "claude-sonnet-4-6", "claude-opus-4-6", "claude-haiku-4-5",
+]
+
+# provider = "openai"（OpenAI 兼容协议）时的缺省值：模型、下拉可选列表与
+# anthropic 各一套；config.toml [model] 显式写了的字段一律优先
+_DEFAULT_MODEL_OPENAI = "gpt-5"
+_DEFAULT_MODELS_OPENAI = [
+    "gpt-5", "gpt-5-mini", "o4-mini",
+]
+
+
+def _endpoint_reachable(base_url: str, timeout: float = 0.5) -> bool:
+    """生效 base_url 连不连得上：任何 HTTP 响应都算通（404 也说明服务在）。
+
+    这是「能跑就不挂红警告」的最终判据——免密网关、异形鉴权（AUTH_TOKEN、
+    网关内定 token）一并覆盖，不用猜用户把密钥写在哪。只发不带凭据的 GET。
+    """
+    if not base_url:
+        return False
+    try:
+        with urllib.request.urlopen(base_url, timeout=timeout):
+            return True
+    except urllib.error.HTTPError:
+        return True          # 服务应答了，只是路径不对——端点是活的
+    except Exception:
+        return False         # 连接拒绝/超时/DNS 挂/URL 脏，都算跑不起来
+
+
+def _prune_model_errors(errors, env_model, model_cfg, environ):
+    r"""去掉「未配置模型协议」的**误报**：模型真能用时不该挂红警告卡。
+
+    判据是「跑不跑得起来」，不是「配置文件里有没有那两行」。真机踩过两回：
+    ① config.toml [model] 给了 base_url、密钥也在环境变量里，模型跑得好好的，
+       卡头却挂红「未配置模型协议」；
+    ② config.toml 压根没写 [model]，走内置缺省 base_url（本地网关免密），
+       模型一样跑得好好的——旧判据只认「config.toml 显式写了 base_url」，
+       把「用户没覆盖缺省值」误当成「用户没配置」。
+
+    故判据看**最终生效的** ModelConfig，且拿不准就探一下端点可达性。
+    二选一协议的**冲突**报错不在此列，照常报。
+    """
+    if env_model:
+        return list(errors)          # .env 配了协议：原样
+    key_env = str(model_cfg.api_key_env or "ANTHROPIC_API_KEY")
+    # 「能跑」两条路占一条即可：① 凭据到位（显式 api_key / 间接寻址的环境
+    # 变量 / *_AUTH_TOKEN 这类网关 token）；② 生效端点真连得上（本地网关可能
+    # 根本不要密钥，模型照样跑得好好的）
+    usable = (
+        bool(model_cfg.api_key)
+        or bool(environ.get(key_env))
+        or any(environ.get(n) for n in _ALL_KEY_ENVS)
+        or _endpoint_reachable(model_cfg.base_url)
+    )
+    if not usable:
+        return list(errors)
+    out = []
+    for e in errors:
+        if "未配置模型协议" in e:
+            continue
+        out.append(e)
+    return out
+
+
+@dataclass
+class ModelConfig:
+    provider: str = "anthropic"  # anthropic | openai（OpenAI 兼容协议）
+    base_url: str = "http://127.0.0.1:15721"
+    model: str = "claude-sonnet-4-6"
+    api_key_env: str = "ANTHROPIC_API_KEY"
+    # .env 直配的密钥（优先于 api_key_env 间接寻址）；None=走环境变量
+    api_key: str | None = None
+    # Web 状态栏模型下拉的可选模型（可在 config.toml [model] models 覆盖）
+    models: list[str] = field(default_factory=lambda: list(_DEFAULT_MODELS))
+
+
+@dataclass
+class ShellConfig:
+    timeout_default: int = 120
+    max_output_bytes: int = 102_400
+    max_tool_turns: int = 10
+
+
+@dataclass
+class PolicyConfig:
+    mode: str = "tiered"  # tiered | approve-all | deny-all
+    auto_extra: list[str] = field(default_factory=list)
+    approve_extra: list[str] = field(default_factory=list)
+    deny_extra: list[str] = field(default_factory=list)
+
+
+@dataclass
+class WebConfig:
+    host: str = "127.0.0.1"
+    port: int = 8080
+    token: str = ""
+
+
+@dataclass
+class TargetConfig:
+    name: str = "default"
+    mode: str = "local"  # local | ssh
+    host: str | None = None
+    user: str | None = None
+    port: int | None = None
+    commands: list[str] = field(default_factory=list)  # 连接后自动执行的命令集(原样行,空行/# 注释由 runner 跳过)
+
+
+@dataclass
+class Config:
+    model: ModelConfig = field(default_factory=ModelConfig)
+    shell: ShellConfig = field(default_factory=ShellConfig)
+    policy: PolicyConfig = field(default_factory=PolicyConfig)
+    web: WebConfig = field(default_factory=WebConfig)
+    targets: dict[str, TargetConfig] = field(
+        default_factory=lambda: {"default": TargetConfig()}
+    )
+    # 启动期配置错误（协议二选一冲突/都缺）：Web 端出红色警告卡展示
+    errors: list[str] = field(default_factory=list)
+
+    @classmethod
+    def load(cls, path: Path | None = None) -> "Config":
+        path = path or (app_dir() / "config.toml")
+        data: dict = {}
+        if path.exists():
+            data = tomllib.loads(path.read_text(encoding="utf-8"))
+
+        m, s, p = data.get("model", {}), data.get("shell", {}), data.get("policy", {})
+        w = data.get("web", {})
+        # 模型协议以 .env 为准（项目 .env > ~/.openterminal/.env > 系统环境）；
+        # config.toml [model] 只兜底模型名/下拉列表，credentials 不再从它取
+        env = load_env()
+        env_model, env_errors = model_from_env(env)
+        for k, v in env.items():
+            if k in _ALL_KEY_ENVS and v:
+                os.environ.setdefault(k, v)   # api_key_env 间接寻址要用
+        # 协议 provider：anthropic（缺省）| openai（OpenAI 兼容协议）。脏值容错：
+        # 未知值回落 anthropic，与 port 写坏只丢字段同一哲学——配置手误不
+        # 打挂启动。provider 决定 base_url / model / api_key_env / models 的
+        # 缺省套（openai 不再继承 anthropic 网关地址），显式字段一律优先。
+        provider = str(m.get("provider", "anthropic")).strip().lower()
+        if provider not in ("anthropic", "openai"):
+            provider = "anthropic"
+        openai = provider == "openai"
+        targets: dict[str, TargetConfig] = {
+            "default": TargetConfig(
+                mode=data.get("target", {}).get("default", {}).get("mode", "local")
+            )
+        }
+        for name, t in data.get("target", {}).items():
+            if name == "default":
+                continue
+            # 脏值容错：port 写坏（如 "22abc"）只丢该字段，commands 允许
+            # TOML 数组或字符串——单个目标的手误不打挂整个启动
+            try:
+                port = int(t["port"]) if t.get("port") is not None else None
+            except (TypeError, ValueError):
+                port = None
+            raw_cmds = t.get("commands")
+            if isinstance(raw_cmds, list):
+                commands = [str(c) for c in raw_cmds]
+            elif raw_cmds:
+                commands = str(raw_cmds).splitlines()
+            else:
+                commands = []
+            targets[name] = TargetConfig(
+                name=name,
+                mode=t.get("mode", "ssh"),
+                host=t.get("host"),
+                user=t.get("user"),
+                port=port,
+                commands=commands,
+            )
+        model = ModelConfig(
+            provider=env_model.get("provider", provider),
+            base_url=env_model.get("base_url") or m.get(
+                "base_url", "" if openai else ModelConfig.base_url),
+            model=env_model.get("model") or m.get(
+                "model", _DEFAULT_MODEL_OPENAI if openai else ModelConfig.model),
+            api_key_env=m.get(
+                "api_key_env",
+                ("OPENAI_API_KEY" if env_model.get("provider") == "openai"
+                 or openai else ModelConfig.api_key_env)),
+            models=list(m.get(
+                "models",
+                _DEFAULT_MODELS_OPENAI if openai else _DEFAULT_MODELS)),
+            api_key=env_model.get("api_key"),
+        )
+        # 降噪必须看**生效的** model，故先构造好再判（旧实现拿 config.toml
+        # 的原始 [model] dict 猜，内置缺省 base_url 于是永远算「没配」）
+        return cls(
+            model=model,
+            shell=ShellConfig(
+                timeout_default=int(s.get("timeout_default", 120)),
+                max_output_bytes=int(s.get("max_output_bytes", 102_400)),
+                max_tool_turns=int(s.get("max_tool_turns", 10)),
+            ),
+            policy=PolicyConfig(
+                mode=p.get("mode", "tiered"),
+                auto_extra=list(p.get("auto_extra", [])),
+                approve_extra=list(p.get("approve_extra", [])),
+                deny_extra=list(p.get("deny_extra", [])),
+            ),
+            web=WebConfig(
+                host=w.get("host", WebConfig.host),
+                port=int(w.get("port", WebConfig.port)),
+                token=w.get("token", WebConfig.token),
+            ),
+            targets=targets,
+            errors=_prune_model_errors(env_errors, env_model, model, os.environ),
+        )

openterminal/connections/__init__.py

@@ -0,0 +1,20 @@
+"""connections 域（阶段二 Task 11 重组）。
+
+models.py——SSH config 解析、目标列表与记住的连接（会话工厂）；
+db.py——记住的连接 SQLite 库；secrets.py——系统凭据库（keyring）封装。
+本 __init__ 再导出旧 ``connections`` 模块全部公开名，旧 import 路径
+（``from openterminal.connections import ...``）不因拆包而变。
+"""
+
+from ..config import TargetConfig  # noqa: F401 —— 旧模块命名空间原有
+from .db import RenameConflictError  # noqa: F401 —— 旧模块统一再导出
+from .models import (  # noqa: F401
+    PW_STORE_FAIL_HINT, SshTarget, TargetList, build_target_list,
+    cred_alias_eq, credential_referenced, delete_saved_target,
+    display_name, find_saved_target, list_ssh_hosts, load_saved_targets,
+    open_session, parse_ssh_config, parse_user_at_host, rename_saved_target,
+    save_saved_targets, saved_targets_path, upsert_saved_target,
+)
+from .secrets import (  # noqa: F401
+    delete_password, load_password, load_password_alias, store_password,
+)

openterminal/connections/db.py

@@ -0,0 +1,240 @@
+"""记住的连接存储：SQLite（~/.openterminal/connections.db）。
+
+只存元数据（主机名 / IP / 端口 / 用户名 / 命令集）；密码始终走系统
+凭据库（见 connections/secrets），不落库。首次访问自动从旧 connections.toml
+一次性迁移，迁移后旧文件改名 connections.toml.migrated 留档。
+
+跳板机已整体下线：旧库的 jumps 表在 connect() 时做一次收尾迁移——
+逐行清系统凭据库里遗留的跳板机密码后 DROP TABLE；saved.jump 死列
+尝试 DROP COLUMN（SQLite < 3.35 无此语法时留作墓碑列，SQL 不再引用）。
+
+本模块只操作 dict 行（不 import connections.py，避免循环依赖）；
+TargetConfig 的转换在 connections.py 完成。
+"""
+
+from __future__ import annotations
+
+import sqlite3
+from pathlib import Path
+
+_SCHEMA = """
+CREATE TABLE IF NOT EXISTS saved(
+  id   INTEGER PRIMARY KEY AUTOINCREMENT,
+  name TEXT NOT NULL UNIQUE,
+  host TEXT NOT NULL,
+  port INTEGER,
+  user TEXT,
+  commands TEXT
+);
+"""
+
+
+class RenameConflictError(Exception):
+    """编辑连接时新名字撞上另一条既有条目（拒绝写入，数据不动）。"""
+
+    def __init__(self, name: str) -> None:
+        self.name = name
+        super().__init__(name)
+
+
+def _as_port(value) -> int | None:
+    try:
+        return int(value) if value is not None else None
+    except (TypeError, ValueError):
+        return None  # 脏值不打挂迁移/加载
+
+
+def db_path() -> Path:
+    """数据库位置（跟随 OPENTERMINAL_HOME，用户主目录，不在 git 仓库内）。"""
+    from ..config import app_dir
+
+    return app_dir() / "connections.db"
+
+
+def connect(path: Path | None = None) -> sqlite3.Connection:
+    """打开（必要时创建）数据库并确保 schema + 旧库/旧 TOML 迁移已完成。"""
+    path = path or db_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(str(path))
+    conn.row_factory = sqlite3.Row
+    conn.executescript(_SCHEMA)
+    # 旧库升级:saved 补 commands 列(命令集文本;连接后自动执行)
+    cols = {r[1] for r in conn.execute("PRAGMA table_info(saved)")}
+    if "commands" not in cols:
+        conn.execute("ALTER TABLE saved ADD COLUMN commands TEXT")
+    _retire_jumps(conn)
+    conn.commit()
+    _migrate_toml(conn, path)
+    return conn
+
+
+def _sweep_orphan_credentials(conn: sqlite3.Connection,
+                              rows: list[tuple[str, str | None, int | None]]) -> None:
+    """清理已下线跳板机的遗留凭据（尽力而为）。
+
+    saved 表里还有同址（host/user/port）直连条目的不动——keyring 键是
+    display_name 三元组，堡垒机常被同时登记为直连主机，无条件删会把
+    直连记住的密码一起误删（headless 场景直接 exit 68）。
+    """
+    for host, user, port in rows:
+        if not host:
+            continue
+        shared = conn.execute(
+            "SELECT 1 FROM saved WHERE host=? AND user IS ? AND port IS ?",
+            (host, user, port)).fetchone()
+        if shared:
+            continue
+        try:
+            from .secrets import delete_password
+
+            delete_password(host, user, port)
+        except Exception:  # noqa: BLE001 - 凭据库不可用不阻断下线迁移
+            pass
+
+
+def _retire_jumps(conn: sqlite3.Connection) -> None:
+    """跳板机下线收尾（幂等）：清遗留凭据 → DROP jumps 表 → 删 saved.jump 列。
+
+    凭据清理尽力而为（凭据库不可用时跳过该行的删除）；表/列删除失败
+    （SQLite 过旧）时留作墓碑，SQL 层已不引用 jump，不影响任何读写。
+    """
+    tables = {r[0] for r in conn.execute(
+        "SELECT name FROM sqlite_master WHERE type='table'")}
+    if "jumps" in tables:
+        rows = [(r["host"], r["user"], r["port"]) for r in conn.execute(
+            "SELECT name, host, port, user FROM jumps ORDER BY id")]
+        # IF EXISTS：两个进程（ot web + ot CLI）同时首跑迁移时，
+        # 后到的 DROP 不再抛 no such table 炸掉调用方
+        conn.execute("DROP TABLE IF EXISTS jumps")
+        _sweep_orphan_credentials(conn, rows)
+    try:
+        conn.execute("ALTER TABLE saved DROP COLUMN jump")
+    except sqlite3.OperationalError:
+        pass    # SQLite < 3.35：死列留档，SQL 不再引用
+
+
+def _migrate_toml(conn: sqlite3.Connection, db_file: Path) -> None:
+    """旧 connections.toml 一次性迁移：仅当库为空且旧文件存在时导入。
+
+    旧文件里的 [[jumps]] 与 saved.jump 一并忽略（跳板机已下线），但
+    jumps 对应的遗留 keyring 凭据顺手清掉（同址直连条目仍在的不动）。"""
+    toml_file = db_file.with_name("connections.toml")
+    if not toml_file.exists():
+        return
+    import tomllib
+
+    try:
+        data = tomllib.loads(toml_file.read_text(encoding="utf-8"))
+    except Exception:  # noqa: BLE001 - 旧文件损坏只跳过迁移，不打挂启动
+        return
+    jump_rows = [(j.get("host") or "", j.get("user"), _as_port(j.get("port")))
+                 for j in data.get("jumps", [])]
+    if conn.execute("SELECT COUNT(*) FROM saved").fetchone()[0]:
+        # 库里已有数据：不重复导入，也不动旧文件；仅做凭据卫生
+        _sweep_orphan_credentials(conn, jump_rows)
+        return
+    for t in data.get("saved", []):
+        host = t.get("host") or t.get("name", "")
+        if not host:
+            continue
+        upsert_saved(conn, {
+            "name": t.get("name") or host, "host": host,
+            "port": _as_port(t.get("port")),
+            "user": t.get("user"),
+        })
+    conn.commit()
+    _sweep_orphan_credentials(conn, jump_rows)
+    try:
+        toml_file.replace(db_file.with_name("connections.toml.migrated"))
+    except OSError:
+        pass  # 改名失败（占用等）不影响数据：库非空后不会重复迁移
+
+
+def _row_to_dict(row: sqlite3.Row) -> dict:
+    return {k: row[k] for k in row.keys()}
+
+
+# --- saved 表 ---
+
+def fetch_saved(conn: sqlite3.Connection) -> list[dict]:
+    rows = conn.execute(
+        "SELECT name, host, port, user, commands FROM saved ORDER BY id"
+    ).fetchall()
+    return [_row_to_dict(r) for r in rows]
+
+
+def replace_saved(conn: sqlite3.Connection, rows: list[dict]) -> None:
+    """整表重写（保持既有 save_saved_targets 语义与插入顺序）。"""
+    conn.execute("DELETE FROM saved")
+    for r in rows:
+        conn.execute(
+            "INSERT INTO saved(name, host, port, user, commands) "
+            "VALUES(?,?,?,?,?)",
+            (r.get("name") or r.get("host", ""), r.get("host", ""),
+             r.get("port"), r.get("user"), r.get("commands")))
+    conn.commit()
+
+
+def upsert_saved(conn: sqlite3.Connection, row: dict) -> None:
+    """按 name 插入或更新（保留原 id 以维持列表顺序）。
+
+    commands 传 None 保留旧值（不带该字段的旧调用方/旧客户端兼容），
+    传空串显式清空——COALESCE 只兜 None，不兜空串。
+    """
+    conn.execute(
+        "INSERT INTO saved(name, host, port, user, commands) "
+        "VALUES(?,?,?,?,?) "
+        "ON CONFLICT(name) DO UPDATE SET host=excluded.host, port=excluded.port, "
+        "user=excluded.user, "
+        "commands=COALESCE(excluded.commands, saved.commands)",
+        (row.get("name") or row.get("host", ""), row.get("host", ""),
+         row.get("port"), row.get("user"), row.get("commands")))
+    conn.commit()
+
+
+def delete_saved(conn: sqlite3.Connection, name: str) -> dict | None:
+    """删除并返回被删行（供调用方清理凭据库）；不存在返回 None。"""
+    row = conn.execute(
+        "SELECT name, host, port, user, commands FROM saved WHERE name=?",
+        (name,)).fetchone()
+    if row is None:
+        return None
+    conn.execute("DELETE FROM saved WHERE name=?", (name,))
+    conn.commit()
+    return _row_to_dict(row)
+
+
+def rename_saved(conn: sqlite3.Connection, old: str, row: dict) -> dict | None:
+    """编辑连接：删旧行、插新行（name 可能改），单事务；返回被删的旧行。
+
+    - 旧行不存在 → 返回 None，**不写入任何行**（不再凭空建条目）；
+    - 新名字撞上另一条既有条目 → 抛 RenameConflictError，库不动
+      （不再静默合并覆盖别人的条目）；
+    - commands 传 None 时继承旧行值——这里是先删后插，upsert 的
+      COALESCE 兜不住（没有冲突路径可走），必须显式接管；
+    - DELETE+INSERT 包在同一事务里，中途失败回滚，不留半截状态。
+    """
+    r = conn.execute(
+        "SELECT name, host, port, user, commands FROM saved WHERE name=?",
+        (old,)).fetchone()
+    if r is None:
+        return None
+    deleted = _row_to_dict(r)
+    new_name = row.get("name") or row.get("host", "")
+    if new_name != old and conn.execute(
+            "SELECT 1 FROM saved WHERE name=?", (new_name,)).fetchone():
+        raise RenameConflictError(new_name)
+    if row.get("commands") is None:
+        row = {**row, "commands": deleted.get("commands")}
+    try:
+        conn.execute("DELETE FROM saved WHERE name=?", (old,))
+        conn.execute(
+            "INSERT INTO saved(name, host, port, user, commands) "
+            "VALUES(?,?,?,?,?)",
+            (new_name, row.get("host", ""), row.get("port"),
+             row.get("user"), row.get("commands")))
+        conn.commit()
+    except BaseException:
+        conn.rollback()
+        raise
+    return deleted