@qingflow-tech/qingflow-cli 1.1.46 → 1.1.47-beta.2

package/src/qingflow_mcp/cli/commands/builder.py

@@ -2,9 +2,23 @@ from __future__ import annotations
 
 import argparse
 from copy import deepcopy
+from pathlib import Path
 
 from ..context import CliContext
-from ...app_form_validator import AppFormValidationError, validate_declaration
+from ...app_form_validator import (
+    AppFormValidationError,
+    build_encoded_id_map,
+    referenced_formula_field_ids,
+    translate_formula_test_case_values,
+    encode_code_block_field_ids,
+    referenced_code_block_field_ids,
+    restore_decimal_ids_in_text,
+    strip_placeholder_quotes,
+    translate_select_test_case_values,
+    validate_code_block_static,
+    validate_declaration,
+    validate_formula_expression,
+)
 from ..json_io import load_json_value
 from .common import load_list_arg, load_object_arg, parse_bool_text, raise_config_error, require_list_arg
 
@@ -128,6 +142,41 @@ def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) ->
     app_form_validate.add_argument("--schema-version", help="固定使用的 AppForm Schema 版本")
     app_form_validate.set_defaults(handler=_handle_app_form_validate, format_hint="builder_summary", force_json_output=True)
 
+    app_form_validate_formula = app_form_subparsers.add_parser(
+        "validate-formula", help="校验公式表达式（本地语法 + 后端求值）"
+    )
+    app_form_validate_formula.add_argument("--app-key", required=True, help="目标应用 key")
+    app_form_validate_formula.add_argument("--formula", required=True, help="公式文本")
+    app_form_validate_formula.add_argument(
+        "--test-case",
+        required=True,
+        help="测试用例 JSON 文件路径，- 表示 stdin；格式 {queId: value}",
+    )
+    app_form_validate_formula.add_argument(
+        "--fields",
+        required=False,
+        help="字段清单 JSON 文件路径（用于本地字段引用校验）；缺省时从后端拉取",
+    )
+    app_form_validate_formula.set_defaults(
+        handler=_handle_app_form_validate_formula, format_hint="builder_summary", force_json_output=True
+    )
+
+    app_form_validate_code_block = app_form_subparsers.add_parser(
+        "validate-code-block", help="校验代码块（本地静态 + 后端真跑）"
+    )
+    app_form_validate_code_block.add_argument("--app-key", required=True, help="目标应用 key")
+    app_form_validate_code_block.add_argument(
+        "--code", required=True, help="代码文本（或 @文件路径读取）"
+    )
+    app_form_validate_code_block.add_argument(
+        "--test-case",
+        required=True,
+        help="测试用例 JSON 文件路径，- 表示 stdin；格式 [{keyQueId, ordinal?, values}]",
+    )
+    app_form_validate_code_block.set_defaults(
+        handler=_handle_app_form_validate_code_block, format_hint="builder_summary", force_json_output=True
+    )
+
     app = builder_subparsers.add_parser("app", help="应用")
     app_subparsers = app.add_subparsers(dest="builder_app_command", required=True)
 
@@ -395,6 +444,283 @@ def _handle_app_form_validate(args: argparse.Namespace, _context: CliContext) ->
     return {"category": "validation", "status": "success", "ok": True, **result, "message": "AppForm declaration is valid"}
 
 
