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

package/README.md

@@ -7,7 +7,7 @@ Qingflow CLI 是轻流面向开发者和 AI Agent 的命令行工具。它把轻
 ## 安装
 
 ```bash
-npm install @qingflow-tech/qingflow-cli@1.1.47
+npm install @qingflow-tech/qingflow-cli@1.1.48-beta.1
 ```
 
 推荐从官网复制这一条一键安装 Qingflow CLI：
@@ -21,7 +21,7 @@ npx qingflow-cli@latest install
 ## 运行
 
 ```bash
-npx -y -p @qingflow-tech/qingflow-cli@1.1.47 qingflow
+npx -y -p @qingflow-tech/qingflow-cli@1.1.48-beta.1 qingflow
 ```
 
 全局安装后可以直接运行：
@@ -62,7 +62,7 @@ qingflow-skills install --agent codex --scope user
 如果你通过一次性 `npx -p` 执行 skills 安装，建议加 `--copy`，避免 symlink 指向 npm 临时执行缓存：
 
 ```bash
-npx -y -p @qingflow-tech/qingflow-cli@1.1.47 qingflow-skills install --agent codex --scope user --copy
+npx -y -p @qingflow-tech/qingflow-cli@1.1.48-beta.1 qingflow-skills install --agent codex --scope user --copy
 ```
 
 `qingflow-skills install` 默认使用 symlink，且遇到同名 skill 不会覆盖；只有显式传入 `--force` 才会替换。

package/npm/lib/runtime.mjs

@@ -569,6 +569,34 @@ function findOfflineProjectWheel(findLinksDir) {
   return path.join(findLinksDir, wheels[wheels.length - 1]);
 }
 
