@josephyan/qingflow-cli 0.2.0-beta.1000

package/src/qingflow_mcp/config.py

@@ -0,0 +1,407 @@
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+from urllib.parse import urlsplit, urlunsplit
+
+DEFAULT_PROFILE = "default"
+DEFAULT_TIMEOUT_SECONDS = 30.0
+DEFAULT_USER_AGENT = "qingflow-mcp/1.0"
+DEFAULT_RECORD_LIST_TYPE = 8
+ATTACHMENT_QUESTION_TYPE = 13
+DEFAULT_BASE_URL = "https://qingflow.com/api"
+DEFAULT_FEEDBACK_APP_KEY = "e0d017kju002"
+DEFAULT_FEEDBACK_QSOURCE_TOKEN = "mcp-feedback-7755d14748fc"
+DEFAULT_REPOSITORY_GIT_REMOTE_TEMPLATE = "git@hackers.oalite.com:{group}/{repo}.git"
+DEFAULT_REPOSITORY_PREVIEW_ADDRESS_TEMPLATE = "https://%s.preview.oalite.com"
+DEFAULT_REPOSITORY_DEVELOP_BRANCH = "develop"
+DEFAULT_REPOSITORY_PROD_BRANCH = "prod"
+DEFAULT_REPOSITORY_AUTHOR_NAME = "qingflow-mcp"
+DEFAULT_REPOSITORY_AUTHOR_EMAIL = "qingflow-mcp@local.invalid"
+DEFAULT_REPOSITORY_INTERNAL_SHARE_TOKEN_KEY = "tokenKey"
+DEFAULT_CREDIT_USAGE_RECORD_PATH = "/user/credit/usage"
+DEFAULT_MCPORTER_CONFIG_PATH = "~/.openclaw/workspace/config/mcporter.json"
+
+
+def get_mcp_home() -> Path:
+    custom_home = os.getenv("QINGFLOW_MCP_HOME")
+    return Path(custom_home).expanduser() if custom_home else Path.home() / ".qingflow-mcp"
+
+
+def get_profiles_path() -> Path:
+    return get_mcp_home() / "profiles.json"
+
+
+def get_mcporter_config_path() -> Path:
+    custom_path = os.getenv("QINGFLOW_MCP_MCPORTER_CONFIG_PATH") or os.getenv(
+        "QINGFLOW_MCP_AUTH_CONFIG_PATH"
+    )
+    return Path(custom_path).expanduser() if custom_path else Path(DEFAULT_MCPORTER_CONFIG_PATH)
+
+
+def get_repository_metadata_dir() -> Path:
+    return get_mcp_home() / "repository-metadata"
+
+
+def get_config_file_paths() -> list[Path]:
+    """
+    获取可能的配置文件路径列表，按优先级排序：
+    1. 环境变量 QINGFLOW_MCP_CONFIG_PATH 指定的路径
+    2. 当前工作目录下的 qingflow-mcp.config.json
+    3. MCP home 目录下的 config.json
+    4. 系统级配置 (Linux/Mac: /etc/qingflow-mcp/config.json)
+    """
+    paths: list[Path] = []
+
+    # 1. 环境变量
+    env_config = os.getenv("QINGFLOW_MCP_CONFIG_PATH")
+    if env_config:
+        paths.append(Path(env_config).expanduser())
+
+    # 2. 当前工作目录
+    paths.append(Path.cwd() / "qingflow-mcp.config.json")
+
+    # 3. MCP home 目录
+    paths.append(get_mcp_home() / "config.json")
+
+    # 4. 系统级配置 (仅非 Windows)
+    if os.name != "nt":
+        paths.append(Path("/etc/qingflow-mcp/config.json"))
+
+    return paths
+
+
+def load_config_file() -> dict[str, Any]:
+    """
+    加载第一个存在的配置文件
+
+    Returns:
+        配置字典，如果没有找到配置文件则返回空字典
+    """
+    for path in get_config_file_paths():
+        if path.exists():
+            try:
+                with open(path, "r", encoding="utf-8") as f:
+                    content = f.read()
+                    # 移除 JSON 注释 (简单的行注释处理)
+                    lines = []
+                    for line in content.split("\n"):
+                        stripped = line.strip()
+                        if not stripped.startswith("//") and not stripped.startswith("#"):
+                            lines.append(line)
+                    return json.loads("\n".join(lines))
+            except (json.JSONDecodeError, IOError) as e:
+                # 配置文件存在但读取失败，记录警告但不中断
+                print(f"Warning: Failed to load config from {path}: {e}")
+                continue
+    return {}
+
+
+def get_config_value(key: str, env_var: str | None = None, default: Any = None) -> Any:
+    """
+    获取配置值，优先级：环境变量 > 配置文件 > 默认值
+
+    Args:
+        key: 配置文件中的键名 (支持点号分隔的嵌套键，如 "profiles.default.name")
+        env_var: 环境变量名
+        default: 默认值
+
+    Returns:
+        配置值
+    """
+    # 1. 环境变量
+    if env_var:
+        env_value = os.getenv(env_var)
+        if env_value is not None:
+            return env_value
+
+    # 2. 配置文件
+    config = load_config_file()
+    keys = key.split(".")
+    value = config
+    for k in keys:
+        if isinstance(value, dict) and k in value:
+            value = value[k]
+        else:
+            value = None
+            break
+
+    if value is not None:
+        return value
+
+    # 3. 默认值
+    return default
+
+
+def get_default_base_url() -> str | None:
+    """获取默认的 Qingflow 后端地址"""
+    value = get_config_value(
+        "default_base_url",
+        env_var="QINGFLOW_MCP_DEFAULT_BASE_URL",
+        default=DEFAULT_BASE_URL
+    )
+    return normalize_base_url(value) if value else None
+
+
+def get_default_qf_version() -> str | None:
+    """获取默认的 qfVersion 路由值"""
+    value = get_config_value(
+        "default_qf_version",
+        env_var="QINGFLOW_MCP_DEFAULT_QF_VERSION",
+        default=None,
+    )
+    if value is None:
+        return None
+    normalized = str(value).strip()
+    return normalized or None
+
+
+def get_feedback_qsource_token() -> str | None:
+    """获取反馈 q-source 被动入口 token"""
+    value = get_config_value(
+        "feedback.qsource_token",
+        env_var="QINGFLOW_MCP_FEEDBACK_QSOURCE_TOKEN",
+        default=DEFAULT_FEEDBACK_QSOURCE_TOKEN,
+    )
+    if value is None:
+        return None
+    normalized = str(value).strip()
+    return normalized or None
+
+
+def get_feedback_base_url() -> str | None:
+    """获取反馈 q-source 使用的 base URL"""
+    value = get_config_value(
+        "feedback.base_url",
+        env_var="QINGFLOW_MCP_FEEDBACK_BASE_URL",
+        default=None,
+    )
+    if value is None:
+        return get_default_base_url()
+    normalized = normalize_base_url(value)
+    return normalized or get_default_base_url()
+
+
+def get_feedback_app_key() -> str:
+    """获取内部反馈表 app_key"""
+    value = get_config_value(
+        "feedback.app_key",
+        env_var="QINGFLOW_MCP_FEEDBACK_APP_KEY",
+        default=DEFAULT_FEEDBACK_APP_KEY,
+    )
+    normalized = str(value or "").strip()
+    return normalized or DEFAULT_FEEDBACK_APP_KEY
+
+
+def get_timeout_seconds() -> float:
+    """获取 HTTP 超时秒数"""
+    value = get_config_value(
+        "timeout_seconds",
+        env_var="QINGFLOW_MCP_TIMEOUT_SECONDS",
+        default=DEFAULT_TIMEOUT_SECONDS
+    )
+    try:
+        return float(value)
+    except (ValueError, TypeError):
+        return DEFAULT_TIMEOUT_SECONDS
+
+
+def get_log_level() -> str:
+    """获取日志级别"""
+    return get_config_value(
+        "log_level",
+        env_var="QINGFLOW_MCP_LOG_LEVEL",
+        default="INFO"
+    )
+
+
+def get_credit_meter_enabled() -> bool:
+    value = get_config_value(
+        "credit_meter.enabled",
+        env_var="QINGFLOW_MCP_CREDIT_METER_ENABLED",
+        default="true",
+    )
+    normalized = str(value or "").strip().lower()
+    return normalized in {"1", "true", "yes", "on"}
+
+
+def get_credit_usage_base_url() -> str | None:
+    value = get_config_value(
+        "credit_meter.apaas.base_url",
+        env_var="QINGFLOW_MCP_CREDIT_APAAS_BASE_URL",
+        default=None,
+    )
+    normalized = normalize_base_url(value)
+    return normalized or None
+
+
+def get_credit_usage_path() -> str:
+    value = get_config_value(
+        "credit_meter.apaas.path",
+        env_var="QINGFLOW_MCP_CREDIT_APAAS_PATH",
+        default=DEFAULT_CREDIT_USAGE_RECORD_PATH,
+    )
+    normalized = str(value or "").strip()
+    return normalized or DEFAULT_CREDIT_USAGE_RECORD_PATH
+
+
+def get_repository_default_group() -> str | None:
+    value = get_config_value(
+        "repository.default_group",
+        env_var="QINGFLOW_MCP_REPOSITORY_DEFAULT_GROUP",
+        default=None,
+    )
+    normalized = str(value or "").strip()
+    return normalized or None
+
+
+def get_repository_git_remote_template() -> str:
+    value = get_config_value(
+        "repository.git_remote_template",
+        env_var="QINGFLOW_MCP_REPOSITORY_GIT_REMOTE_TEMPLATE",
+        default=DEFAULT_REPOSITORY_GIT_REMOTE_TEMPLATE,
+    )
+    normalized = str(value or "").strip()
+    return normalized or DEFAULT_REPOSITORY_GIT_REMOTE_TEMPLATE
+
+
+def get_repository_preview_address_template() -> str:
+    value = get_config_value(
+        "repository.preview_address_template",
+        env_var="QINGFLOW_MCP_REPOSITORY_PREVIEW_ADDRESS_TEMPLATE",
+        default=DEFAULT_REPOSITORY_PREVIEW_ADDRESS_TEMPLATE,
+    )
+    normalized = str(value or "").strip()
+    return normalized or DEFAULT_REPOSITORY_PREVIEW_ADDRESS_TEMPLATE
+
+
+def get_repository_develop_branch() -> str:
+    value = get_config_value(
+        "repository.develop_branch",
+        env_var="QINGFLOW_MCP_REPOSITORY_DEVELOP_BRANCH",
+        default=DEFAULT_REPOSITORY_DEVELOP_BRANCH,
+    )
+    normalized = str(value or "").strip()
+    return normalized or DEFAULT_REPOSITORY_DEVELOP_BRANCH
+
+
+def get_repository_prod_branch() -> str:
+    value = get_config_value(
+        "repository.prod_branch",
+        env_var="QINGFLOW_MCP_REPOSITORY_PROD_BRANCH",
+        default=DEFAULT_REPOSITORY_PROD_BRANCH,
+    )
+    normalized = str(value or "").strip()
+    return normalized or DEFAULT_REPOSITORY_PROD_BRANCH
+
+
+def get_repository_author_name() -> str:
+    value = get_config_value(
+        "repository.author_name",
+        env_var="QINGFLOW_MCP_REPOSITORY_AUTHOR_NAME",
+        default=DEFAULT_REPOSITORY_AUTHOR_NAME,
+    )
+    normalized = str(value or "").strip()
+    return normalized or DEFAULT_REPOSITORY_AUTHOR_NAME
+
+
+def get_repository_author_email() -> str:
+    value = get_config_value(
+        "repository.author_email",
+        env_var="QINGFLOW_MCP_REPOSITORY_AUTHOR_EMAIL",
+        default=DEFAULT_REPOSITORY_AUTHOR_EMAIL,
+    )
+    normalized = str(value or "").strip()
+    return normalized or DEFAULT_REPOSITORY_AUTHOR_EMAIL
+
+
+def get_repository_internal_base_url() -> str | None:
+    value = get_config_value(
+        "repository.internal_base_url",
+        env_var="QINGFLOW_MCP_REPOSITORY_INTERNAL_BASE_URL",
+        default=None,
+    )
+    if value is None:
+        return None
+    normalized = normalize_base_url(str(value).strip())
+    return normalized or None
+
+
+def get_repository_internal_share_token() -> str | None:
+    value = get_config_value(
+        "repository.internal_share_token",
+        env_var="QINGFLOW_MCP_REPOSITORY_INTERNAL_SHARE_TOKEN",
+        default=None,
+    )
+    normalized = str(value or "").strip()
+    return normalized or None
+
+
+def get_repository_internal_share_token_key() -> str:
+    value = get_config_value(
+        "repository.internal_share_token_key",
+        env_var="QINGFLOW_MCP_REPOSITORY_INTERNAL_SHARE_TOKEN_KEY",
+        default=DEFAULT_REPOSITORY_INTERNAL_SHARE_TOKEN_KEY,
+    )
+    normalized = str(value or "").strip()
+    return normalized or DEFAULT_REPOSITORY_INTERNAL_SHARE_TOKEN_KEY
+
+
+def get_repository_generate_default_agent_id() -> int | None:
+    value = get_config_value(
+        "repository.generate.default_agent_id",
+        env_var="QINGFLOW_MCP_REPOSITORY_GENERATE_DEFAULT_AGENT_ID",
+        default=None,
+    )
+    if value is None:
+        return None
+    try:
+        return int(str(value).strip())
+    except (TypeError, ValueError):
+        return None
+
+
+def get_repository_generate_default_route_prefix() -> str | None:
+    value = get_config_value(
+        "repository.generate.default_route_prefix",
+        env_var="QINGFLOW_MCP_REPOSITORY_GENERATE_DEFAULT_ROUTE_PREFIX",
+        default=None,
+    )
+    normalized = str(value or "").strip()
+    return normalized or None
+
+
+def get_repository_generate_default_token_name() -> str | None:
+    value = get_config_value(
+        "repository.generate.default_token_name",
+        env_var="QINGFLOW_MCP_REPOSITORY_GENERATE_DEFAULT_TOKEN_NAME",
+        default=None,
+    )
+    normalized = str(value or "").strip()
+    return normalized or None
+
+
+def normalize_base_url(base_url: str | None) -> str | None:
+    """规范化 base URL"""
+    if base_url is None:
+        return None
+    normalized = base_url.strip()
+    if not normalized:
+        return None
+    normalized = normalized.rstrip("/")
+    try:
+        parsed = urlsplit(normalized)
+    except ValueError:
+        return normalized
+    if not parsed.scheme or not parsed.netloc:
+        return normalized
+
+    hostname = parsed.hostname or ""
+    if hostname.lower() == "www.qingflow.com":
+        netloc = "qingflow.com"
+        if parsed.port is not None:
+            netloc = f"{netloc}:{parsed.port}"
+        normalized = urlunsplit((parsed.scheme, netloc, parsed.path, parsed.query, parsed.fragment))
+    return normalized

