tinet-agent-cli 0.1.0.dev36__py3-none-any.whl

taco/core/profile_manager.py

@@ -0,0 +1,217 @@
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import urlsplit
+
+from taco.core.access_token_manager import credential_fingerprint
+from taco.core.config_store import ConfigStore, TacoConfig
+from taco.core.errors import TacoError
+from taco.core.output import mask_token
+from taco.core.profile_resolver import ProfileResolver, ResolvedProfile
+
+
+class ProfileManager:
+    def __init__(
+        self,
+        store: ConfigStore | None = None,
+        *,
+        resolver: ProfileResolver | None = None,
+    ) -> None:
+        self.store = store or ConfigStore()
+        self.resolver = resolver or ProfileResolver(self.store)
+
+    def set_profile(
+        self,
+        *,
+        name: str,
+        endpoint: str,
+        access_key_id: str,
+        access_key_secret: str,
+    ) -> dict[str, Any]:
+        normalized_name = name.strip()
+        normalized_endpoint = endpoint.strip().rstrip("/")
+        normalized_access_key_id = access_key_id.strip()
+        if not normalized_name:
+            raise TacoError(code="PROFILE_NAME_REQUIRED", message="profile name 不能为空。", exit_code=2)
+        parsed = urlsplit(normalized_endpoint)
+        if parsed.scheme not in {"http", "https"} or not parsed.netloc:
+            raise TacoError(code="PROFILE_ENDPOINT_INVALID", message="endpoint 不是有效 HTTP(S) 地址。", exit_code=2)
+        if not normalized_access_key_id or not access_key_secret:
+            raise TacoError(code="ACCESS_KEY_PROFILE_INVALID", message="AccessKey profile 配置不完整。", exit_code=2)
+        profile_data = {
+            "endpoint": normalized_endpoint,
+            "access_key_id": normalized_access_key_id,
+            "access_key_secret": access_key_secret,
+        }
+
+        def mutate(config: TacoConfig) -> None:
+            if config.profiles.get(normalized_name) != profile_data:
+                config.auth_tokens.pop(normalized_name, None)
+            config.profiles[normalized_name] = profile_data
+            config.current_profile = normalized_name
+
+        self.store.update(mutate)
+        return {
+            "profile": normalized_name,
+            "current": True,
+            "endpoint": normalized_endpoint,
+            "access_key_id": normalized_access_key_id,
+            "access_key_secret": "********",
+            "has_access_token": False,
+        }
+
+    def list_profiles(self) -> list[dict[str, Any]]:
+        config = self.store.load()
+        entries: list[tuple[str, str, dict[str, Any], bool]] = []
+        zenava = self.resolver.load_zenava()
+        if zenava is not None:
+            entries.extend(
+                (
+                    name,
+                    "zenava",
+                    value,
+                    name == zenava["current_profile"],
+                )
+                for name, value in zenava["profiles"].items()
+            )
+        entries.extend(
+            (
+                name,
+                "taco",
+                value,
+                name == config.current_profile,
+            )
+            for name, value in config.profiles.items()
+        )
+
+        name_counts: dict[str, int] = {}
+        for name, _, _, _ in entries:
+            name_counts[name] = name_counts.get(name, 0) + 1
+
+        profiles: list[dict[str, Any]] = []
+        for name, source, value, current in entries:
+            token = _string(value.get("token") or value.get("access_token"))
+            token_updated_at = _string(
+                value.get("token_updated_at") or value.get("access_token_updated_at")
+            )
+            cached = config.auth_tokens.get(name, {})
+            if _cache_belongs_to_profile(
+                name,
+                source,
+                value,
+                cached,
+                name_is_unique=name_counts[name] == 1,
+            ):
+                token = _string(cached.get("access_token")) or token
+                token_updated_at = _string(cached.get("updated_at")) or token_updated_at
+            profiles.append(
+                self._public_profile(
+                    name,
+                    value,
+                    source=source,
+                    current=current,
+                    token=token,
+                    token_updated_at=token_updated_at,
+                )
+            )
+
+        source_order = {"zenava": 0, "taco": 1}
+        return sorted(
+            profiles,
+            key=lambda item: (
+                not item["current"],
+                source_order[item["source"]],
+                item["key"],
+            ),
+        )
+
+    def use(self, name: str) -> dict[str, str]:
+        def mutate(config: TacoConfig) -> None:
+            if name not in config.profiles:
+                raise _profile_not_found_error(name)
+            config.current_profile = name
+
+        self.store.update(mutate)
+        return {"current_profile": name}
+
+    def delete(self, name: str) -> dict[str, str | None]:
+        current: list[str | None] = []
+
+        def mutate(config: TacoConfig) -> None:
+            if name not in config.profiles:
+                raise _profile_not_found_error(name)
+            if name == config.current_profile:
+                raise TacoError(
+                    code="PROFILE_DELETE_CURRENT_FORBIDDEN",
+                    message=f"不能删除当前 profile `{name}`。",
+                    exit_code=2,
+                    hint="请先执行 taco profile use 切换到其他 profile。",
+                )
+            del config.profiles[name]
+            config.auth_tokens.pop(name, None)
+            current.append(config.current_profile)
+
+        self.store.update(mutate)
+        return {"deleted": name, "current_profile": current[0]}
+
+    @staticmethod
+    def _public_profile(
+        name: str,
+        value: dict[str, Any],
+        *,
+        source: str = "taco",
+        current: bool,
+        token: str = "",
+        token_updated_at: str = "",
+    ) -> dict[str, Any]:
+        return {
+            "key": name,
+            "source": source,
+            "current": current,
+            "endpoint": value.get("endpoint", ""),
+            "access_key_id": value.get("access_key_id", ""),
+            "access_key_secret": "********" if value.get("access_key_secret") else "",
+            "access_token": mask_token(token),
+            "access_token_updated_at": token_updated_at,
+        }
+
+
+def _profile_not_found_error(name: str) -> TacoError:
+    return TacoError(
+        code="PROFILE_NOT_FOUND",
+        message=f"profile `{name}` 不存在。",
+        exit_code=2,
+        hint="请执行 taco profile list 查看可用 profile。",
+    )
+
+
+def _string(value: Any) -> str:
+    return value if isinstance(value, str) else ""
+
+
+def _cache_belongs_to_profile(
+    name: str,
+    source: str,
+    value: dict[str, Any],
+    cached: dict[str, Any],
+    *,
+    name_is_unique: bool,
+) -> bool:
+    if not _string(cached.get("access_token")):
+        return False
+    fingerprint = _string(cached.get("credential_fingerprint"))
+    if not fingerprint:
+        return name_is_unique
+    endpoint = _string(value.get("endpoint")).strip().rstrip("/")
+    access_key_id = _string(value.get("access_key_id")).strip()
+    access_key_secret = _string(value.get("access_key_secret"))
+    if not endpoint or not access_key_id or not access_key_secret:
+        return False
+    profile = ResolvedProfile(
+        name=name,
+        source="zenava" if source == "zenava" else "taco",
+        endpoint=endpoint,
+        access_key_id=access_key_id,
+        access_key_secret=access_key_secret,
+    )
+    return fingerprint == credential_fingerprint(profile)