+def _handle_app_form_validate_formula(args: argparse.Namespace, context: CliContext) -> dict:
+    formula = args.formula
+    test_case = load_json_value(
+        args.test_case, option_name="--test-case", max_bytes=1 * 1024 * 1024, max_depth=32
+    )
+    if not isinstance(test_case, dict):
+        raise_config_error(
+            "--test-case must be a JSON object {queId: value}", error_code="INVALID_TEST_CASE"
+        )
+
+    # 字段定义:优先 --fields;缺省拉全量(保留 option_details 供选择类值翻译)
+    fields_path = getattr(args, "fields", None)
+    if fields_path:
+        fields = _load_fields_for_validation(args, context)
+    else:
+        fields = _load_code_block_validation_fields(args, context) or _load_fields_for_validation(args, context)
+
+    # ① 本地语法校验（函数名 + 字段引用存在性）
+    syntax_fields = [
+        {"queId": f.get("que_id") or f.get("queId"), "name": f.get("name")} for f in (fields or [])
+    ] if fields else None
+    syntax_errors = validate_formula_expression(formula, syntax_fields)
+
+    # ①' 选择类值翻译:实测后端只认 [optId 数组],文案/标量 optId 均报错——把文案自动翻成 [optId]
+    test_case, select_changes, option_errors = translate_formula_test_case_values(fields, test_case)
+
+    # ①'' 覆盖校验:公式引用缺值字段会静默变空(CONCAT 直接跳过)→ 空洞通过,这里拦下
+    referenced_ids = referenced_formula_field_ids(formula)
+    underivable = _underivable_field_ids(fields)
+    covered_ids = {int(k) for k in test_case if str(k).isdigit()}
+    missing_ids = sorted((referenced_ids - covered_ids) - underivable)
+    coverage_errors = [
+        {
+            "pointer": "test-case",
+            "message": f"field queId {que_id} is referenced by formula but has no test-case value "
+            f"(reference would evaluate as empty)",
+        }
+        for que_id in missing_ids
+    ]
+
+    # ② 后端求值校验（本地有错时不浪费后端调用）
+    evaluation = None
+    evaluation_error = None
+    if not syntax_errors and not coverage_errors and not option_errors:
+        result = context.builder.app_form_evaluate_formula(
+            profile=args.profile, app_key=args.app_key, formula=formula, test_case=test_case
+        )
+        evaluation = result.get("evaluation")
+        evaluation_error = result.get("evaluationError")
+
+    ok = bool(
+        not syntax_errors
+        and not coverage_errors
+        and not option_errors
+        and isinstance(evaluation, dict)
+        and evaluation.get("valid") is True
+    )
+    return {
+        "category": "validation",
+        "status": "success" if ok else "failed",
+        "ok": ok,
+        "syntaxErrors": syntax_errors,
+        "coverageErrors": coverage_errors,
+        "optionErrors": option_errors,
+        "autoFixes": {"selectValuesTranslated": select_changes},
+        "evaluation": evaluation,
+        "evaluationError": evaluation_error,
+        "message": "formula is valid" if ok else "formula validation failed",
+    }
+
+
+def _handle_app_form_validate_code_block(args: argparse.Namespace, context: CliContext) -> dict:
+    raw_code = _read_code_arg(args.code)
+    # 占位符容错:模型常给字段名加引号(qf_field.{"名$$id$$"}),后端替换正则要求结尾恰为
+    # `$$}`,带引号直接匹配失败→占位符原样进 JS→语法错误。先剥离引号再进编码。
+    code_after_quotes, quote_fixes = strip_placeholder_quotes(raw_code)
+    # 后端运行时按 encryptQueId 的编码形态解码代码里的 $$id$$ 段再匹配 test-case 填值；
+    # AI 生成的代码是十进制 queId，先编码归一化（含字母的已编码段原样保留，防双重编码）。
+    code = encode_code_block_field_ids(code_after_quotes)
+    # 错误回显还原映射:后端错误里出现的编码 id 还原为模型写的十进制,避免模型逆向混淆。
+    encoded_id_map = build_encoded_id_map(code_after_quotes)
+    test_case = load_json_value(
+        args.test_case, option_name="--test-case", max_bytes=1 * 1024 * 1024, max_depth=32
+    )
+    if not isinstance(test_case, list):
+        raise_config_error(
+            "--test-case must be a JSON array [{keyQueId, ordinal?, values}]",
+            error_code="INVALID_TEST_CASE",
+        )
+
+    # 字段定义(选项翻译/覆盖豁免用;拉取失败不阻断,只是少一层自动修正)
+    fields = _load_code_block_validation_fields(args, context)
+
+    # ① 本地静态校验（qf_output 赋值 + 基本语法）
+    static_errors = validate_code_block_static(code)
+
+    # ①' 选择类值翻译:后端只认选项 optId,传文案静默变 null——把文案自动翻成 optId。
+    key_que_values = _normalize_code_block_test_case(test_case)
+    key_que_values, select_changes, option_errors = translate_select_test_case_values(fields, key_que_values)
+
+    # ①'' 测试覆盖校验：代码引用的字段必须在 test-case 中给值（成员/部门类豁免——
+    # 其值是 uid/部门 id,模型无从得知,代码须自行 null 安全）。缺值时后端会把占位符
+    # 替换成字面量 null 静默跑通（空洞通过）——在这里拦下，逼 test-case 补全而不是放行。
+    covered_ids = _code_block_test_case_field_ids(key_que_values)
+    underivable = _underivable_field_ids(fields)
+    referenced_ids = referenced_code_block_field_ids(raw_code)
+    missing_ids = sorted((referenced_ids - covered_ids) - underivable)
+    coverage_errors = [
+        {
+            "pointer": "test-case",
+            "message": f"field queId {que_id} is referenced by code but has no test-case value "
+            f"(placeholder would run as literal null)",
+        }
+        for que_id in missing_ids
+    ]
+
+    # ② 后端真跑校验（本地有错时不浪费后端调用）
+    run_result = None
+    run_error = None
+    if not static_errors and not coverage_errors and not option_errors:
+        result = context.builder.app_form_run_code_block(
+            profile=args.profile, app_key=args.app_key, code=code, key_que_values=key_que_values
+        )
+        run_result = result.get("runResult")
+        run_error = result.get("runError")
+
+    if isinstance(run_error, str):
+        run_error = restore_decimal_ids_in_text(run_error, encoded_id_map)
+
+    ok = not static_errors and not coverage_errors and not option_errors and run_result is not None
+    return {
+        "category": "validation",
+        "status": "success" if ok else "failed",
+        "ok": ok,
+        "staticErrors": static_errors,
+        "coverageErrors": coverage_errors,
+        "optionErrors": option_errors,
+        "autoFixes": {
+            "placeholderQuotesStripped": quote_fixes,
+            "selectValuesTranslated": select_changes,
+        },
+        "runResult": run_result,
+        "runError": run_error,
+        "message": "code block is valid" if ok else "code block validation failed",
+    }
+
+
+def _load_code_block_validation_fields(
+    args: argparse.Namespace, context: CliContext
+) -> list[dict] | None:
+    """加载字段定义(类型+选项 optId),供选择类值翻译与成员/部门覆盖豁免;失败返回 None。"""
+    try:
+        fetched = context.builder.app_get_fields(profile=args.profile, app_key=args.app_key)
+    except Exception:  # noqa: BLE001 - 字段拉取失败不阻断校验主流程
+        return None
+    if not isinstance(fetched, dict) or fetched.get("status") != "success":
+        return None
+    raw_fields = fetched.get("fields")
+    if not isinstance(raw_fields, list):
+        return None
+    return [field for field in raw_fields if isinstance(field, dict)]
+
+
+def _underivable_field_ids(fields: list[dict] | None) -> set[int]:
+    """值不可由模型推导的字段(成员/部门):test-case 覆盖校验豁免。"""
+    if not fields:
+        return set()
+    result: set[int] = set()
+    for field in fields:
+        field_type = str(field.get("type") or "")
+        if field_type in {"member", "department"}:
+            que_id = field.get("que_id") or field.get("queId")
+            if isinstance(que_id, int):
+                result.add(que_id)
+    return result
+
+
+def _code_block_test_case_field_ids(key_que_values: list[dict]) -> set[int]:
+    """test-case 覆盖的字段 id 集合：顶层 keyQueId + 表格 tableValues 行内 keyQueId。"""
+    covered: set[int] = set()
+    for item in key_que_values:
+        key = item.get("keyQueId")
+        if isinstance(key, int):
+            covered.add(key)
+        for row in item.get("tableValues") or []:
+            if isinstance(row, list):
+                for cell in row:
+                    if isinstance(cell, dict) and isinstance(cell.get("keyQueId"), int):
+                        covered.add(cell["keyQueId"])
+    return covered
+
+
+def _load_fields_for_validation(args: argparse.Namespace, context: CliContext) -> list[dict] | None:
+    """加载字段清单：优先 --fields 参数，缺省时从后端拉取应用字段。
+
+    后端拉取失败时返回 None（跳过字段引用校验，不阻断流程）。
+    """
+    fields_path = getattr(args, "fields", None)
+    if fields_path:
+        fields = load_json_value(
+            fields_path, option_name="--fields", max_bytes=2 * 1024 * 1024, max_depth=64
+        )
+        if not isinstance(fields, list):
+            raise_config_error(
+                "--fields must be a JSON array of field objects", error_code="INVALID_FIELDS"
+            )
+        return fields
+    fetched = context.builder.app_get_fields(profile=args.profile, app_key=args.app_key)
+    if not isinstance(fetched, dict) or fetched.get("status") != "success":
+        return None
+    raw_fields = fetched.get("fields")
+    if not isinstance(raw_fields, list):
+        return None
+    return [
+        {"queId": field.get("que_id"), "name": field.get("name")}
+        for field in raw_fields
+        if isinstance(field, dict)
+    ]
+
+
+def _read_code_arg(code_arg: str) -> str:
+    """读取 --code 参数：@ 前缀读文件内容，否则当文本。"""
+    if not isinstance(code_arg, str) or not code_arg:
+        raise_config_error("--code is required", error_code="INVALID_CODE")
+    if code_arg.startswith("@"):
+        path = code_arg[1:]
+        try:
+            return Path(path).expanduser().read_text(encoding="utf-8")
+        except OSError as exc:
+            raise_config_error(
+                f"failed to read --code from '{path}': {exc}", error_code="INVALID_CODE"
+            )
+    return code_arg
+
+
+def _normalize_code_block_test_case(test_case: list) -> list[dict]:
+    """将 --test-case 规范化为后端 OpenMatchQueValue 结构 [{keyQueId, ordinal?, values}]。"""
+    normalized: list[dict] = []
+    for item in test_case:
+        if not isinstance(item, dict):
+            raise_config_error(
+                "--test-case items must be JSON objects {keyQueId, ordinal?, values}",
+                error_code="INVALID_TEST_CASE",
+            )
+        raw_que_id = item.get("keyQueId", item.get("key_que_id"))
+        if raw_que_id is None:
+            raise_config_error(
+                "--test-case items require keyQueId", error_code="INVALID_TEST_CASE"
+            )
+        try:
+            key_que_id = int(raw_que_id)
+        except (TypeError, ValueError):
+            raise_config_error(
+                f"--test-case keyQueId must be an integer, got {raw_que_id!r}",
+                error_code="INVALID_TEST_CASE",
+            )
+        entry: dict = {"keyQueId": key_que_id}
+        if item.get("ordinal") is not None:
+            try:
+                entry["ordinal"] = int(item.get("ordinal"))
+            except (TypeError, ValueError):
+                raise_config_error(
+                    f"--test-case ordinal must be an integer, got {item.get('ordinal')!r}",
+                    error_code="INVALID_TEST_CASE",
+                )
+        values = item.get("values", [])
+        if not isinstance(values, list):
+            raise_config_error(
+                "--test-case item values must be a JSON array", error_code="INVALID_TEST_CASE"
+            )
+        entry["values"] = [str(value) for value in values]
+        if item.get("tableValues") is not None:
+            entry["tableValues"] = item.get("tableValues")
+        normalized.append(entry)
+    return normalized
+
+
 def _handle_app_delete(args: argparse.Namespace, context: CliContext) -> dict:
     return context.builder.app_delete(profile=args.profile, app_key=args.app_key)
 