package/src/qingflow_mcp/errors.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass
+
+from .json_types import JSONObject, JSONScalar
+
+
+INVALID_TOKEN_MARKERS = (
+    "invalid token",
+    "token invalid",
+    "token失效",
+    "无效token",
+    "登录失效",
+    "login token invalid",
+    "access token invalid",
+)
+
+
+@dataclass(slots=True)
+class QingflowApiError(Exception):
+    category: str
+    message: str
+    backend_code: JSONScalar = None
+    request_id: str | None = None
+    http_status: int | None = None
+    details: JSONObject | None = None
+
+    def to_dict(self) -> JSONObject:
+        return asdict(self)
+
+    def as_json(self) -> str:
+        return json.dumps(self.to_dict(), ensure_ascii=False)
+
+    def __str__(self) -> str:
+        return self.as_json()
+
+    def looks_like_invalid_token(self) -> bool:
+        text = self.message.lower()
+        return any(marker in text for marker in INVALID_TOKEN_MARKERS)
+
+    @classmethod
+    def auth_required(cls, profile: str) -> "QingflowApiError":
+        return cls(
+            category="auth",
+            message=f"Profile '{profile}' is not logged in. Run auth login or auth_use_credential first.",
+        )
+
+    @classmethod
+    def workspace_not_selected(cls, profile: str) -> "QingflowApiError":
+        return cls(
+            category="workspace",
+            message=f"WORKSPACE_NOT_SELECTED: profile '{profile}' has no workspace from auth context. Re-run auth login or auth_use_credential.",
+        )
+
+    @classmethod
+    def config_error(cls, message: str) -> "QingflowApiError":
+        return cls(category="config", message=message)
+
+    @classmethod
+    def not_supported(cls, message: str) -> "QingflowApiError":
+        return cls(category="not_supported", message=message)
+
+
+def raise_tool_error(error: QingflowApiError) -> None:
+    raise RuntimeError(error.as_json())