taco/core/profile_resolver.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from json import JSONDecodeError
+from pathlib import Path
+from typing import Any, Literal
+from urllib.parse import urlsplit
+
+from taco.core.config_store import ConfigStore
+from taco.core.errors import TacoError
+
+
+@dataclass(frozen=True, slots=True)
+class ResolvedProfile:
+    name: str
+    source: Literal["zenava", "taco"]
+    endpoint: str
+    access_key_id: str
+    access_key_secret: str
+    legacy_access_token: str | None = None
+
+
+class ProfileResolver:
+    def __init__(
+        self,
+        store: ConfigStore | None = None,
+        *,
+        zenava_path: Path | None = None,
+    ) -> None:
+        self.store = store or ConfigStore()
+        self.zenava_path = zenava_path or Path.home() / ".zenava" / "profile.json"
+
+    def resolve(self, name: str | None = None) -> ResolvedProfile:
+        if name is not None:
+            zenava = self._load_zenava()
+            if zenava is not None and name in zenava["profiles"]:
+                return _resolve_profile(
+                    name,
+                    zenava["profiles"][name],
+                    source="zenava",
+                )
+        else:
+            try:
+                zenava = self._load_zenava()
+                zenava_name = zenava["current_profile"] if zenava else None
+                if zenava_name is not None and zenava_name in zenava["profiles"]:
+                    try:
+                        return _resolve_profile(
+                            zenava_name,
+                            zenava["profiles"][zenava_name],
+                            source="zenava",
+                        )
+                    except TacoError:
+                        pass
+            except TacoError:
+                pass
+
+        taco = self.store.load()
+        taco_name = name if name is not None else taco.current_profile
+        if taco_name is None or taco_name not in taco.profiles:
+            raise TacoError(
+                code="PROFILE_NOT_FOUND",
+                message=f"profile `{taco_name or ''}` 不存在。",
+                exit_code=2,
+                hint="请执行 taco profile set 创建配置，或使用 --profile 选择已有配置。",
+            )
+        return _resolve_profile(taco_name, taco.profiles[taco_name], source="taco")
+
+    def load_zenava(self) -> dict[str, Any] | None:
+        """读取 Zenava profile 集合，供只读发现命令使用。"""
+        return self._load_zenava()
+
+    def known_names(self) -> set[str]:
+        names = set(self.store.load().profiles)
+        zenava = self._load_zenava()
+        if zenava is not None:
+            names.update(zenava["profiles"])
+        return names
+
+    def _load_zenava(self) -> dict[str, Any] | None:
+        if not self.zenava_path.is_file():
+            return None
+        try:
+            payload = json.loads(self.zenava_path.read_text(encoding="utf-8"))
+        except (OSError, JSONDecodeError) as error:
+            raise _zenava_invalid_error() from error
+        if not isinstance(payload, dict):
+            raise _zenava_invalid_error()
+        current_profile = payload.get("currentProfile")
+        profiles = payload.get("profiles", {})
+        if (
+            (current_profile is not None and not isinstance(current_profile, str))
+            or not isinstance(profiles, dict)
+            or any(
+                not isinstance(profile_name, str) or not isinstance(value, dict)
+                for profile_name, value in profiles.items()
+            )
+        ):
+            raise _zenava_invalid_error()
+        return {"current_profile": current_profile, "profiles": profiles}
+
+
+def _resolve_profile(
+    name: str,
+    value: dict[str, Any],
+    *,
+    source: Literal["zenava", "taco"],
+) -> ResolvedProfile:
+    required = ("endpoint", "access_key_id", "access_key_secret")
+    missing = [
+        field
+        for field in required
+        if not isinstance(value.get(field), str) or not str(value[field]).strip()
+    ]
+    if missing:
+        raise TacoError(
+            code="ACCESS_KEY_PROFILE_INVALID",
+            message=f"{source} profile `{name}` 缺少字段：{', '.join(missing)}。",
+            exit_code=2,
+        )
+    endpoint = str(value["endpoint"]).strip().rstrip("/")
+    parsed = urlsplit(endpoint)
+    if parsed.scheme not in {"http", "https"} or not parsed.netloc:
+        raise TacoError(
+            code="ACCESS_KEY_PROFILE_INVALID",
+            message=f"{source} profile `{name}` 的 endpoint 不是有效 HTTP(S) 地址。",
+            exit_code=2,
+        )
+    legacy_access_token = value.get("access_token") if source == "taco" else None
+    return ResolvedProfile(
+        name=name,
+        source=source,
+        endpoint=endpoint,
+        access_key_id=str(value["access_key_id"]).strip(),
+        access_key_secret=str(value["access_key_secret"]),
+        legacy_access_token=(
+            legacy_access_token
+            if isinstance(legacy_access_token, str) and legacy_access_token
+            else None
+        ),
+    )
+
+
+def _zenava_invalid_error() -> TacoError:
+    return TacoError(
+        code="ZENAVA_CONFIG_INVALID",
+        message="Zenava profile 配置格式不合法。",
+        exit_code=2,
+        hint="请检查 ~/.zenava/profile.json。",
+    )