+function hasEnv(env, name) {
+  return Object.prototype.hasOwnProperty.call(env, name);
+}
+
+export function buildPipInstallArgs(env = process.env) {
+  const standardNoIndexConfigured = hasEnv(env, "PIP_NO_INDEX");
+  const standardFindLinksConfigured = hasEnv(env, "PIP_FIND_LINKS");
+
+  const noIndex = (standardNoIndexConfigured ? env.PIP_NO_INDEX : env.QINGFLOW_MCP_PIP_NO_INDEX) === "1";
+  const findLinks = String(
+    standardFindLinksConfigured ? env.PIP_FIND_LINKS ?? "" : env.QINGFLOW_MCP_PIP_FIND_LINKS ?? "",
+  ).trim();
+
+  const pipArgs = ["install", "--disable-pip-version-check"];
+  if (noIndex) {
+    pipArgs.push("--no-index");
+  }
+  if (findLinks) {
+    pipArgs.push("--find-links", findLinks);
+  }
+  if (noIndex && findLinks) {
+    pipArgs.push(findOfflineProjectWheel(findLinks));
+  } else {
+    pipArgs.push(".");
+  }
+  return pipArgs;
+}
+
 export function findPython() {
   const preferred = process.env.QINGFLOW_MCP_PYTHON?.trim();
   const candidates = preferred
@@ -629,19 +657,7 @@ export function ensurePythonEnv(packageRoot, { force = false, commandName = "qin
   }
 
   const pip = getVenvPip(packageRoot);
-  const pipArgs = ["install", "--disable-pip-version-check"];
-  const offlineFindLinks = process.env.QINGFLOW_MCP_PIP_FIND_LINKS?.trim();
-  if (process.env.QINGFLOW_MCP_PIP_NO_INDEX === "1") {
-    pipArgs.push("--no-index");
-  }
-  if (offlineFindLinks) {
-    pipArgs.push("--find-links", offlineFindLinks);
-  }
-  if (process.env.QINGFLOW_MCP_PIP_NO_INDEX === "1" && offlineFindLinks) {
-    pipArgs.push(findOfflineProjectWheel(offlineFindLinks));
-  } else {
-    pipArgs.push(".");
-  }
+  const pipArgs = buildPipInstallArgs();
   runChecked(pip, pipArgs, { cwd: packageRoot });
 
   const probe = probePythonRuntime(packageRoot, commandName);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qingflow-tech/qingflow-cli",
-  "version": "1.1.47",
+  "version": "1.1.48-beta.1",
   "description": "Human-friendly Qingflow command line interface for auth, record operations, import, tasks, and stable builder flows.",
   "license": "MIT",
   "type": "module",

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qingflow-mcp"
-version = "1.1.47"
+version = "1.1.48b1"
 description = "User-authenticated MCP server for Qingflow"
 readme = "README.md"
 license = "MIT"

package/skills/qingflow-cli/SKILL.md

@@ -124,6 +124,27 @@ qingflow auth login \
 qingflow --json auth whoami
 ```
 
+### 交付网页资源链接
+
+创建、修改或安装轻流资源后，最终回复主动提供主要结果的可点击页面入口，无需等待用户再次索要。采用“完成结果 + 查看入口”，文案使用“在轻流中查看应用／应用包／视图”，不默认称为“继续编辑”。
+
+默认只交付用户请求的主要结果：安装方案默认提供应用包入口；直接创建或修改应用、视图时提供对应入口；用户明确要求多个主要对象时分别提供。使用业务结果中的稳定 `uri`，按 URI 去重，不为全部子资源预签票据。主要对象没有可靠 URI 时说明限制，不猜地址，也不替换为不相关页面。
+
+CLI 返回的稳定 `uri` 以 `QINGFLOW_BASE_URL` 为当前环境来源：去除末尾 API 路径后使用同一 HTTP(S) 域名；仅当该变量为空时回退 `https://qingflow.com`。若非空配置非法，保留 URI 不可用诊断，不自行替换或拼接其他环境地址。
+
+部分成功时仅交付已确认成功且可定位的主要结果，保留失败或未验证说明。纯数据问答、中间读取、失败资源和删除操作不自动签发；用户明确要求不提供链接时遵从。用户明确要求查看或打开页面时也使用已确认的路径。
+
+目标浏览器登录态未知时，临近交付取主要结果稳定 `uri` 的完整 pathname 执行，不得丢失应用包、应用或视图层级；视图任务不得退化成应用入口：
+
+```bash
+qingflow auth login-link --redirect-path "<主要结果 uri 的完整 pathname>"
+# 自定义视图 pathname 示例：/resources/ws/<WS_ID>/app/<APP_KEY>/view/custom/<VIEW_KEY>
+```
+
+对每个实际展示的入口分别签发，使用本次返回的完整 URL，不额外追问登录态，不复用已消费链接。只有已有用户确认同一浏览器、网页域名、账号和工作区已登录、没有失效信号的事实，才直接交付稳定 `uri`。CLI 已登录、自动化浏览器已登录或曾经成功签发票据都不能证明目标浏览器已登录。
+
+用户未要求打开时不要提前打开或消费链接；签发失败时说明免登录链接未生成，并提供标注“需登录”的稳定 `uri` 作为备用入口，不重做业务操作。机器结果继续保留稳定 URI，临时登录链接仅用于面向用户交付。
+
 常用参数：`--credential-stdin`、`--password-stdin`、`--persist` / `--forget-persisted`；详见 `qingflow auth --help`。
 
 ---
@@ -439,7 +460,7 @@ qingflow auth logout --forget-persisted
 
 | 分组 | 骨架（细则见上文章节 + 「关联文件」） |
 | ---- | ------------------------------------ |
-| **auth** | `auth whoami` · `auth use-credential --base-url "$QINGFLOW_BASE_URL" --credential-stdin --persist` · `auth login …`（见「失败恢复时的认证方式」）· `auth logout --forget-persisted` |
+| **auth** | `auth whoami` · `auth use-credential --base-url "$QINGFLOW_BASE_URL" --credential-stdin --persist` · `auth login …`（见「失败恢复时的认证方式」）· `auth login-link [--redirect-path PATH]`（临时网页登录链接）· `auth logout --forget-persisted` |
 | **workspace** | `workspace list` · `workspace get --ws-id` · `workspace select`（慎用，可读数前不必；可能 **59004**） |
 | **app / portal / view / chart** | `app list [--query 关键词]` → **`app get --app-key`**（`accessible_views` / `view_id`、`import_capability`）· `builder package list [--query 关键词]` → `builder package get --package-id` · `portal list` · `portal get --dash-key` · `view get --view-id`（只读视图元信息；`baseInfo` 或 `viewConfig` 只有 40002 / 40027 / 404 这类权限/缺失边界可用另一侧降级，非权限类后端错误不隐藏；解析 app 仅依赖同源 view/form 与可见应用树，不回退旧应用搜索）· `chart get --chart-id`（图表 `baseInfo` / 数据 / 配置分阶段读取；单个辅助阶段 40002 / 40027 / 404 只作为 warning，非权限类后端错误不隐藏） |
 | **record** | `record schema insert`（新建记录 insert-ready schema，仅 `--app-key`）· **`browse`/`list`/`access`：`--app-key` + `--view-id`（缺一常 CONFIG）** · `record list --query ... [--query-field FIELD_ID] [--page-size N]` 用于候选定位/样本浏览 · `record get --record-id` 读详情页首屏上下文 · `record logs --record-id` 读完整数据/流程日志 JSONL · `record insert --items-file`（单条也是 items 一行）· `schema update --record-id [--view-id]` / **`update`**（单条 `--fields-file` **或** 批量 `--items-file`/`--dry-run`，二者勿混）· `record delete --app-key --record-id --view-id system:*` / `--record-ids-file` · `export start/direct --view-id` 仅用于明确导出文件 · **大 schema**：先 **[FIELD_DATA_TYPES](./reference/core/QINGFLOW_CLI_FIELD_DATA_TYPES.md)** / **[RECORD_CREATE](./reference/record/QINGFLOW_CLI_RECORD_CREATE_WORKFLOW.md)** / **[RECORD_UPDATE](./reference/record/QINGFLOW_CLI_RECORD_UPDATE_WORKFLOW.md)** / **[RECORD_DELETE](./reference/record/QINGFLOW_CLI_RECORD_DELETE_WORKFLOW.md)**，再 `-h` |
@@ -447,6 +468,21 @@ qingflow auth logout --forget-persisted
 | **builder** | **搭建／系统化配置**：先按 **[INDEX](./reference/00-INDEX.md)** / **[BUILDER](./reference/builder/README.md)** 选主路径，再读 `builder contract`。**完整系统/应用包**：`builder package apply --config-file` → 每个应用依次执行 `builder app-form schema`、更新时 `get --app-key APP_KEY --being-draft`、`validate --schema-version VERSION --file DECLARATION.json`、`apply --file DECLARATION.json`（固定版本、完整声明、记录返回的 `appKey`）→ 视图（按钮随视图 `action_buttons` 写）→ 门户（缺报表时写 `chart`）→ 发布/回读。旧 `schema apply` / `layout apply` 不在当前 CLI parser 中。超时、`partial_success`、`write_executed=true`、`safe_to_retry=false` 或回读不完整时先读取 AppForm draft/published，再恢复，不得重复创建或创建 V2/测试/随机后缀绕过重名。**单应用**：新建和更新遵循同一 AppForm CLI 链路，再按需求配置流程/视图。更新动作归入对应资源文档：AppForm [30](./reference/builder/30-schema-fields.md)、视图 [50](./reference/builder/50-views.md)、报表 [60](./reference/builder/60-charts.md)、门户 [70](./reference/builder/70-portal.md)、关联资源/非主链路按钮维护 [80](./reference/builder/80-buttons-associated-resources.md)、流程 [90](./reference/builder/90-workflow.md)、发布 [99](./reference/builder/99-publish-verify.md)。**AI 公式/代码块校验**：`builder app-form validate-formula --app-key KEY --formula '<公式>' --test-case <文件路径>`（`--formula` 内联；`--test-case` **只收文件路径或 `-` stdin，不收内联 JSON**）与 `builder app-form validate-code-block --app-key KEY --code <内联文本|@文件路径> --test-case <文件路径>`（本地静态 + 后端真跑，输出 `staticErrors` / `runResult` / `runError`）；两者是公式/代码块生成场景的真实校验命令，校验结论必须来自其真实执行，不得以本地模拟替代。代码内占位符 `qf_field.{字段名$$queId$$}`（**字段名不带引号**，带引号会被 CLI 自动剥离但勿依赖）与 `keyQueId` 均使用**十进制** queId（CLI 真跑前自动编码为运行时形态；错误回显自动还原为十进制，勿逆向编码 id）。test-case values 按类型：文本/电话=字符串、数字=数字字面量、日期=yyyy-MM-dd、附件=URL 字符串数组、单选/下拉/多选=选项文案（CLI 自动译为选项 id）、成员/部门=不可提供（代码判空,覆盖校验豁免）。 |
 | **task**（须落盘见上文） | `task list [--task-box][--flow-status][--app-key][--query] --page --page-size`（**枚举、`--query`、与 `record` 视图口径勿混**：见上文 SOP · **[TASK_CONTEXT](./reference/task/QINGFLOW_CLI_TASK_CONTEXT_WORKFLOW.md)**）· **`get`/`log`/`report`/`action`**：默认只传 `task list` 返回的 **`data.items[].task_id`**；`report` 另须必选 **`--report-id`**；`action` **无 `--dry-run`** |
 
+### 临时网页登录链接
+
+按上文“交付网页资源链接”规则，在创建、修改或安装完成后主动为主要结果提供查看入口；用户明确要求进入页面时也适用，纯数据问答不自动调用：
+
+```bash
+qingflow --json auth login-link
+qingflow --profile default --json auth login-link --redirect-path "<主要结果 uri 的完整 pathname>"
+# 自定义视图 pathname 示例：/resources/ws/<WS_ID>/app/<APP_KEY>/view/custom/<VIEW_KEY>
+```
+
+- 默认使用当前会话和已选工作区；缺失时按实际错误恢复，不额外预查或重新登录。pathname 必须保留主要对象的完整层级，视图任务不得改用应用 pathname。
+- `--redirect-path` 可选，仅接受已确认的站内业务路径，可包含 query/hash；不接受外域或认证入口。示例 ID 仅作格式展示，不得照抄或编造实际目标；省略时进入工作区首页。
+- 将返回的 `url` 作为可点击链接交付，不修改或拼造。链接短时有效且仅可使用一次，失效后重新获取，不写入公共文档或日志。
+- 命令不会自动打开浏览器；用户未要求打开时不提前打开或消费链接，明确要求打开时才调用浏览器。
+
 **高发必败**：旧应用搜索入口 · **`record list`/`browse`/`access` 缺 `--view-id`** · **`task report` 缺 `--report-id`** · **`record update` 批量与单条参数混用**。
 
 更多成员策略：**[reference/QINGFLOW_CLI_MEMBER_CHEATSHEET.md](./reference/core/QINGFLOW_CLI_MEMBER_CHEATSHEET.md)** · 一次性长模板：**[reference/QINGFLOW_CLI_ONE_SHOT_CHEATSHEET.md](./reference/core/QINGFLOW_CLI_ONE_SHOT_CHEATSHEET.md)** · 对齐说明：**[reference/QINGFLOW_CLI_EXPLORATION_REPORT.md](./reference/core/QINGFLOW_CLI_EXPLORATION_REPORT.md)**。

package/skills/qingflow-common/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: qingflow-common
-description: Route Qingflow work through the shared public concepts and choose the matching CLI or MCP package. Use when comparing Qingflow CLI and MCP capabilities, selecting an execution surface, or handing work between record, task, form, workflow, and builder skills.
+description: Explain shared Qingflow concepts, choose the CLI or MCP surface, and route resource work or page-link delivery to the relevant domain Skill.
 ---
 
 # Qingflow Common Concepts
@@ -31,6 +31,7 @@ Do not require both surfaces. If only one is installed, complete the workflow on
 | Form schema/read/apply/delete | `qingflow --json builder app-form ...` / `builder app delete` | `app_form_schema`, `app_form_get`, `app_form_apply`, `app_delete` |
 | AppForm static validation | `qingflow --json builder app-form validate --file ...` | Performed inside `app_form_apply`; no separate tool |
 | Record and task work | `qingflow --json record ...` / `task ...` | Qingflow MCP record and task tools |
+| Open a workspace or confirmed business page | `qingflow --json auth login-link [--redirect-path PATH]` | `get_login_link` |
 | Package, view, portal, chart, workflow | `qingflow --json builder ...` | Qingflow MCP configuration tools |
 
 The operation names and payload schemas are defined by the public surface. Use the current Schema or tool input schema as the source of truth, not a legacy command name or backend payload.
@@ -42,6 +43,11 @@ The operation names and payload schemas are defined by the public surface. Use t
 
 Each package includes this common Skill. The CLI package installs its CLI guidance; the MCP package installs every MCP domain Skill. The source of every packaged Skill is `qingflow-support/mcp-server/skills/`.
 
+## Deliver Qingflow Page Links
+
+- After creating, changing, or installing resources, finish with the result and a clickable entry for each requested primary result. Use confirmed stable `uri` values, deduplicate them, and link only confirmed successes. Do not auto-issue links for data-only answers, intermediate reads, failed or deleted resources, or when the user declines links.
+- When browser login is unknown, issue one fresh link per displayed destination near delivery through the installed surface. Never guess, replace, open, or consume a destination unless authorized. If issuance fails, keep the business result and offer the stable URI as requiring login when available. Follow the CLI Skill or MCP tool description for signing details.
+
 ## Route Next
 
 Use the installed package's relevant domain Skill. In the unified MCP package, select the Skill by the requested work, not by an assumed user or builder server role. Do not link to or invoke a domain Skill that the current package did not install.

package/src/qingflow_mcp/builder_facade/service.py

@@ -19,6 +19,7 @@ from ..backend_client import BackendRequestContext
 from ..errors import QingflowApiError, backend_code_int, backend_code_value_int, is_auth_like_error
 from ..json_types import JSONObject
 from ..list_type_labels import RECORD_LIST_TYPE_LABELS, SYSTEM_VIEW_ID_TO_LIST_TYPE
+from ..resource_uri import validate_positive_resource_id, validate_resource_identity
 from ..solution.build_assembly_store import BuildAssemblyStore, default_artifacts, default_manifest
 from ..solution.compiler.chart_compiler import qingbi_workspace_visible_auth
 from ..solution.compiler.form_compiler import build_question, default_form_payload, default_member_auth
@@ -1491,6 +1492,74 @@ class AiBuilderFacade:
                 details={"solution_key": requested_solution_key},
                 suggested_next_call={"tool_name": "solution_install", "arguments": {"profile": profile, **normalized_args}},
             )
+        raw_result = created.get("result") if isinstance(created.get("result"), dict) else {}
+        raw_tag_ids = raw_result.get("tagIds")
+        raw_app_keys = raw_result.get("appKeys")
+        tag_ids, tag_ids_complete = _unique_resource_tag_ids(raw_tag_ids)
+        app_keys, app_keys_complete = _unique_resource_app_keys(raw_app_keys)
+        resource_list_complete = tag_ids_complete and app_keys_complete
+        resources: list[JSONObject] = []
+        warnings: list[JSONObject] = []
+
+        for tag_id in tag_ids:
+            name = None
+            try:
+                detail = self.packages.package_get(profile=profile, tag_id=tag_id, include_raw=False)
+                package = detail.get("result") if isinstance(detail.get("result"), dict) else {}
+                name = str(package.get("tagName") or package.get("tag_name") or "").strip() or None
+            except (QingflowApiError, RuntimeError):
+                pass
+            if not name:
+                warnings.append(_warning("RESOURCE_NAME_UNAVAILABLE", "installed package name could not be read", package_id=tag_id))
+            resources.append(
+                _compact_dict(
+                    {
+                        "resource_type": "package",
+                        "operation": "installed",
+                        "status": "success",
+                        "id": tag_id,
+                        "key": str(tag_id),
+                        "name": name,
+                        "ids": {"package_id": tag_id},
+                    }
+                )
+            )
+
+        for app_key in app_keys:
+            name = None
+            parent = None
+            try:
+                detail = self.apps.app_get_base(profile=profile, app_key=app_key, include_raw=False)
+                app = detail.get("result") if isinstance(detail.get("result"), dict) else {}
+                name = str(app.get("formTitle") or app.get("appName") or "").strip() or None
+                matching_tag_ids = [tag_id for tag_id in _unique_positive_ints(app.get("tagIds")) if tag_id in tag_ids]
+                if len(matching_tag_ids) == 1:
+                    parent = {"resource_type": "package", "id": matching_tag_ids[0], "key": str(matching_tag_ids[0])}
+            except (QingflowApiError, RuntimeError):
+                pass
+            if not name:
+                warnings.append(_warning("RESOURCE_NAME_UNAVAILABLE", "installed application name could not be read", app_key=app_key))
+            resources.append(
+                _compact_dict(
+                    {
+                        "resource_type": "app",
+                        "operation": "installed",
+                        "status": "success",
+                        "key": app_key,
+                        "name": name,
+                        "ids": {"app_key": app_key},
+                        "parent": parent,
+                    }
+                )
+            )
+
+        if not resource_list_complete:
+            warnings.append(
+                _warning(
+                    "RESOURCE_LIST_INCOMPLETE",
+                    "solution installation succeeded, but its returned package/application identity list was incomplete",
+                )
+            )
         return {
             "status": "success",
             "error_code": None,
@@ -1503,9 +1572,15 @@ class AiBuilderFacade:
             "request_id": created.get("request_id"),
             "suggested_next_call": None,
             "noop": False,
-            "verification": {},
+            "warnings": warnings,
+            "verified": False,
+            "verification": {
+                "resource_list_complete": resource_list_complete,
+                "business_verified": False,
+            },
             "write_executed": True,
             "safe_to_retry": False,
+            "resources": resources,
         }
 
     def package_list(self, *, profile: str, trial_status: str = "all", query: str = "") -> JSONObject:
@@ -17148,6 +17223,49 @@ def _coerce_positive_int(value: Any) -> int | None:
     return None
 
 
+def _unique_positive_ints(value: Any) -> list[int]:
+    if not isinstance(value, list):
+        return []
+    result: list[int] = []
+    for item in value:
+        number = _coerce_positive_int(item)
+        if number is not None and number not in result:
+            result.append(number)
+    return result
+
+
+def _unique_resource_tag_ids(value: Any) -> tuple[list[int], bool]:
+    if not isinstance(value, list):
+        return [], False
+    result: list[int] = []
+    complete = True
+    for item in value:
+        try:
+            tag_id = validate_positive_resource_id(item, "package_id")
+        except (ValueError, UnicodeError):
+            complete = False
+            continue
+        if tag_id not in result:
+            result.append(tag_id)
+    return result, complete
+
+
+def _unique_resource_app_keys(value: Any) -> tuple[list[str], bool]:
+    if not isinstance(value, list):
+        return [], False
+    result: list[str] = []
+    complete = True
+    for item in value:
+        try:
+            app_key = validate_resource_identity(item, "app_key")
+        except (ValueError, UnicodeError):
+            complete = False
+            continue
+        if app_key not in result:
+            result.append(app_key)
+    return result, complete
+
+
 def _coerce_nonnegative_int(value: Any) -> int | None:
     if isinstance(value, bool) or value is None:
         return None

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

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import argparse
 
-from . import app, auth, builder, chart, exports, imports, portal, record, task, view, workspace
+from . import app, auth, builder, chart, data, exports, imports, portal, record, task, view, workspace
 
 
 def register_all_commands(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
@@ -13,6 +13,7 @@ def register_all_commands(subparsers: argparse._SubParsersAction[argparse.Argume
     view.register(subparsers)
     chart.register(subparsers)
     record.register(subparsers)
+    data.register(subparsers)
     imports.register(subparsers)
     exports.register(subparsers)
     task.register(subparsers)

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

@@ -40,11 +40,19 @@ def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) ->
     whoami = auth_subparsers.add_parser("whoami", help="查看当前登录态")
     whoami.set_defaults(handler=_handle_whoami, format_hint="auth_whoami")
 
+    login_link = auth_subparsers.add_parser("login-link", help="生成当前工作区的临时一次性登录链接（不自动打开）")
+    login_link.add_argument("--redirect-path", default="", help="登录后跳转的站内路径；资源路径必须属于当前工作区，其他业务路径可包含查询参数和锚点")
+    login_link.set_defaults(handler=_handle_login_link, format_hint="login_link")
+
     logout = auth_subparsers.add_parser("logout", help="退出登录")
     logout.add_argument("--forget-persisted", action="store_true")
     logout.set_defaults(handler=_handle_logout, format_hint="")
 
 
+def _handle_login_link(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.login_link.get_login_link(profile=args.profile, redirect_path=args.redirect_path)
+
+
 def _handle_login(args: argparse.Namespace, context: CliContext) -> dict:
     if args.method == "oauth":
         return _handle_oauth_login(args, context)

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

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+import argparse
+import textwrap
+
+from ..context import CliContext
+from .common import load_list_arg, require_list_arg, require_object_arg, raise_config_error
+
+
+def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    parser = subparsers.add_parser(
+        "data",
+        help="视图无关的应用数据面",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=textwrap.dedent("""
+            JSON 文件约定：
+              columns.json  [101, 102]
+              where.json    [{"field_id": 101, "op": "eq", "value": "A"}]
+              sort.json     [{"field_id": 101, "direction": "asc"}]
+              items.json    [{"fields": {"101": "A"}}]
+              fields.json   {"101": "B"}
+            query/get/insert/update 默认返回 field_capabilities；可用 --no-schema 关闭。
+        """).strip(),
+    )
+    commands = parser.add_subparsers(dest="data_command", required=True, metavar="{query,get,insert,update,delete}")
+
+    query = commands.add_parser(
+        "query", help="分页查询应用数据", formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog='最小示例：qingflow data query --app-key APP_1 --where-file where.json\n'
+               'where.json: [{"field_id": 101, "op": "eq", "value": "A"}]',
+    )
+    query.add_argument("--app-key", required=True)
+    query.add_argument("--columns-file", help='JSON 数组，例如 [101, 102]')
+    query.add_argument(
+        "--where-file",
+        help='JSON 数组；项为 {"field_id":101,"op":"eq","value":"A"}，in/not_in 的 value 必须为数组',
+    )
+    query.add_argument("--sort-file", help='JSON 数组，例如 [{"field_id":101,"direction":"asc"}]')
+    query.add_argument("--search", default="")
+    query.add_argument("--page", type=int, default=1)
+    query.add_argument("--page-size", type=int, default=100)
+    query.add_argument("--no-schema", action="store_false", dest="include_schema", default=True)
+    query.add_argument("--all", action="store_true", dest="all_pages")
+    query.add_argument("--output", choices=("json", "csv"), default="json")
+    query.set_defaults(handler=_handle_query, format_hint="data_query")
+
+    get = commands.add_parser("get", help="读取单条应用数据")
+    get.add_argument("--app-key", required=True)
+    get.add_argument("--record-id", required=True)
+    get.add_argument("--no-schema", action="store_false", dest="include_schema", default=True)
+    get.set_defaults(handler=_handle_get, format_hint="data_get")
+
+    insert = commands.add_parser(
+        "insert", help="新增应用数据", formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog='最小示例：items.json = [{"fields": {"101": "A"}}]',
+    )
+    insert.add_argument("--app-key", required=True)
+    insert.add_argument("--items-file", required=True, help='JSON 数组，项为 {"fields":{"字段ID":值}}')
+    insert.add_argument("--no-schema", action="store_false", dest="include_schema", default=True)
+    insert.set_defaults(handler=_handle_insert, format_hint="data_insert")
+
+    update = commands.add_parser(
+        "update", help="更新应用数据", formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog='最小示例：fields.json = {"101": "B"}',
+    )
+    update.add_argument("--app-key", required=True)
+    update.add_argument("--record-id", required=True)
+    update.add_argument("--fields-file", required=True, help='JSON 对象，键为字符串形式 field_id')
+    update.add_argument("--no-schema", action="store_false", dest="include_schema", default=True)
+    update.set_defaults(handler=_handle_update, format_hint="data_update")
+
+    delete = commands.add_parser("delete", help="删除应用数据")
+    delete.add_argument("--app-key", required=True)
+    delete.add_argument(
+        "--record-ids", action="append", default=[], metavar="ID[,ID...]",
+        help="待删除记录 ID；支持逗号分隔，也可重复传入",
+    )
+    delete.add_argument("--record-ids-file", help="附加的记录 ID JSON 数组文件")
+    delete.set_defaults(handler=_handle_delete, format_hint="data_delete")
+
+
+def _handle_query(args: argparse.Namespace, context: CliContext) -> dict:
+    if args.all_pages != (args.output == "csv"):
+        raise_config_error(
+            "--all 与 --output csv 必须同时使用。",
+            fix_hint="使用 `qingflow data query ... --all --output csv`，普通分页查询不要传这两个参数。",
+        )
+    return context.data.data_query(
+        profile=args.profile,
+        app_key=args.app_key,
+        columns=load_list_arg(args.columns_file, option_name="--columns-file"),
+        where=load_list_arg(args.where_file, option_name="--where-file"),
+        sort=load_list_arg(args.sort_file, option_name="--sort-file"),
+        search=args.search,
+        page=args.page,
+        page_size=args.page_size,
+        include_schema=args.include_schema,
+        all_pages=args.all_pages,
+        output=args.output,
+    )
+
+
+def _handle_get(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.data.data_get(
+        profile=args.profile, app_key=args.app_key, record_id=args.record_id, include_schema=args.include_schema
+    )
+
+
+def _handle_insert(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.data.data_insert(
+        profile=args.profile, app_key=args.app_key,
+        items=require_list_arg(args.items_file, option_name="--items-file"), include_schema=args.include_schema,
+    )
+
+
+def _handle_update(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.data.data_update(
+        profile=args.profile, app_key=args.app_key, record_id=args.record_id,
+        fields=require_object_arg(args.fields_file, option_name="--fields-file"), include_schema=args.include_schema,
+    )
+
+
+def _handle_delete(args: argparse.Namespace, context: CliContext) -> dict:
+    record_ids = [item.strip() for group in args.record_ids for item in group.split(",") if item.strip()]
+    record_ids.extend(load_list_arg(args.record_ids_file, option_name="--record-ids-file"))
+    if not record_ids:
+        raise_config_error(
+            "至少传入一个记录 ID。",
+            fix_hint="使用 `--record-ids ID[,ID...]`；也可附加 `--record-ids-file ids.json`。",
+        )
+    return context.data.data_delete(
+        profile=args.profile, app_key=args.app_key,
+        record_ids=record_ids,
+    )

package/src/qingflow_mcp/cli/context.py

@@ -11,10 +11,12 @@ from ..tools.ai_builder_tools import AiBuilderTools
 from ..tools.app_tools import AppTools
 from ..tools.auth_tools import AuthTools
 from ..tools.code_block_tools import CodeBlockTools
+from ..tools.data_tools import DataTools
 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,10 +29,12 @@ class CliContext:
     sessions: CliSessionFacade
     backend: BackendClient
     auth: AuthTools
+    login_link: LoginLinkTools
     workspace: WorkspaceTools
     app: AppTools
     resource: ResourceReadTools
     record: RecordTools
+    data: DataTools
     code_block: CodeBlockTools
     imports: ImportTools
     exports: ExportTools
@@ -57,10 +61,12 @@ 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),
         record=RecordTools(sessions, backend),
+        data=DataTools(sessions, backend),
         code_block=CodeBlockTools(sessions, backend),
         imports=ImportTools(sessions, backend),
         exports=ExportTools(sessions, backend),