@qingflow-tech/qingflow-cli 1.1.47 → 1.1.48-beta.1

package/src/qingflow_mcp/cli/formatters.py

@@ -8,7 +8,10 @@ from typing import Any, TextIO
 def emit_text_result(result: dict[str, Any], *, hint: str, stream: TextIO) -> None:
     text = _format_cancelled_result(result)
     if text is None:
-        if _is_failed_result(result) and hint != "task_action_execute":
+        if hint in _DATA_FORMAT_HINTS:
+            # 数据面失败也必须保留 field_errors 与列表型 hints，不能先走通用失败裁剪。
+            text = _format_data_result(result)
+        elif _is_failed_result(result) and hint != "task_action_execute":
             text = _format_failed_result(result)
         else:
             formatter = _FORMATTERS.get(hint, _format_generic)
@@ -90,6 +93,92 @@ def _format_generic(result: dict[str, Any]) -> str:
     return "\n".join(lines) + "\n"
 
 
+def _format_data_result(result: dict[str, Any]) -> str:
+    lines = [f"Status: {result.get('status') or ('success' if result.get('ok') is not False else 'failed')}"]
+    if result.get("format") == "csv":
+        files = result.get("files") if isinstance(result.get("files"), list) else []
+        lines.extend(
+            [
+                f"Local dir: {result.get('local_dir') or '-'}",
+                f"Files: {len(files)}",
+            ]
+        )
+        for item in files:
+            if isinstance(item, dict):
+                lines.append(
+                    f"- part {item.get('part')}: {item.get('local_path')} ({item.get('row_count')} rows)"
+                )
+        lines.extend(
+            [
+                f"Rows: {result.get('row_count')}",
+                f"Complete: {result.get('complete')}",
+                f"Truncated: {result.get('truncated')}",
+                f"Safe for final conclusion: {result.get('safe_for_final_conclusion')}",
+                f"Stopped reason: {result.get('stopped_reason') or '-'}",
+            ]
+        )
+    access = result.get("access") if isinstance(result.get("access"), dict) else {}
+    if access:
+        sources = access.get("scope_sources") if isinstance(access.get("scope_sources"), list) else []
+        lines.append(
+            f"Access: level={access.get('level') or '-'} / can_write={access.get('can_write')}"
+            f" / scope_sources={','.join(str(item) for item in sources) or '-'}"
+        )
+
+    records = result.get("records") if isinstance(result.get("records"), dict) else {}
+    if records:
+        items = records.get("items") if isinstance(records.get("items"), list) else []
+        lines.append(
+            "Pagination: "
+            f"page={records.get('page')} / requested_page_size={records.get('requested_page_size')} / "
+            f"page_size={records.get('page_size')} / total={records.get('total')} / "
+            f"has_more={records.get('has_more')} / returned={len(items)}"
+        )
+    record = result.get("record") if isinstance(result.get("record"), dict) else {}
+    if record:
+        lines.append(f"Record ID: {record.get('record_id') or '-'}")
+    items = result.get("items") if isinstance(result.get("items"), list) else []
+    if items:
+        lines.append(f"Items: {len(items)}")
+
+    for key, label in (
+        ("error_code", "Error Code"),
+        ("message", "Message"),
+        ("write_executed", "Write Executed"),
+        ("retry_safe", "Retry Safe"),
+    ):
+        if key in result:
+            lines.append(f"{label}: {result.get(key)}")
+
+    field_errors = result.get("field_errors") if isinstance(result.get("field_errors"), list) else []
+    if field_errors:
+        lines.append("Field Errors:")
+        _append_data_field_errors(lines, field_errors)
+    for index, item in enumerate(items):
+        if not isinstance(item, dict) or not isinstance(item.get("field_errors"), list):
+            continue
+        lines.append(f"Item {index} Field Errors:")
+        _append_data_field_errors(lines, item["field_errors"])
+
+    hints = result.get("hints") if isinstance(result.get("hints"), list) else []
+    lines.append(f"Hints: {len(hints)}")
+    for hint in hints:
+        if isinstance(hint, dict):
+            lines.append(f"- {hint.get('code') or '-'}: {hint.get('message') or '-'}")
+        else:
+            lines.append(f"- {hint}")
+    return "\n".join(lines) + "\n"
+
+
+def _append_data_field_errors(lines: list[str], field_errors: list[Any]) -> None:
+    for error in field_errors:
+        if isinstance(error, dict):
+            lines.append(
+                f"- {error.get('path') or '-'}: {error.get('message') or '-'}"
+                f" / fix_hint={error.get('fix_hint') or '-'}"
+            )
+
+
 def _format_whoami(result: dict[str, Any]) -> str:
     lines = [
         f"User: {result.get('nick_name') or '-'} ({result.get('email') or '-'})",
@@ -191,9 +280,10 @@ def _format_app_items(result: dict[str, Any]) -> str:
                 str(item.get("app_key") or item.get("appKey") or ""),
                 str(item.get("app_name") or item.get("name") or item.get("title") or ""),
                 str(item.get("package_name") or item.get("tag_name") or ""),
+                str(item.get("uri") or ""),
             ]
         )