package/src/qingflow_mcp/id_utils.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from typing import Any
+
+from .errors import QingflowApiError
+
+
+JS_MAX_SAFE_INTEGER = 9_007_199_254_740_991
+
+
+def stringify_backend_id(value: Any) -> str | None:
+    """Return an exact public id string for backend-originated identifiers."""
+    if value in (None, ""):
+        return None
+    if isinstance(value, bool):
+        return None
+    text = str(value).strip()
+    return text or None
+
+
+def normalize_positive_id_text(value: Any, *, field_name: str) -> str:
+    """Normalize a user-supplied id while rejecting JS-unsafe numeric input."""
+    if value in (None, "") or isinstance(value, bool):
+        raise QingflowApiError.config_error(f"{field_name} must be positive")
+    if isinstance(value, int):
+        if value <= 0:
+            raise QingflowApiError.config_error(f"{field_name} must be positive")
+        if value > JS_MAX_SAFE_INTEGER:
+            raise QingflowApiError.config_error(
+                f"{field_name} exceeds JavaScript's safe integer range; pass it as a string to avoid precision loss"
+            )
+        return str(value)
+    if isinstance(value, str):
+        text = value.strip()
+        if not text.isdecimal() or int(text) <= 0:
+            raise QingflowApiError.config_error(f"{field_name} must be a positive integer string")
+        return text
+    raise QingflowApiError.config_error(f"{field_name} must be a positive integer string")
+
+
+def normalize_positive_id_int(value: Any, *, field_name: str) -> int:
+    """Normalize an id to Python int after the public boundary preserves it as text."""
+    return int(normalize_positive_id_text(value, field_name=field_name))
+
+
+def ids_equal(left: Any, right: Any) -> bool:
+    left_text = stringify_backend_id(left)
+    right_text = stringify_backend_id(right)
+    return left_text is not None and right_text is not None and left_text == right_text