package/src/qingflow_mcp/cli/context.py

@@ -15,6 +15,7 @@ from ..tools.export_tools import ExportTools
 from ..tools.feedback_tools import FeedbackTools
 from ..tools.file_tools import FileTools
 from ..tools.import_tools import ImportTools
+from ..tools.login_link_tools import LoginLinkTools
 from ..tools.record_tools import RecordTools
 from ..tools.resource_read_tools import ResourceReadTools
 from ..tools.task_context_tools import TaskContextTools
@@ -27,6 +28,7 @@ class CliContext:
     sessions: CliSessionFacade
     backend: BackendClient
     auth: AuthTools
+    login_link: LoginLinkTools
     workspace: WorkspaceTools
     app: AppTools
     resource: ResourceReadTools
@@ -57,6 +59,7 @@ def build_cli_context() -> CliContext:
         sessions=sessions,
         backend=backend,
         auth=AuthTools(sessions, backend),
+        login_link=LoginLinkTools(sessions, backend),
         workspace=WorkspaceTools(sessions, backend),
         app=AppTools(sessions, backend),
         resource=ResourceReadTools(sessions, backend),

package/src/qingflow_mcp/cli/formatters.py

@@ -191,9 +191,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 +202,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 +226,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 +298,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 +1187,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 +1220,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 +1231,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 +1308,7 @@ def _builder_item_summary(item: Any) -> str:
         "uid",
         "userId",
         "email",