-    return _render_titled_table("Apps", ["app_key", "app_name", "package"], rows)
+    return _render_titled_table("Apps", ["app_key", "app_name", "package", "uri"], rows)
 
 
 def _format_app_get(result: dict[str, Any]) -> str:
@@ -201,6 +291,7 @@ def _format_app_get(result: dict[str, Any]) -> str:
     lines = [
         f"App: {data.get('app_name') or '-'}",
         f"App Key: {data.get('app_key') or '-'}",
+        f"URI: {data.get('uri') or '-'}",
         f"Can Create: {data.get('can_create')}",
     ]
     import_capability = data.get("import_capability")
@@ -224,7 +315,7 @@ def _format_app_get(result: dict[str, Any]) -> str:
     lines.append(f"Accessible Views: {len(views)}")
     for item in views[:10]:
         if isinstance(item, dict):
-            lines.append(f"- {item.get('view_id')}: {item.get('name')}")
+            lines.append(f"- {item.get('view_id')}: {item.get('name')} / {item.get('uri') or '-'}")
     _append_warnings(lines, result.get("warnings"))
     return "\n".join(lines) + "\n"
 
@@ -296,6 +387,7 @@ def _format_view_get(result: dict[str, Any]) -> str:
         f"View Key: {data.get('view_key') or '-'}",
         f"App Key: {data.get('app_key') or '-'}",
         f"View Type: {data.get('view_type') or '-'}",
+        f"URI: {data.get('uri') or '-'}",
         f"Analysis Supported: {data.get('analysis_supported')}",
     ]
     if export_capability:
@@ -1184,6 +1276,7 @@ def _format_builder_summary(result: dict[str, Any]) -> str:
         ("view_key", "View Key"),
         ("chart_id", "Chart ID"),
         ("package_id", "Package ID"),
+        ("uri", "URI"),
         ("verified", "Verified"),
         ("write_executed", "Write Executed"),
         ("delete_executed", "Delete Executed"),
@@ -1216,6 +1309,7 @@ def _format_builder_summary(result: dict[str, Any]) -> str:
         "associations",
         "package_ids",
         "app_keys",
+        "resources",
     ):
         value = result.get(key)
         if not isinstance(value, list) and isinstance(data, dict):
@@ -1226,6 +1320,15 @@ def _format_builder_summary(result: dict[str, Any]) -> str:
                 lines.append("- " + _builder_item_summary(item))
             if len(value) > 8:
                 lines.append(f"... {len(value) - 8} more")
+            if key == "apps":
+                uri_lines = [
+                    line
+                    for item in value
+                    for line in _builder_batch_item_uri_lines(item)
+                ]
+                if uri_lines:
+                    lines.append("Resource URIs:")
+                    lines.extend(f"- {line}" for line in uri_lines)
     components = result.get("components") if isinstance(result.get("components"), list) else []
     if components:
         lines.append("Component Refs:")
@@ -1294,6 +1397,7 @@ def _builder_item_summary(item: Any) -> str:
         "uid",
         "userId",
         "email",