package/src/qingflow_mcp/import_store.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Any
+
+from .config import get_mcp_home
+
+
+def _utc_now() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+def _parse_utc(value: Any) -> datetime | None:
+    if not isinstance(value, str) or not value.strip():
+        return None
+    normalized = value.strip().replace("Z", "+00:00")
+    try:
+        parsed = datetime.fromisoformat(normalized)
+    except ValueError:
+        return None
+    if parsed.tzinfo is None:
+        return parsed.replace(tzinfo=timezone.utc)
+    return parsed.astimezone(timezone.utc)
+
+
+def _json_safe_key(value: str) -> str:
+    keep = []
+    for char in value:
+        if char.isalnum() or char in {"-", "_"}:
+            keep.append(char)
+        else:
+            keep.append("_")
+    result = "".join(keep).strip("_")
+    return result or "entry"
+
+
+def _store_dir(env_var: str, default_name: str) -> Path:
+    custom = os.getenv(env_var)
+    if custom:
+        return Path(custom).expanduser()
+    return get_mcp_home() / default_name
+
+
+@dataclass(slots=True)
+class _JsonEntryStore:
+    base_dir: Path
+    ttl: timedelta
+
+    def __post_init__(self) -> None:
+        self.base_dir.mkdir(parents=True, exist_ok=True)
+        self.prune()
+
+    def put(self, entry_id: str, payload: dict[str, Any]) -> None:
+        data = dict(payload)
+        data["id"] = entry_id
+        data["updated_at"] = _utc_now().isoformat()
+        self._path(entry_id).write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+
+    def get(self, entry_id: str) -> dict[str, Any] | None:
+        path = self._path(entry_id)
+        if not path.exists():
+            return None
+        try:
+            payload = json.loads(path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            path.unlink(missing_ok=True)
+            return None
+        created_at = _parse_utc(payload.get("created_at")) or _parse_utc(payload.get("updated_at"))
+        if created_at is None or _utc_now() - created_at > self.ttl:
+            path.unlink(missing_ok=True)
+            return None
+        return payload
+
+    def prune(self) -> None:
+        for path in self.base_dir.glob("*.json"):
+            try:
+                payload = json.loads(path.read_text(encoding="utf-8"))
+            except (OSError, json.JSONDecodeError):
+                path.unlink(missing_ok=True)
+                continue
+            created_at = _parse_utc(payload.get("created_at")) or _parse_utc(payload.get("updated_at"))
+            if created_at is None or _utc_now() - created_at > self.ttl:
+                path.unlink(missing_ok=True)
+
+    def list(self) -> list[dict[str, Any]]:
+        entries: list[dict[str, Any]] = []
+        self.prune()
+        for path in self.base_dir.glob("*.json"):
+            try:
+                payload = json.loads(path.read_text(encoding="utf-8"))
+            except (OSError, json.JSONDecodeError):
+                continue
+            created_at = _parse_utc(payload.get("created_at")) or _parse_utc(payload.get("updated_at"))
+            if created_at is None:
+                continue
+            entries.append(payload)
+        entries.sort(key=lambda item: item.get("created_at") or item.get("updated_at") or "", reverse=True)
+        return entries
+
+    def _path(self, entry_id: str) -> Path:
+        return self.base_dir / f"{_json_safe_key(entry_id)}.json"
+
+
+class ImportVerificationStore(_JsonEntryStore):
+    def __init__(self, base_dir: Path | None = None, *, ttl_seconds: int = 3600) -> None:
+        super().__init__(
+            base_dir=base_dir or _store_dir("QINGFLOW_MCP_IMPORT_VERIFY_HOME", "import-verifications"),
+            ttl=timedelta(seconds=ttl_seconds),
+        )
+
+
+class ImportJobStore(_JsonEntryStore):
+    def __init__(self, base_dir: Path | None = None, *, ttl_seconds: int = 24 * 3600) -> None:
+        super().__init__(
+            base_dir=base_dir or _store_dir("QINGFLOW_MCP_IMPORT_JOB_HOME", "import-jobs"),
+            ttl=timedelta(seconds=ttl_seconds),
+        )

package/src/qingflow_mcp/json_types.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from typing import Protocol, Any
+
+# Use Any for JSON types to avoid Pydantic recursion issues
+# These are used for MCP tool signatures where exact typing is less critical
+JSONScalar = Any
+JSONValue = Any
+JSONObject = dict[str, Any]
+JSONArray = list[Any]
+
+
+class KeyringBackend(Protocol):
+    def set_password(self, service: str, key: str, value: str) -> None: ...
+
+    def get_password(self, service: str, key: str) -> str | None: ...
+
+    def delete_password(self, service: str, key: str) -> None: ...