@qingflow-tech/qingflow-cli 1.1.43-beta.5 → 1.1.44-beta.1

package/src/qingflow_mcp/cloud_auth.py

@@ -26,6 +26,7 @@ AUTH_CONTEXT_KEY_PREFIX = "mcp:auth:context"
 AUTH_CONTEXT_LOCK_KEY_PREFIX = "mcp:auth:context:lock"
 AUTH_CONTEXT_NEGATIVE_KEY_PREFIX = "mcp:auth:context:negative"
 ACCESS_PLATFORM_KEY_PREFIX = "oauth2:access-platform:"
+ACCESS_CONTEXT_KEY_PREFIX = "auth:access-context:"
 
 
 @dataclass(slots=True)
@@ -108,12 +109,31 @@ class CloudAuthBroker:
         normalized_token = self._normalize_text(access_token)
         if normalized_token is None:
             return ""
+        access_context = self.resolve_access_context(normalized_token)
+        if access_context is not None:
+            source_code = self._normalize_text(access_context.get("source_code"))
+            if source_code is not None:
+                return source_code
         try:
             value = self.cache.get_text(f"{ACCESS_PLATFORM_KEY_PREFIX}{normalized_token}")
         except QingflowApiError:
             return ""
         return self._normalize_text(value) or ""
 
+    def resolve_access_context(self, access_token: str) -> JSONObject | None:
+        normalized_token = self._normalize_text(access_token)
+        if normalized_token is None:
+            return None
+        try:
+            value = self.cache.get_json(
+                f"{ACCESS_CONTEXT_KEY_PREFIX}{sha256(normalized_token.encode('utf-8')).hexdigest()}"
+            )
+        except QingflowApiError:
+            return None
+        if not isinstance(value, dict):
+            return None
+        return value
+
     @staticmethod
     def credential_hash(credential: str) -> str:
         return sha256(credential.encode("utf-8")).hexdigest()

package/src/qingflow_mcp/cloud_oauth_proxy.py

@@ -26,6 +26,7 @@ AUTHORIZATION_SERVER_METADATA_PATH = "/.well-known/oauth-authorization-server"
 OAUTH_ENDPOINT_PATHS = {
     "authorization_endpoint": "/oauth/authorize",
     "token_endpoint": "/oauth/token",
+    "revocation_endpoint": "/oauth/revoke",
     "registration_endpoint": "/oauth/register",
 }
 FORWARDED_REQUEST_HEADERS = {"accept", "content-type"}

package/src/qingflow_mcp/config.py

@@ -12,6 +12,7 @@ DEFAULT_USER_AGENT = "qingflow-mcp/1.0"
 DEFAULT_RECORD_LIST_TYPE = 8
 ATTACHMENT_QUESTION_TYPE = 13
 DEFAULT_BASE_URL = "https://qingflow.com/api"
+DEFAULT_CLI_OAUTH_RESOURCE_URL = "https://mcp.qingflow.com/mcp"
 DEFAULT_FEEDBACK_APP_KEY = "e0d017kju002"
 DEFAULT_FEEDBACK_QSOURCE_TOKEN = "mcp-feedback-7755d14748fc"
 DEFAULT_REPOSITORY_GIT_REMOTE_TEMPLATE = "git@hackers.oalite.com:{group}/{repo}.git"
@@ -165,6 +166,17 @@ def get_default_qf_version() -> str | None:
     return normalized or None
 
 