+        "uri",
     )
     parts = [
         f"{key}={item.get(key)}"
@@ -1305,6 +1409,50 @@ def _builder_item_summary(item: Any) -> str:
     return " / ".join(parts) if parts else json.dumps(item, ensure_ascii=False)
 
 
+def _builder_batch_item_uri_lines(item: Any) -> list[str]:
+    if not isinstance(item, dict):
+        return []
+    item_status = str(item.get("status") or "").lower()
+    if item_status not in {"success", "partial_success"}:
+        return []
+    data = item.get("data") if isinstance(item.get("data"), dict) else item.get("result")
+    if not isinstance(data, dict) or not _builder_uri_is_confirmed(data, fallback_status=item_status):
+        return []
+    lines: list[str] = []
+    if data.get("uri"):
+        lines.append(f"URI: {data['uri']}")
+    views = data.get("views") if isinstance(data.get("views"), list) else []
+    for view in views:
+        if (
+            isinstance(view, dict)
+            and view.get("uri")
+            and _builder_uri_is_confirmed(view, fallback_status=item_status)
+        ):
+            lines.append(f"View URI: {view['uri']}")
+    return lines
+
+
+def _builder_uri_is_confirmed(value: dict[str, Any], *, fallback_status: str) -> bool:
+    status = str(value.get("status") or fallback_status).lower()
+    operation = str(value.get("operation") or "").lower()
+    return (
+        status in {"success", "partial_success", "unchanged", "verified"}
+        and operation
+        not in {
+            "failed",
+            "pending",
+            "planned",
+            "readback_pending",
+            "pending_readback",
+            "unknown",
+            "remove",
+            "removed",
+            "delete",
+            "deleted",
+        }
+    )
+
+
 def _format_file_upload_local(result: dict[str, Any]) -> str:
     lines = [
         f"Upload Kind: {result.get('upload_kind') or result.get('requested_upload_kind') or '-'}",
@@ -1566,7 +1714,12 @@ def _task_action_debug_lines(result: dict[str, Any]) -> list[str]:
     return lines
 
 
+def _format_login_link(result: dict[str, Any]) -> str:
+    return f"登录链接：{result['url']}\n过期时间（Unix 毫秒）：{result['expires_at']}\n链接只能使用一次，请勿泄露；仅在用户要求打开时才打开。\n"
+
+
 _FORMATTERS = {
+    "login_link": _format_login_link,
     "auth_whoami": _format_whoami,
     "workspace_list": _format_workspace_list,
     "workspace_get": _format_workspace_get,
@@ -1604,4 +1757,11 @@ _FORMATTERS = {
     "builder_summary": _format_builder_summary,
     "file_upload_local": _format_file_upload_local,
     "feedback_submit": _format_feedback_submit,
+    "data_query": _format_data_result,
+    "data_get": _format_data_result,
+    "data_insert": _format_data_result,
+    "data_update": _format_data_result,
+    "data_delete": _format_data_result,
 }
+
+_DATA_FORMAT_HINTS = {"data_query", "data_get", "data_insert", "data_update", "data_delete"}

package/src/qingflow_mcp/cli/main.py

@@ -2,11 +2,13 @@ from __future__ import annotations
 
 import argparse
 import json
+import os
 import sys
 from typing import Any, Callable, TextIO
 
 from ..errors import QingflowApiError, backend_code_value_int, message_looks_like_invalid_token
 from ..public_surface import cli_public_tool_spec_from_namespace
+from ..resource_uri import cli_resource_base_url
 from ..response_trim import resolve_cli_tool_name, trim_error_response, trim_public_response
 from ..tools.ai_builder_tools import _attach_builder_apply_envelope
 from ..version import get_cli_version, get_cli_version_info
@@ -94,7 +96,8 @@ def run(
         context = context_factory()
         if not bool(args.json):
             _emit_cli_effective_context_notice(args, context, stream=err)
-        result = handler(args, context)
+        with cli_resource_base_url(os.getenv("QINGFLOW_BASE_URL") or ""):
+            result = handler(args, context)
     except SystemExit as exc:
         return int(exc.code or 0)
     except RuntimeError as exc:

package/src/qingflow_mcp/config.py

@@ -2,16 +2,20 @@ from __future__ import annotations
 
 import json
 import os
+import re
 from pathlib import Path
 from typing import Any
 from urllib.parse import urlsplit, urlunsplit
 
+from .errors import QingflowApiError
+
 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_WEB_BASE_URL = "https://qingflow.com"
 DEFAULT_CLI_OAUTH_RESOURCE_URL = "https://mcp.qingflow.com/mcp"
 DEFAULT_FEEDBACK_APP_KEY = "e0d017kju002"
 DEFAULT_FEEDBACK_QSOURCE_TOKEN = "mcp-feedback-7755d14748fc"
@@ -153,6 +157,41 @@ def get_default_base_url() -> str | None:
     return normalize_base_url(value) if value else None
 
 
+def get_web_base_url() -> str:
+    """读取网页根地址；空白配置逐级回退，不复用后端或 OAuth 地址。"""
+    value = os.getenv("QINGFLOW_MCP_WEB_BASE_URL")
+    if value is None or not value.strip():
+        value = get_config_value("web_base_url", default=DEFAULT_WEB_BASE_URL)
+    if isinstance(value, str) and not value.strip():
+        value = DEFAULT_WEB_BASE_URL
+    try:
+        if not isinstance(value, str):
+            raise ValueError
+        value = value.strip()
+        parsed = urlsplit(value)
+        host = parsed.hostname or ""
+        # urlsplit 会校验 IPv6；域名标签额外拒绝空格、转义字符及无效边界。
+        valid_host = bool(host) and (":" in host or all(
+            re.fullmatch(r"[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?", label)
+            for label in host.rstrip(".").split(".")
+        ))
+        if (
+            parsed.scheme not in {"http", "https"}
+            or not valid_host or host.lower() in {"null", "undefined"}
+            or parsed.username is not None or parsed.password is not None
+            or parsed.path not in {"", "/"} or "?" in value or "#" in value
+            or any(character.isspace() or ord(character) < 32 for character in value)
+        ):
+            raise ValueError
+        # 访问 port 触发 urllib 的端口格式与范围校验。
+        _ = parsed.port
+        return urlunsplit((parsed.scheme, parsed.netloc, "", "", ""))
+    except ValueError:
+        raise QingflowApiError.config_error(
+            "QINGFLOW_MCP_WEB_BASE_URL（web_base_url）必须是有效的 HTTP(S) 网页根地址，不包含路径、查询参数或用户凭证"
+        ) from None
+
+
 def get_default_qf_version() -> str | None:
     """获取默认的 qfVersion 路由值"""
     value = get_config_value(

package/src/qingflow_mcp/public_surface.py

@@ -33,12 +33,18 @@ USER_PUBLIC_TOOL_SPECS: tuple[PublicToolSpec, ...] = (
     PublicToolSpec(USER_DOMAIN, "auth_login", cli_route=("auth", "login"), mcp_public=False),
     PublicToolSpec(USER_DOMAIN, "auth_use_credential", ("auth_use_credential",), ("auth", "use-credential")),
     PublicToolSpec(USER_DOMAIN, "auth_whoami", ("auth_whoami",), ("auth", "whoami")),
+    PublicToolSpec(USER_DOMAIN, "get_login_link", ("get_login_link",), ("auth", "login-link")),
     PublicToolSpec(USER_DOMAIN, "auth_logout", ("auth_logout",), ("auth", "logout")),
     PublicToolSpec(USER_DOMAIN, "workspace_list", ("workspace_list",), ("workspace", "list")),
     PublicToolSpec(USER_DOMAIN, "workspace_get", ("workspace_get",), ("workspace", "get")),
     PublicToolSpec(USER_DOMAIN, "workspace_select", ("workspace_select",), ("workspace", "select")),
     PublicToolSpec(USER_DOMAIN, "app_list", ("app_list",), ("app", "list"), cli_show_effective_context=True),
     PublicToolSpec(USER_DOMAIN, "app_get", ("app_get",), ("app", "get"), cli_show_effective_context=True),
+    PublicToolSpec(USER_DOMAIN, "data_query", ("data_query",), ("data", "query"), cli_show_effective_context=True),
+    PublicToolSpec(USER_DOMAIN, "data_get", ("data_get",), ("data", "get"), cli_show_effective_context=True),
+    PublicToolSpec(USER_DOMAIN, "data_insert", ("data_insert",), ("data", "insert"), cli_show_effective_context=True, cli_context_write=True),
+    PublicToolSpec(USER_DOMAIN, "data_update", ("data_update",), ("data", "update"), cli_show_effective_context=True, cli_context_write=True),
+    PublicToolSpec(USER_DOMAIN, "data_delete", ("data_delete",), ("data", "delete"), cli_show_effective_context=True, cli_context_write=True),
     PublicToolSpec(USER_DOMAIN, "portal_list", ("portal_list",), ("portal", "list"), cli_show_effective_context=True),
     PublicToolSpec(USER_DOMAIN, "portal_get", ("portal_get",), ("portal", "get"), cli_show_effective_context=True),
     PublicToolSpec(USER_DOMAIN, "view_get", ("view_get",), ("view", "get"), cli_show_effective_context=True),
@@ -127,6 +133,7 @@ BUILDER_PUBLIC_TOOL_SPECS: tuple[PublicToolSpec, ...] = (
     PublicToolSpec(BUILDER_DOMAIN, "auth_use_credential", ("auth_use_credential",), ("builder", "auth", "use-credential"), cli_public=False),
     PublicToolSpec(BUILDER_DOMAIN, "auth_whoami", ("auth_whoami",), ("builder", "auth", "whoami"), cli_public=False),
     PublicToolSpec(BUILDER_DOMAIN, "auth_logout", ("auth_logout",), ("builder", "auth", "logout"), cli_public=False),
+    PublicToolSpec(BUILDER_DOMAIN, "get_login_link", ("get_login_link",), mcp_public=True, cli_public=False),
     PublicToolSpec(BUILDER_DOMAIN, "workspace_list", ("workspace_list",), ("builder", "workspace", "list"), cli_public=False),
     PublicToolSpec(BUILDER_DOMAIN, "workspace_get", ("workspace_get",), ("builder", "workspace", "get"), cli_public=False),
     PublicToolSpec(BUILDER_DOMAIN, "file_upload_local", ("file_upload_local",), ("builder", "file", "upload-local"), has_contract=True, cli_show_effective_context=True, cli_context_write=True),

package/src/qingflow_mcp/resource_uri.py

@@ -0,0 +1,241 @@
+from __future__ import annotations
+
+import re
+from collections.abc import Iterator
+from contextlib import contextmanager
+from contextvars import ContextVar
+from dataclasses import dataclass
+from typing import Any
+from urllib.parse import quote, unquote, urlsplit, urlunsplit
+
+from .config import DEFAULT_WEB_BASE_URL, get_web_base_url
+from .errors import QingflowApiError
+from .json_types import JSONObject
+
+
+SYSTEM_VIEW_NAMES = frozenset({"all", "initiated", "todo", "done", "cc"})
+_ENCODED_OCTET = re.compile(r"%[0-9A-Fa-f]{2}")
+_CLI_RESOURCE_BASE_URL: ContextVar[str | None] = ContextVar(
+    "qingflow_cli_resource_base_url",
+    default=None,
+)
+
+
+@dataclass(frozen=True, slots=True)
+class ResourcePath:
+    resource_type: str
+    ws_id: int
+    package_id: int | None = None
+    app_key: str | None = None
+    view_kind: str | None = None
+    view_key: str | None = None
+
+
+@contextmanager
+def cli_resource_base_url(value: str) -> Iterator[None]:
+    """让一次 CLI 调用的资源 URI 使用 QINGFLOW_BASE_URL 对应的网页环境。"""
+    token = _CLI_RESOURCE_BASE_URL.set(value)
+    try:
+        yield
+    finally:
+        _CLI_RESOURCE_BASE_URL.reset(token)
+
+
+def validate_resource_identity(value: object, field: str = "resource_id") -> str:
+    """按资源 URI 单路径段合同校验并返回规范身份，不读取网页域名配置。"""
+    return _validate_identity(value, field)
+
+
+def validate_positive_resource_id(value: object, field: str = "resource_id") -> int:
+    """按资源 URI 数字路径段合同校验正整数，不接受布尔值或浮点截断。"""
+    return int(_positive_int_segment(value, field))
+
+
+def build_resource_uri(
+    *,
+    ws_id: object,
+    resource_type: str,
+    package_id: object = None,
+    app_key: object = None,
+    view_kind: str | None = None,
+    view_key: object = None,
+    web_origin: str | None = None,
+) -> str:
+    """按固定公共合同构造资源 URI，不接受通用目标路由。"""
+    workspace = _positive_int_segment(ws_id, "ws_id")
+    if resource_type == "package":
+        path = f"/resources/ws/{workspace}/package/{_positive_int_segment(package_id, 'package_id')}"
+    elif resource_type == "app":
+        path = f"/resources/ws/{workspace}/app/{_identity_segment(app_key, 'app_key')}"
+    elif resource_type == "view":
+        app_segment = _identity_segment(app_key, "app_key")
+        if view_kind == "custom":
+            view_segment = _identity_segment(view_key, "view_key")
+        elif view_kind == "system":
+            name = str(view_key or "").strip()
+            if name not in SYSTEM_VIEW_NAMES:
+                raise ValueError("system view name is not supported")
+            view_segment = name
+        else:
+            raise ValueError("view_kind must be custom or system")
+        path = f"/resources/ws/{workspace}/app/{app_segment}/view/{view_kind}/{view_segment}"
+    else:
+        raise ValueError("resource_type is not supported")
+    return f"{resolve_resource_web_origin(web_origin)}{path}"
+
+
+def parse_resource_path(value: str) -> ResourcePath:
+    """严格解析资源 pathname，供免登录签发前校验工作区。"""
+    try:
+        parsed = urlsplit(value)
+        if parsed.scheme or parsed.netloc or parsed.query or parsed.fragment or parsed.path != value:
+            raise ValueError
+        parts = parsed.path.split("/")
+        if len(parts) < 6 or parts[:3] != ["", "resources", "ws"]:
+            raise ValueError
+        ws_id = int(_decode_segment(parts[3], "ws_id"))
+        if ws_id <= 0:
+            raise ValueError
+        if len(parts) == 6 and parts[4] == "package":
+            package_id = int(_decode_segment(parts[5], "package_id"))
+            if package_id <= 0:
+                raise ValueError
+            return ResourcePath("package", ws_id, package_id=package_id)
+        if len(parts) == 6 and parts[4] == "app":
+            return ResourcePath("app", ws_id, app_key=_decode_segment(parts[5], "app_key"))
+        if len(parts) == 9 and parts[4] == "app" and parts[6] == "view":
+            app_key = _decode_segment(parts[5], "app_key")
+            view_kind = parts[7]
+            view_key = _decode_segment(parts[8], "view_key")
+            if view_kind == "system" and view_key not in SYSTEM_VIEW_NAMES:
+                raise ValueError
+            if view_kind not in {"custom", "system"}:
+                raise ValueError
+            return ResourcePath("view", ws_id, app_key=app_key, view_kind=view_kind, view_key=view_key)
+    except (TypeError, ValueError, UnicodeError):
+        pass
+    raise ValueError("resource path is invalid")
+
+
+def try_build_resource_uri(**kwargs: Any) -> tuple[str | None, JSONObject | None]:
+    try:
+        return build_resource_uri(**kwargs), None
+    except (QingflowApiError, ValueError, UnicodeError) as error:
+        return None, {
+            "code": "RESOURCE_URI_UNAVAILABLE",
+            "message": f"resource URI was omitted because its identity or web origin is invalid: {error}",
+        }
+
+
+def _positive_int_segment(value: object, field: str) -> str:
+    if isinstance(value, bool):
+        raise ValueError(f"{field} must be a positive integer")
+    try:
+        parsed = int(value)
+    except (TypeError, ValueError):
+        raise ValueError(f"{field} must be a positive integer") from None
+    if parsed <= 0 or str(value).strip() != str(parsed):
+        raise ValueError(f"{field} must be a positive integer")
+    return str(parsed)
+
+
+def _normalize_web_origin(value: str) -> str:
+    try:
+        parsed = urlsplit(value.strip())
+        if (
+            parsed.scheme not in {"http", "https"}
+            or not parsed.hostname
+            or parsed.username is not None
+            or parsed.password is not None
+            or parsed.path not in {"", "/"}
+            or parsed.query
+            or parsed.fragment
+            or any(character.isspace() or ord(character) < 32 for character in value)
+        ):
+            raise ValueError
+        _ = parsed.port
+    except (AttributeError, ValueError):
+        raise ValueError("web_origin must be an absolute HTTP(S) origin") from None
+    return urlunsplit((parsed.scheme, parsed.netloc, "", "", ""))
+
+
+def resolve_resource_web_origin(web_origin: str | None = None) -> str:
+    """解析当前调用面的网页根地址；CLI 与 MCP 分别沿用各自的环境配置。"""
+    if web_origin is not None:
+        return _normalize_web_origin(web_origin)
+    cli_base_url = _CLI_RESOURCE_BASE_URL.get()
+    if cli_base_url is None:
+        return get_web_base_url()
+    return _web_origin_from_api_base_url(cli_base_url)
+
+
+def _web_origin_from_api_base_url(value: str) -> str:
+    normalized = value.strip()
+    if not normalized:
+        return DEFAULT_WEB_BASE_URL
+    try:
+        parsed = urlsplit(normalized)
+        host = parsed.hostname or ""
+        valid_host = bool(host) and (":" in host or all(
+            re.fullmatch(r"[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?", label)
+            for label in host.rstrip(".").split(".")
+        ))
+        if (
+            parsed.scheme not in {"http", "https"}
+            or not valid_host
+            or host.lower() in {"null", "undefined"}
+            or parsed.username is not None
+            or parsed.password is not None
+            or parsed.query
+            or parsed.fragment
+            or any(character.isspace() or ord(character) < 32 for character in normalized)
+        ):
+            raise ValueError
+        _ = parsed.port
+        return _normalize_web_origin(urlunsplit((parsed.scheme, parsed.netloc, "", "", "")))
+    except ValueError:
+        raise QingflowApiError.config_error(
+            "QINGFLOW_BASE_URL 必须是有效的 HTTP(S) API 地址，不包含查询参数、片段或用户凭证"
+        ) from None
+
+
+def _identity_segment(value: object, field: str) -> str:
+    raw = _validate_identity(value, field)
+    return quote(raw, safe="")
+
+
+def _decode_segment(value: str, field: str) -> str:
+    decoded = _validate_identity(unquote(value, errors="strict"), field)
+    if quote(decoded, safe="") != value:
+        raise ValueError(f"{field} must use canonical path encoding")
+    return decoded
+
+
+def _validate_identity(value: object, field: str) -> str:
+    source = str(value or "")
+    if any(ord(character) < 32 or ord(character) == 127 for character in source):
+        raise ValueError(f"{field} must be one safe path segment")
+    raw = source.strip()
+    if not raw:
+        raise ValueError(f"{field} is required")
+    current = raw
+    for _ in range(8):
+        if (
+            current in {".", ".."}
+            or any(character in current for character in "/\\?#")
+            or any(ord(character) < 32 or ord(character) == 127 for character in current)
+        ):
+            raise ValueError(f"{field} must be one safe path segment")
+        decoded = unquote(current, errors="strict")
+        if decoded == current:
+            return raw
+        current = decoded
+    if (
+        current in {".", ".."}
+        or any(character in current for character in "/\\?#")
+        or any(ord(character) < 32 or ord(character) == 127 for character in current)
+    ):
+        raise ValueError(f"{field} must be one safe path segment")
+    if _ENCODED_OCTET.search(current):
+        raise ValueError(f"{field} has excessive encoding")
+    return raw

package/src/qingflow_mcp/response_trim.py

@@ -326,7 +326,7 @@ def _trim_workspace_get(payload: JSONObject) -> None:
 
 def _trim_app_list_like(payload: JSONObject) -> None:
     payload.pop("apps", None)
-    _trim_item_list(payload, "items", allowed=("app_key", "app_name", "package_name"))
+    _trim_item_list(payload, "items", allowed=("app_key", "app_name", "package_name", "uri"))
 
 
 def _trim_app_get(payload: JSONObject) -> None:
@@ -334,7 +334,7 @@ def _trim_app_get(payload: JSONObject) -> None:
     _trim_nested_item_list(
         payload,
         ("data", "accessible_views"),
-        allowed=("view_id", "name", "analysis_supported", "list_supported", "kind"),
+        allowed=("view_id", "name", "analysis_supported", "list_supported", "kind", "uri"),
     )
 
 
@@ -1134,6 +1134,13 @@ def _summarize_form_diff(diff: dict[str, Any]) -> dict[str, Any]:
     return summary
 
 
+def _trim_login_link(payload: JSONObject) -> None:
+    # 临时票据只通过链接交付，必须保留链接和过期时间。
+    for key in list(payload):
+        if key not in {"url", "expires_at"}:
+            payload.pop(key)
+
+
 def _register_policy(domains: tuple[str, ...], names: tuple[str, ...], transform: TransformFn) -> None:
     for domain in domains:
         for name in names:
@@ -1215,6 +1222,7 @@ _register_policy(
     _trim_directory,
 )
 _register_policy((USER_DOMAIN, BUILDER_DOMAIN), ("feedback_submit",), _trim_feedback)
+_register_policy((USER_DOMAIN, BUILDER_DOMAIN), ("get_login_link",), _trim_login_link)
 _register_policy(
     (USER_DOMAIN,),
     (