+        "uri",
     )
     parts = [
         f"{key}={item.get(key)}"
@@ -1305,6 +1320,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 +1625,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,

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,6 +33,7 @@ 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")),
@@ -127,6 +128,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),
@@ -144,6 +146,8 @@ BUILDER_PUBLIC_TOOL_SPECS: tuple[PublicToolSpec, ...] = (
     PublicToolSpec(BUILDER_DOMAIN, "app_resolve", ("app_resolve",), ("builder", "app", "resolve"), has_contract=True, cli_show_effective_context=True),
     PublicToolSpec(BUILDER_DOMAIN, "app_form_schema", ("app_form_schema",), ("builder", "app-form", "schema")),
     PublicToolSpec(BUILDER_DOMAIN, "app_form_validate", (), ("builder", "app-form", "validate"), mcp_public=False),
+    PublicToolSpec(BUILDER_DOMAIN, "app_form_validate_formula", (), ("builder", "app-form", "validate-formula"), mcp_public=False),
+    PublicToolSpec(BUILDER_DOMAIN, "app_form_validate_code_block", (), ("builder", "app-form", "validate-code-block"), mcp_public=False),
     PublicToolSpec(BUILDER_DOMAIN, "app_form_get", ("app_form_get",), ("builder", "app-form", "get"), cli_show_effective_context=True),
     PublicToolSpec(BUILDER_DOMAIN, "app_form_apply", ("app_form_apply",), ("builder", "app-form", "apply"), cli_show_effective_context=True, cli_context_write=True),
     PublicToolSpec(BUILDER_DOMAIN, "app_delete", ("app_delete",), ("builder", "app", "delete"), cli_show_effective_context=True, cli_context_write=True),