+def get_cli_oauth_resource_url() -> str:
+    """获取 CLI OAuth 受保护资源地址。"""
+    value = get_config_value(
+        "cli.oauth.resource_url",
+        env_var="QINGFLOW_MCP_OAUTH_RESOURCE_URL",
+        default=DEFAULT_CLI_OAUTH_RESOURCE_URL,
+    )
+    normalized = normalize_base_url(str(value or "").strip())
+    return normalized or DEFAULT_CLI_OAUTH_RESOURCE_URL
+
+
 def get_feedback_qsource_token() -> str | None:
     """获取反馈 q-source 被动入口 token"""
     value = get_config_value(

package/src/qingflow_mcp/oauth_profile_store.py

@@ -0,0 +1,264 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from contextlib import contextmanager
+from dataclasses import asdict, dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Iterator, Literal
+from uuid import uuid4
+
+from .config import get_mcp_home, normalize_base_url
+from .errors import QingflowApiError
+
+
+OAUTH_PROFILE_SCHEMA_VERSION = 1
+OAuthStateValue = Literal["oauth", "none"]
+
+
+def _utcnow() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def profile_storage_key(profile: str) -> str:
+    return hashlib.sha256(profile.encode("utf-8")).hexdigest()
+
+
+@dataclass(slots=True)
+class OAuthProfileState:
+    active_auth_type: OAuthStateValue
+    profile: str
+    base_url: str | None = None
+    qf_version: str | None = None
+    qf_version_source: str | None = None
+    uid: int | None = None
+    email: str | None = None
+    nick_name: str | None = None
+    selected_ws_id: int | None = None
+    selected_ws_name: str | None = None
+    persisted: bool = True
+    secret_storage: str | None = None
+    issuer: str | None = None
+    client_id: str | None = None
+    resource: str | None = None
+    source_code: str | None = None
+    access_expires_at: str | None = None
+    created_at: str = ""
+    updated_at: str = ""
+
+    @classmethod
+    def from_dict(cls, profile: str, value: object) -> "OAuthProfileState":
+        if not isinstance(value, dict):
+            raise _config_error(profile, "profile entry must be an object")
+        active_auth_type = value.get("active_auth_type")
+        if active_auth_type not in {"oauth", "none"}:
+            raise _config_error(profile, "active_auth_type must be 'oauth' or 'none'")
+        stored_profile = value.get("profile")
+        if stored_profile != profile:
+            raise _config_error(profile, "stored profile name does not match the requested profile")
+        secret_storage = _normalized_text(value.get("secret_storage"))
+        if active_auth_type == "oauth":
+            required_text = ("base_url", "issuer", "client_id", "resource", "source_code", "access_expires_at")
+            missing = [name for name in required_text if not _normalized_text(value.get(name))]
+            if secret_storage not in {"keyring", "file"}:
+                missing.append("secret_storage")
+            uid = _positive_int(value.get("uid"))
+            if uid is None:
+                missing.append("uid")
+            if missing:
+                raise _config_error(profile, "missing OAuth fields: " + ", ".join(missing))
+        created_at = _normalized_text(value.get("created_at")) or _utcnow()
+        updated_at = _normalized_text(value.get("updated_at")) or created_at
+        return cls(
+            active_auth_type=active_auth_type,
+            profile=profile,
+            base_url=_normalized_text(value.get("base_url")),
+            qf_version=_normalized_text(value.get("qf_version")),
+            qf_version_source=_normalized_text(value.get("qf_version_source")),
+            uid=_positive_int(value.get("uid")),
+            email=_normalized_text(value.get("email")),
+            nick_name=_normalized_text(value.get("nick_name")),
+            selected_ws_id=_positive_int(value.get("selected_ws_id")),
+            selected_ws_name=_normalized_text(value.get("selected_ws_name")),
+            persisted=bool(value.get("persisted", True)),
+            secret_storage=secret_storage,
+            issuer=_normalized_text(value.get("issuer")),
+            client_id=_normalized_text(value.get("client_id")),
+            resource=_normalized_text(value.get("resource")),
+            source_code=_normalized_text(value.get("source_code")),
+            access_expires_at=_normalized_text(value.get("access_expires_at")),
+            created_at=created_at,
+            updated_at=updated_at,
+        )
+
+    def to_dict(self) -> dict[str, object]:
+        return asdict(self)
+
+
+class OAuthProfileStore:
+    def __init__(self, base_dir: Path | None = None) -> None:
+        self.base_dir = Path(base_dir) if base_dir is not None else get_mcp_home()
+        self._profiles_dir = self.base_dir / "oauth-profiles"
+        self._locks_dir = self.base_dir / "locks"
+
+    def get(self, profile: str) -> OAuthProfileState | None:
+        path = self.profile_path(profile)
+        if not path.exists():
+            return None
+        try:
+            with path.open("r", encoding="utf-8") as handle:
+                payload = json.load(handle)
+        except (OSError, json.JSONDecodeError) as exc:
+            raise _config_error(profile, f"state file cannot be read: {exc}") from exc
+        if not isinstance(payload, dict) or payload.get("schema_version") != OAUTH_PROFILE_SCHEMA_VERSION:
+            raise _config_error(profile, "unsupported or missing schema_version")
+        profiles = payload.get("profiles")
+        if not isinstance(profiles, dict) or profile not in profiles:
+            raise _config_error(profile, "state file does not contain the requested profile")
+        return OAuthProfileState.from_dict(profile, profiles[profile])
+
+    def save(self, state: OAuthProfileState, *, locked: bool = False) -> None:
+        if locked:
+            self._save_locked(state)
+            return
+        with self.lock(state.profile):
+            self._save_locked(state)
+
+    def set_none(self, profile: str, *, locked: bool = False) -> OAuthProfileState:
+        now = _utcnow()
+        try:
+            previous = self.get(profile)
+        except QingflowApiError:
+            previous = None
+        state = OAuthProfileState(
+            active_auth_type="none",
+            profile=profile,
+            persisted=True,
+            created_at=previous.created_at if previous is not None else now,
+            updated_at=now,
+        )
+        self.save(state, locked=locked)
+        return state
+
+    def delete(self, profile: str, *, locked: bool = False) -> None:
+        if not locked:
+            with self.lock(profile):
+                self.delete(profile, locked=True)
+            return
+        try:
+            self.profile_path(profile).unlink()
+        except FileNotFoundError:
+            return
+        except OSError as exc:
+            raise _config_error(profile, f"state file cannot be removed: {exc}") from exc
+
+    @contextmanager
+    def lock(self, profile: str) -> Iterator[None]:
+        lock_path = self._locks_dir / f"{profile_storage_key(profile)}.oauth.lock"
+        with _FileLock(lock_path):
+            yield
+
+    def profile_path(self, profile: str) -> Path:
+        return self._profiles_dir / f"{profile_storage_key(profile)}.json"
+
+    def _save_locked(self, state: OAuthProfileState) -> None:
+        normalized_base_url = normalize_base_url(state.base_url) if state.base_url else None
+        if state.active_auth_type == "oauth" and not normalized_base_url:
+            raise _config_error(state.profile, "base_url is invalid")
+        state.base_url = normalized_base_url
+        state.updated_at = _utcnow()
+        if not state.created_at:
+            state.created_at = state.updated_at
+        payload = {
+            "schema_version": OAUTH_PROFILE_SCHEMA_VERSION,
+            "profiles": {state.profile: state.to_dict()},
+        }
+        _atomic_json_write(self.profile_path(state.profile), payload)
+
+
+class _FileLock:
+    def __init__(self, path: Path) -> None:
+        self.path = path
+        self._handle = None
+
+    def __enter__(self) -> "_FileLock":
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self._handle = self.path.open("a+b")
+        self._handle.seek(0, os.SEEK_END)
+        if self._handle.tell() == 0:
+            self._handle.write(b"0")
+            self._handle.flush()
+        self._handle.seek(0)
+        if os.name == "nt":
+            import msvcrt
+
+            msvcrt.locking(self._handle.fileno(), msvcrt.LK_LOCK, 1)
+        else:
+            import fcntl
+
+            fcntl.flock(self._handle.fileno(), fcntl.LOCK_EX)
+        return self
+
+    def __exit__(self, _exc_type, _exc, _traceback) -> None:
+        if self._handle is None:
+            return
+        try:
+            self._handle.seek(0)
+            if os.name == "nt":
+                import msvcrt
+
+                msvcrt.locking(self._handle.fileno(), msvcrt.LK_UNLCK, 1)
+            else:
+                import fcntl
+
+                fcntl.flock(self._handle.fileno(), fcntl.LOCK_UN)
+        finally:
+            self._handle.close()
+            self._handle = None
+
+
+def _atomic_json_write(path: Path, payload: object) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.parent / f".{path.name}.{os.getpid()}.{uuid4().hex}.tmp"
+    fd = os.open(temporary, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as handle:
+            json.dump(payload, handle, ensure_ascii=False, indent=2)
+            handle.flush()
+            os.fsync(handle.fileno())
+        os.replace(temporary, path)
+        try:
+            os.chmod(path, 0o600)
+        except OSError:
+            pass
+    finally:
+        try:
+            temporary.unlink()
+        except FileNotFoundError:
+            pass
+
+
+def _normalized_text(value: object) -> str | None:
+    if value is None:
+        return None
+    normalized = str(value).strip()
+    return normalized or None
+
+
+def _positive_int(value: object) -> int | None:
+    if value is None or isinstance(value, bool):
+        return None
+    try:
+        parsed = int(value)
+    except (TypeError, ValueError):
+        return None
+    return parsed if parsed > 0 else None
+
+
+def _config_error(profile: str, reason: str) -> QingflowApiError:
+    return QingflowApiError.config_error(
+        f"OAuth state for profile '{profile}' is invalid: {reason}.",
+        details={"reason": "oauth_state_invalid", "profile": profile},
+    )

package/src/qingflow_mcp/oauth_token_store.py

@@ -0,0 +1,210 @@
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+try:
+    import keyring
+except ImportError:
+    keyring = None
+
+from .errors import QingflowApiError
+from .json_types import KeyringBackend
+from .oauth_profile_store import OAuthProfileStore, _atomic_json_write, profile_storage_key
+from .session_store import KEYRING_SERVICE_NAME
+
+
+@dataclass(slots=True)
+class OAuthTokenBundle:
+    access_token: str
+    refresh_token: str
+    access_expires_at: str
+    generation: int
+
+    @classmethod
+    def from_json(cls, profile: str, value: object) -> "OAuthTokenBundle":
+        if not isinstance(value, dict):
+            raise _bundle_error(profile, "bundle must be an object")
+        access_token = _text(value.get("access_token"))
+        refresh_token = _text(value.get("refresh_token"))
+        access_expires_at = _text(value.get("access_expires_at"))
+        generation_value = value.get("generation")
+        if isinstance(generation_value, bool):
+            generation = -1
+        else:
+            try:
+                generation = int(generation_value)
+            except (TypeError, ValueError):
+                generation = -1
+        missing = []
+        if not access_token:
+            missing.append("access_token")
+        if not refresh_token:
+            missing.append("refresh_token")
+        if not access_expires_at:
+            missing.append("access_expires_at")
+        if generation < 0:
+            missing.append("generation")
+        if missing:
+            raise _bundle_error(profile, "missing or invalid fields: " + ", ".join(missing))
+        return cls(
+            access_token=access_token,
+            refresh_token=refresh_token,
+            access_expires_at=access_expires_at,
+            generation=generation,
+        )
+
+    def to_json(self) -> dict[str, object]:
+        return asdict(self)
+
+
+class OAuthTokenStore:
+    def __init__(
+        self,
+        profile_store: OAuthProfileStore,
+        *,
+        keyring_backend: KeyringBackend | None = None,
+    ) -> None:
+        self.profile_store = profile_store
+        self._keyring = keyring_backend if keyring_backend is not None else keyring
+        self._secrets_dir = profile_store.base_dir / "oauth-secrets"
+
+    def load(self, profile: str) -> OAuthTokenBundle | None:
+        state = self.profile_store.get(profile)
+        if state is not None and state.active_auth_type == "none":
+            return None
+        if state is not None and state.secret_storage == "file":
+            return self._load_file(profile)
+        if state is not None and state.secret_storage == "keyring":
+            keyring_value = self._get_keyring(profile)
+            return self._decode(profile, keyring_value, storage="keyring") if keyring_value is not None else None
+        keyring_value = self._get_keyring(profile)
+        if keyring_value is not None:
+            return self._decode(profile, keyring_value, storage="keyring")
+        return self._load_file(profile)
+
+    def _load_file(self, profile: str) -> OAuthTokenBundle | None:
+        path = self.secret_path(profile)
+        if not path.exists():
+            return None
+        try:
+            with path.open("r", encoding="utf-8") as handle:
+                payload = json.load(handle)
+        except (OSError, json.JSONDecodeError) as exc:
+            raise _bundle_error(profile, f"file bundle cannot be read: {exc}") from exc
+        return OAuthTokenBundle.from_json(profile, payload)
+
+    def save(
+        self,
+        profile: str,
+        bundle: OAuthTokenBundle,
+        *,
+        storage: str | None = None,
+        locked: bool = False,
+    ) -> str:
+        if not locked:
+            with self.profile_store.lock(profile):
+                state = self.profile_store.get(profile)
+                selected_storage = storage
+                if selected_storage is None and state is not None and state.active_auth_type == "oauth":
+                    selected_storage = state.secret_storage
+                saved_storage = self.save(profile, bundle, storage=selected_storage, locked=True)
+                if state is not None and state.active_auth_type == "oauth":
+                    state.secret_storage = saved_storage
+                    state.access_expires_at = bundle.access_expires_at
+                    self.profile_store.save(state, locked=True)
+                return saved_storage
+        if storage not in {None, "keyring", "file"}:
+            raise _bundle_error(profile, f"unsupported secret storage: {storage}")
+        encoded = json.dumps(bundle.to_json(), ensure_ascii=False, separators=(",", ":"))
+        if storage == "keyring":
+            if not self._set_keyring(profile, encoded):
+                raise _bundle_error(profile, "keyring write failed")
+            self._delete_file(profile)
+            return "keyring"
+        if storage == "file":
+            self._save_file(profile, bundle)
+            self._delete_keyring(profile)
+            return "file"
+        if self._set_keyring(profile, encoded):
+            self._delete_file(profile)
+            return "keyring"
+        self._save_file(profile, bundle)
+        self._delete_keyring(profile)
+        return "file"
+
+    def delete(self, profile: str, *, locked: bool = False) -> None:
+        if not locked:
+            with self.profile_store.lock(profile):
+                self.delete(profile, locked=True)
+            return
+        self._delete_keyring(profile)
+        self._delete_file(profile)
+
+    def secret_path(self, profile: str) -> Path:
+        return self._secrets_dir / f"{profile_storage_key(profile)}.json"
+
+    def _decode(self, profile: str, encoded: str, *, storage: str) -> OAuthTokenBundle:
+        try:
+            value = json.loads(encoded)
+        except json.JSONDecodeError as exc:
+            raise _bundle_error(profile, f"{storage} bundle is not valid JSON") from exc
+        return OAuthTokenBundle.from_json(profile, value)
+
+    def _key(self, profile: str) -> str:
+        return f"{profile}:oauth-token-set"
+
+    def _get_keyring(self, profile: str) -> str | None:
+        if self._keyring is None:
+            return None
+        try:
+            value = self._keyring.get_password(KEYRING_SERVICE_NAME, self._key(profile))
+        except Exception:
+            return None
+        return value if value else None
+
+    def _set_keyring(self, profile: str, value: str) -> bool:
+        if self._keyring is None:
+            return False
+        try:
+            self._keyring.set_password(KEYRING_SERVICE_NAME, self._key(profile), value)
+        except Exception:
+            return False
+        return True
+
+    def _delete_keyring(self, profile: str) -> None:
+        if self._keyring is None:
+            return
+        try:
+            self._keyring.delete_password(KEYRING_SERVICE_NAME, self._key(profile))
+        except Exception:
+            pass
+
+    def _save_file(self, profile: str, bundle: OAuthTokenBundle) -> None:
+        try:
+            _atomic_json_write(self.secret_path(profile), bundle.to_json())
+        except OSError as exc:
+            raise _bundle_error(profile, f"file bundle cannot be written: {exc}") from exc
+
+    def _delete_file(self, profile: str) -> None:
+        try:
+            self.secret_path(profile).unlink()
+        except FileNotFoundError:
+            return
+        except OSError as exc:
+            raise _bundle_error(profile, f"file bundle cannot be removed: {exc}") from exc
+
+
+def _text(value: object) -> str | None:
+    if value is None:
+        return None
+    normalized = str(value).strip()
+    return normalized or None
+
+
+def _bundle_error(profile: str, reason: str) -> QingflowApiError:
+    return QingflowApiError.config_error(
+        f"OAuth token bundle for profile '{profile}' is invalid: {reason}.",
+        details={"reason": "oauth_token_bundle_invalid", "profile": profile},
+    )

package/src/qingflow_mcp/server_cloud.py

@@ -109,9 +109,22 @@ class CloudMcpAuthApp:
             and self._oauth_token_resolver is not None
             and not auth_value.startswith("mcp_")
         )
+        access_context: dict[str, Any] | None = None
         try:
             if use_oauth:
                 assert self._oauth_token_resolver is not None
+                access_context = await anyio.to_thread.run_sync(
+                    self._broker.resolve_access_context,
+                    auth_value,
+                )
+                if access_context is not None:
+                    assert self._oauth_proxy is not None
+                    token_resource = str(access_context.get("resource") or "").strip()
+                    if token_resource != self._oauth_proxy.config.resource_url:
+                        raise QingflowApiError(
+                            category="auth",
+                            message="OAuth access token was issued for a different protected resource",
+                        )
                 cloud_context = await anyio.to_thread.run_sync(
                     self._resolve_oauth_or_legacy_credential,
                     auth_value,
@@ -138,7 +151,14 @@ class CloudMcpAuthApp:
             )
             return
 
-        if not call_platform:
+        trusted_source = (
+            str(access_context.get("source_code") or "").strip()
+            if access_context is not None
+            else ""
+        )
+        if trusted_source:
+            call_platform = trusted_source
+        elif not call_platform:
             call_platform = await anyio.to_thread.run_sync(
                 self._broker.resolve_call_platform,
                 cloud_context.token,