taco/core/secure_file.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import errno
+import os
+import stat
+from pathlib import Path
+
+
+class SecureFileReadError(Exception):
+    def __init__(self, reason: str) -> None:
+        self.reason = reason
+        super().__init__(reason)
+
+
+def read_regular_file(path: Path | str, *, max_bytes: int) -> bytes:
+    """Read a bounded regular file without following path replacement races."""
+    source = Path(path)
+    try:
+        path_stat = os.lstat(source)
+    except OSError as error:
+        raise SecureFileReadError("unreadable") from error
+    if stat.S_ISLNK(path_stat.st_mode):
+        raise SecureFileReadError("symlink")
+    if not stat.S_ISREG(path_stat.st_mode):
+        raise SecureFileReadError("not_regular")
+
+    flags = os.O_RDONLY
+    flags |= getattr(os, "O_CLOEXEC", 0)
+    flags |= getattr(os, "O_NONBLOCK", 0)
+    flags |= getattr(os, "O_NOFOLLOW", 0)
+    try:
+        descriptor = os.open(source, flags)
+    except OSError as error:
+        if error.errno == errno.ELOOP:
+            reason = "symlink"
+        elif error.errno == errno.ENOENT:
+            reason = "changed"
+        else:
+            reason = "unreadable"
+        raise SecureFileReadError(reason) from error
+
+    try:
+        opened_stat = os.fstat(descriptor)
+        if not stat.S_ISREG(opened_stat.st_mode):
+            raise SecureFileReadError("not_regular")
+        if (path_stat.st_dev, path_stat.st_ino) != (
+            opened_stat.st_dev,
+            opened_stat.st_ino,
+        ):
+            raise SecureFileReadError("changed")
+        if opened_stat.st_size > max_bytes:
+            raise SecureFileReadError("too_large")
+
+        content = bytearray()
+        while len(content) <= max_bytes:
+            chunk = os.read(
+                descriptor,
+                min(64 * 1024, max_bytes + 1 - len(content)),
+            )
+            if not chunk:
+                break
+            content.extend(chunk)
+        if len(content) > max_bytes:
+            raise SecureFileReadError("too_large")
+        if os.fstat(descriptor).st_size > max_bytes:
+            raise SecureFileReadError("too_large")
+        return bytes(content)
+    except SecureFileReadError:
+        raise
+    except OSError as error:
+        raise SecureFileReadError("unreadable") from error
+    finally:
+        try:
+            os.close(descriptor)
+        except OSError:
+            pass