openyida 2026.6.1-beta.0 → 2026.6.3-beta.0

package/lib/app/import-app.js

@@ -139,16 +139,28 @@ async function updateFormConfig(appType, formUuid, authRef) {
   return result;
 }
 
-// ── 适配 SerialNumberField formula ───────────────────
+// ── 适配 Schema 中的应用 / 表单标识符 ─────────────────
 //
-// 将 Schema 中所有 SerialNumberField 的 formula 里的旧 appType 替换为新 appType，
-// 同时将旧 formUuid 替换为新 formUuid。
+// 导入时需要把 Schema 里所有对旧 appType / formUuid 的引用（页面 id、组件
+// props.appType、actions.source、SerialNumberField 公式等）重映射为新值。
+//
+// 早期实现对整个 Schema JSON 做无约束的全局字符串替换，存在数据腐蚀风险：
+// 若某个字段的文本值、label、备注恰好包含旧 appType / formUuid 子串，会被
+// 误替换。这里改为「标识符边界」约束替换——appType / formUuid 都是由字母、
+// 数字、下划线、连字符构成的标识符，只有当匹配片段两侧不是同类标识符字符时
+// 才替换，从而避免误伤包含旧标识符子串的普通文本。
+
+function buildIdentifierBoundaryRegExp(identifier) {
+  // 标识符字符集：字母、数字、下划线、连字符。
+  // 使用 lookbehind / lookahead 保证匹配片段不是更长标识符的一部分。
+  return new RegExp(`(?<![A-Za-z0-9_-])${escapeRegExp(identifier)}(?![A-Za-z0-9_-])`, 'g');
+}
 
-function adaptSerialNumberFormulas(schema, oldAppType, newAppType, oldFormUuid, newFormUuid) {
+function adaptSchemaIdentifiers(schema, oldAppType, newAppType, oldFormUuid, newFormUuid) {
   const schemaStr = JSON.stringify(schema);
   const adapted = schemaStr
-    .replace(new RegExp(escapeRegExp(oldAppType), 'g'), newAppType)
-    .replace(new RegExp(escapeRegExp(oldFormUuid), 'g'), newFormUuid);
+    .replace(buildIdentifierBoundaryRegExp(oldAppType), newAppType)
+    .replace(buildIdentifierBoundaryRegExp(oldFormUuid), newFormUuid);
   return JSON.parse(adapted);
 }
 
@@ -287,8 +299,8 @@ async function run(args) {
       continue;
     }
 
-    // 将 Schema 中所有旧 appType / formUuid 替换为新值
-    const adaptedSchema = adaptSerialNumberFormulas(
+    // 将 Schema 中所有旧 appType / formUuid 引用重映射为新值（标识符边界约束，避免误伤普通文本）
+    const adaptedSchema = adaptSchemaIdentifiers(
       originalSchema,
       sourceAppType,
       newAppType,
@@ -377,7 +389,7 @@ module.exports = {
   __test__: {
     normalizeImportFormType,
     buildCreateFormPostData,
-    adaptSerialNumberFormulas,
+    adaptSchemaIdentifiers,
     extractSchemaContent,
   },
 };

package/lib/connector/action-generator.js

@@ -2,6 +2,42 @@
  * 执行动作配置生成模块
  */
 
+// 可能携带凭证 / 敏感信息的请求头（小写匹配）。
+// 这些头的真实值绝不能写入生成的 Action 配置，否则会把用户 token 泄漏到
+// 落盘的连接器配置里。命中时用占位符替换，提示用户在连接器认证中配置。
+const SENSITIVE_HEADER_PATTERNS = [
+  'authorization',
+  'cookie',
+  'token',
+  'api-key',
+  'apikey',
+  'secret',
+  'access-token',
+  'x-acs-dingtalk-access-token',
+  'x-api-key',
+  'proxy-authorization',
+];
+
+function isSensitiveHeader(headerName) {
+  const lower = String(headerName || '').toLowerCase();
+  return SENSITIVE_HEADER_PATTERNS.some((pattern) => lower.includes(pattern));
+}
+
+/**
+ * 计算请求头写入 Action 配置的默认值。
+ * 敏感头返回占位符（不泄漏真实凭证），普通头截断展示前 50 字符。
+ * @param {string} headerName - 请求头名称
+ * @param {string} headerValue - 请求头原始值
+ * @returns {string} 可安全写入配置的默认值
+ */
+function buildHeaderDefaultValue(headerName, headerValue) {
+  if (isSensitiveHeader(headerName)) {
+    return '';
+  }
+  const value = String(headerValue === null || headerValue === undefined ? '' : headerValue);
+  return value.length > 50 ? value.substring(0, 50) + '...' : value;
+}
+
 /**
  * 根据URL路径生成有意义的动作名称和描述
  * @param {string} path - URL路径
@@ -125,7 +161,7 @@ function generateOperation(curlData, relevantHeaders) {
       paramType: 'String',
       desc: key,
       required: false,
-      defaultValue: value.substring(0, 50) + (value.length > 50 ? '...' : ''),
+      defaultValue: buildHeaderDefaultValue(key, value),
       children: [],
       childList: [],
       __level: 0,
@@ -262,5 +298,7 @@ function generateOperation(curlData, relevantHeaders) {
 
 module.exports = {
   generateActionInfo,
-  generateOperation
+  generateOperation,
+  isSensitiveHeader,
+  buildHeaderDefaultValue
 };

package/lib/connector/api.js

@@ -60,7 +60,13 @@ function printTable(headers, rows) {
 function buildOperationsSummary(operations) {
   if (!Array.isArray(operations) || operations.length === 0) {return '';}
 
-  const summaries = operations.map(op => op.summary || op.operationId);
+  const summaries = operations
+    .map(op => op.summary || op.name || op.operationId || op.id || op.url || op.path)
+    .filter(Boolean);
+
+  if (summaries.length === 0) {
+    return '';
+  }
 
   if (summaries.length === 1) {
     return `支持${summaries[0]}`;

package/lib/connector/connector-add-action.js

@@ -23,6 +23,7 @@ const {
   getConnectorDetail,
   saveConnector,
 } = require('./api');
+const { normalizeOperations } = require('./operation-normalizer');
 
 function showUsage() {
   console.log(`
@@ -99,6 +100,7 @@ async function run(args) {
     if (!Array.isArray(newOperations)) {
       newOperations = [newOperations];
     }
+    newOperations = normalizeOperations(newOperations);
     console.log(`✓ 已加载 ${newOperations.length} 个执行动作`);
     newOperations.forEach((operation, index) => {
       console.log(`  [${index + 1}] ${operation.operationId}: ${operation.summary}`);
@@ -123,7 +125,7 @@ async function run(args) {
     const detail = await getConnectorDetail(connector.connectorName, authRef);
     targetConnector = { ...connector, detail };
 
-    const existingOps = JSON.parse(targetConnector.detail.operations || '[]');
+    const existingOps = normalizeOperations(JSON.parse(targetConnector.detail.operations || '[]'));
     console.log('📋 即将追加到以下连接器:');
     console.log(`   名称: ${targetConnector.displayName}`);
     console.log(`   ID: ${targetConnector.id}`);
@@ -164,7 +166,7 @@ async function run(args) {
   }
 
   // 合并执行动作
-  const existingOperations = JSON.parse(targetConnector.detail.operations || '[]');
+  const existingOperations = normalizeOperations(JSON.parse(targetConnector.detail.operations || '[]'));
   const existingIds = new Set(existingOperations.map(op => op.operationId));
   const duplicates = newOperations.filter(op => existingIds.has(op.operationId));
 

package/lib/connector/connector-create.js

@@ -31,6 +31,7 @@ const {
   getConnectorDetail,
   saveConnector,
 } = require('./api');
+const { normalizeOperations } = require('./operation-normalizer');
 
 function showUsage() {
   console.log(`
@@ -232,11 +233,11 @@ async function run(args) {
     console.log(`当前描述: ${connector.connectorDesc || '(空)'}\n`);
 
     const detail = await getConnectorDetail(connector.connectorName, authRef);
-    const currentOperations = JSON.parse(detail.operations || '[]');
+    const currentOperations = normalizeOperations(JSON.parse(detail.operations || '[]'));
     const newDesc = buildConnectorDesc(options.description, connector.connectorDesc, authRef, currentOperations);
 
     await saveConnector({
-      operations: detail.operations || '[]',
+      operations: JSON.stringify(currentOperations),
       displayName: detail.displayName,
       iconUrl: detail.iconUrl || 'chaxun%%#FFA200',
       connectorDesc: newDesc,
@@ -278,6 +279,7 @@ async function run(args) {
       fail('错误: operations 文件不能为空数组');
       process.exit(1);
     }
+    operations = normalizeOperations(operations);
     console.log(`✓ 已加载 ${operations.length} 个执行动作`);
   } catch (e) {
     fail(`读取执行动作配置文件失败: ${e.message}`);

package/lib/connector/connector-delete-action.js

@@ -17,6 +17,7 @@ const {
   getConnectorDetail,
   saveConnector,
 } = require('./api');
+const { normalizeOperations } = require('./operation-normalizer');
 
 function showUsage() {
   console.log(`
@@ -63,7 +64,7 @@ async function run(args) {
   }
 
   const detail = await getConnectorDetail(connector.connectorName, authRef);
-  const currentOperations = JSON.parse(detail.operations || '[]');
+  const currentOperations = normalizeOperations(JSON.parse(detail.operations || '[]'));
   const targetOperation = currentOperations.find(op => op.operationId === operationId);
 
   if (!targetOperation) {

package/lib/connector/curl-parser.js

@@ -2,6 +2,36 @@
  * Curl 命令解析模块
  */
 
+/**
+ * 从 curl 命令中提取 URL。
+ * 早期实现只匹配 `curl "<url>"`（必须带引号且紧跟 curl），导致裸 URL、
+ * 单引号、`--url` 参数、`-X POST` 在 URL 之前等常见写法全部解析失败。
+ * 这里按优先级多策略提取：
+ *   1. 显式 `--url <url>` 参数
+ *   2. 命令中任意带引号的 http(s) URL
+ *   3. 命令中任意裸 http(s) URL（截断到空白处）
+ * @param {string} curlCommand - curl 命令字符串
+ * @returns {string} 提取到的 URL，未找到返回空字符串
+ */
+function extractCurlUrl(curlCommand) {
+  const explicitUrl = curlCommand.match(/--url\s+['"]?([^'"\s]+)['"]?/);
+  if (explicitUrl) {
+    return explicitUrl[1];
+  }
+
+  const quotedUrl = curlCommand.match(/['"](https?:\/\/[^'"]+)['"]/);
+  if (quotedUrl) {
+    return quotedUrl[1];
+  }
+
+  const bareUrl = curlCommand.match(/(https?:\/\/[^\s'"]+)/);
+  if (bareUrl) {
+    return bareUrl[1];
+  }
+
+  return '';
+}
+
 /**
  * 解析 curl 命令
  * @param {string} curlCommand - curl 命令字符串
@@ -19,10 +49,9 @@ function parseCurl(curlCommand) {
   };
 
   try {
-    // 提取 URL
-    const urlMatch = curlCommand.match(/curl\s+['"]([^'"]+)['"]/);
-    if (urlMatch) {
-      result.url = urlMatch[1];
+    // 提取 URL：兼容带引号 URL、裸 URL、--url 参数、-X POST 在前等多种写法
+    result.url = extractCurlUrl(curlCommand);
+    if (result.url) {
       const url = new URL(result.url);
       result.protocol = url.protocol.replace(':', '');
       result.host = url.hostname;
@@ -30,10 +59,10 @@ function parseCurl(curlCommand) {
     }
 
     // 提取方法
-    const methodMatch = curlCommand.match(/-X\s+(\w+)/);
+    const methodMatch = curlCommand.match(/(?:-X|--request)\s+['"]?(\w+)['"]?/);
     if (methodMatch) {
       result.method = methodMatch[1].toUpperCase();
-    } else if (curlCommand.includes('--data') || curlCommand.includes('-d')) {
+    } else if (curlCommand.includes('--data') || /\s-d\b/.test(curlCommand)) {
       result.method = 'POST';
     }
 
@@ -64,10 +93,11 @@ function detectAuthType(headers) {
   const authHeader = headers['Authorization'] || headers['authorization'];
 
   if (authHeader) {
-    if (authHeader.startsWith('Bearer')) {
+    const scheme = authHeader.trim().toLowerCase();
+    if (scheme.startsWith('bearer')) {
       return { type: 'API密钥', code: 'ApiKeyAuth', headerName: 'Authorization' };
     }
-    if (authHeader.startsWith('Basic')) {
+    if (scheme.startsWith('basic')) {
       return { type: '基本身份验证', code: 'BasicAuth', headerName: 'Authorization' };
     }
   }
@@ -116,6 +146,7 @@ function filterBrowserHeaders(headers) {
 
 module.exports = {
   parseCurl,
+  extractCurlUrl,
   detectAuthType,
   filterBrowserHeaders,
   BROWSER_HEADERS

package/lib/connector/doc-parser.js

@@ -104,21 +104,22 @@ class MarkdownParser extends BaseDocParser {
   }
 
   parseRequestHeaders() {
-    const headerSection = this.extractSection('请求头', '请求参数');
+    const headerSection = this.extractSection('请求头', ['查询参数', '请求参数', '请求体', '响应']);
     if (headerSection) {
       this.result.requestInfo.headers = this.parseTable(headerSection);
     }
   }
 
   parseQueryParams() {
-    const querySection = this.extractSection('查询参数', '请求体');
+    const querySection = this.extractSection('查询参数', ['请求体', '响应', '错误码']) ||
+      this.extractSection('请求参数', ['请求体', '响应', '错误码']);
     if (querySection) {
       this.result.requestInfo.query = this.parseTable(querySection);
     }
   }
 
   parseRequestBody() {
-    const bodySection = this.extractSection('请求体', '响应');
+    const bodySection = this.extractSection('请求体', ['响应', '返回', '错误码']);
     if (!bodySection) {return;}
 
     const jsonMatch = bodySection.match(/```json\s*([\s\S]*?)```/);
@@ -289,10 +290,13 @@ class MarkdownParser extends BaseDocParser {
 
     let endIndex = this.content.length;
     if (endMarker) {
-      const endMatch = this.content.indexOf(endMarker, startIndex + startMarker.length);
-      if (endMatch !== -1) {
-        endIndex = endMatch;
-      }
+      const markers = Array.isArray(endMarker) ? endMarker : [endMarker];
+      markers.forEach(marker => {
+        const endMatch = this.content.indexOf(marker, startIndex + startMarker.length);
+        if (endMatch !== -1 && endMatch < endIndex) {
+          endIndex = endMatch;
+        }
+      });
     }
 
     return this.content.substring(startIndex, endIndex);
@@ -343,6 +347,15 @@ class MarkdownParser extends BaseDocParser {
   }
 }
 
+function applyParamLocation(nodes, paramLocation) {
+  (Array.isArray(nodes) ? nodes : []).forEach(node => {
+    node.paramLocation = paramLocation;
+    applyParamLocation(node.childList, paramLocation);
+    applyParamLocation(node.children, paramLocation);
+  });
+  return nodes;
+}
+
 /**
  * 文档解析器工厂
  */
@@ -424,6 +437,7 @@ function convertToOperationConfig(parseResult) {
       childList: [],
       __level: 0,
       hidden: false,
+      paramLocation: 'header',
       required: h.required === 'true' || h.required === '是' || h.required === '**' || h.required === true,
       defaultValue: h.example || h.value || ''
     }));
@@ -433,7 +447,8 @@ function convertToOperationConfig(parseResult) {
       desc: '请求头',
       name: 'Headers',
       paramType: 'Object',
-      required: false
+      required: false,
+      paramLocation: 'header'
     });
 
     operation.parameters.header = parseResult.requestInfo.headers.map(h => ({
@@ -452,7 +467,8 @@ function convertToOperationConfig(parseResult) {
       children: [],
       childList: [],
       __level: 0,
-      hidden: false
+      hidden: false,
+      paramLocation: 'query'
     }));
 
     operation.inputs.push({
@@ -460,7 +476,8 @@ function convertToOperationConfig(parseResult) {
       desc: '查询参数',
       name: 'Query',
       paramType: 'Object',
-      required: false
+      required: false,
+      paramLocation: 'query'
     });
 
     operation.parameters.query = parseResult.requestInfo.query.map(q => ({
@@ -478,7 +495,7 @@ function convertToOperationConfig(parseResult) {
       default: JSON.stringify(requestExample)
     };
 
-    const requestChildList = generateChildList(requestSchema, operation.operationId);
+    const requestChildList = applyParamLocation(generateChildList(requestSchema, operation.operationId), 'body');
     if (requestChildList.length > 0) {
       operation.inputs.push({
         defaultValue: JSON.stringify(requestExample),
@@ -486,7 +503,8 @@ function convertToOperationConfig(parseResult) {
         name: 'Body',
         paramType: 'Object',
         required: false,
-        childList: requestChildList
+        childList: requestChildList,
+        paramLocation: 'body'
       });
     }
   }
@@ -496,13 +514,6 @@ function convertToOperationConfig(parseResult) {
     const responseSchema = parseResult.responseInfo.schema;
     operation.responses = responseSchema;
 
-    if (!operation.parameters.body) {
-      const example = generateExample(responseSchema);
-      operation.parameters.body = {
-        default: JSON.stringify(example)
-      };
-    }
-
     operation.outputs = [generateOutputs(responseSchema, operation.operationId)];
   } else {
     operation.responses = { type: 'object' };

package/lib/connector/operation-normalizer.js

@@ -0,0 +1,198 @@
+'use strict';
+
+const { generateOutputs } = require('./response-parser');
+
+function slugifyOperationId(value, fallback) {
+  const slug = String(value || '')
+    .trim()
+    .replace(/^\//, '')
+    .replace(/[^A-Za-z0-9_]+/g, '_')
+    .replace(/^_+|_+$/g, '');
+
+  return slug || fallback;
+}
+
+function deriveOperationId(operation, index) {
+  const explicitId = String(operation.operationId || '').trim();
+  if (explicitId) {
+    return explicitId;
+  }
+
+  const fallback = `operation_${index + 1}`;
+  const candidates = [operation.url, operation.path, operation.id, operation.name, operation.summary];
+  for (const candidate of candidates) {
+    const operationId = slugifyOperationId(candidate, '');
+    if (operationId) {
+      return operationId;
+    }
+  }
+
+  return fallback;
+}
+
+function normalizeUrl(value) {
+  return String(value || '').trim().replace(/^\/+/, '');
+}
+
+function inferParamLocation(input) {
+  if (input.paramLocation) {
+    return input.paramLocation;
+  }
+
+  const name = String(input.name || '').toLowerCase();
+  if (name === 'headers' || name === 'header') {
+    return 'header';
+  }
+  if (name === 'query' || name === 'queries') {
+    return 'query';
+  }
+  if (name === 'path' || name === 'paths') {
+    return 'path';
+  }
+  if (name === 'body') {
+    return 'body';
+  }
+
+  return null;
+}
+
+function normalizeParamNode(node, paramLocation) {
+  if (!node || typeof node !== 'object') {
+    return node;
+  }
+
+  const normalized = { ...node };
+  if (paramLocation && !normalized.paramLocation) {
+    normalized.paramLocation = paramLocation;
+  }
+  if (!Array.isArray(normalized.children)) {
+    normalized.children = [];
+  }
+  if (!Array.isArray(normalized.childList)) {
+    normalized.childList = [];
+  }
+  normalized.children = normalized.children.map(child => normalizeParamNode(child, paramLocation));
+  normalized.childList = normalized.childList.map(child => normalizeParamNode(child, paramLocation));
+  return normalized;
+}
+
+function normalizeInput(input) {
+  if (!input || typeof input !== 'object') {
+    return input;
+  }
+
+  const paramLocation = inferParamLocation(input);
+  const normalized = { ...input };
+  if (paramLocation && !normalized.paramLocation) {
+    normalized.paramLocation = paramLocation;
+  }
+  if (!Array.isArray(normalized.childList)) {
+    normalized.childList = [];
+  }
+  normalized.childList = normalized.childList.map(child => normalizeParamNode(child, paramLocation));
+  return normalized;
+}
+
+function buildParametersFromInputs(inputs) {
+  const parameters = { header: [] };
+
+  for (const input of inputs) {
+    if (!input || typeof input !== 'object') {
+      continue;
+    }
+
+    const location = inferParamLocation(input);
+    const childList = Array.isArray(input.childList) ? input.childList : [];
+
+    if (location === 'header') {
+      parameters.header = childList.map(child => ({
+        name: child.name,
+        value: child.defaultValue || '',
+      }));
+    } else if (location === 'query') {
+      parameters.query = childList.map(child => ({
+        name: child.name,
+        value: child.defaultValue || '',
+      }));
+    } else if (location === 'body' && input.defaultValue !== undefined) {
+      parameters.body = { default: input.defaultValue };
+    }
+  }
+
+  return parameters;
+}
+
+function normalizeParameters(parameters, inputs) {
+  const normalized = parameters && typeof parameters === 'object' && !Array.isArray(parameters)
+    ? { ...parameters }
+    : buildParametersFromInputs(inputs);
+
+  if (!Array.isArray(normalized.header)) {
+    normalized.header = [];
+  }
+
+  return normalized;
+}
+
+function normalizeOutput(output) {
+  if (!output || typeof output !== 'object') {
+    return output;
+  }
+
+  const normalized = { ...output };
+  if (!Array.isArray(normalized.childList)) {
+    normalized.childList = [];
+  }
+  return normalized;
+}
+
+function normalizeOperation(operation, index) {
+  if (!operation || typeof operation !== 'object' || Array.isArray(operation)) {
+    throw new Error(`第 ${index + 1} 个执行动作必须是对象`);
+  }
+
+  const operationId = deriveOperationId(operation, index);
+  const rawUrl = operation.url !== undefined && operation.url !== null ? operation.url : operation.path;
+  const hasUrl = rawUrl !== undefined && rawUrl !== null && String(rawUrl).trim() !== '';
+  const url = normalizeUrl(rawUrl);
+
+  if (!hasUrl) {
+    throw new Error(`第 ${index + 1} 个执行动作缺少 url/path`);
+  }
+
+  const summary = operation.summary || operation.name || operationId;
+  const description = operation.description || operation.desc || summary;
+  const method = String(operation.method || 'get').toLowerCase();
+  const inputs = Array.isArray(operation.inputs)
+    ? operation.inputs.map(normalizeInput)
+    : [];
+  const responses = operation.responses || { type: 'object', properties: {} };
+  const outputs = Array.isArray(operation.outputs) && operation.outputs.length > 0
+    ? operation.outputs.map(normalizeOutput)
+    : [generateOutputs(responses, operationId)];
+
+  return {
+    ...operation,
+    id: operation.id || `operation-${operationId}`,
+    operationId,
+    summary,
+    description,
+    url,
+    method,
+    inputs,
+    parameters: normalizeParameters(operation.parameters, inputs),
+    responses,
+    outputs,
+    origin: operation.origin !== undefined ? operation.origin : true,
+  };
+}
+
+function normalizeOperations(operations) {
+  const list = Array.isArray(operations) ? operations : [operations];
+  return list.map(normalizeOperation);
+}
+
+module.exports = {
+  normalizeOperation,
+  normalizeOperations,
+};

package/lib/core/chalk.js

@@ -36,6 +36,8 @@ const c = {
   cyan:    '\x1b[36m',
   white:   '\x1b[37m',
   gray:    '\x1b[90m',
+  bgBlue:  '\x1b[44m',
+  bgCyan:  '\x1b[46m',
 };
 
 // ── 图标常量 ───────────────────────────────────────────

package/lib/core/env-cmd.js

@@ -13,7 +13,7 @@
 
 const { execSync } = require('child_process');
 const readline = require('readline');
-const { warn } = require('./chalk');
+const { c, warn } = require('./chalk');
 const {
   loadEnvsConfig,
   saveEnvsConfig,
@@ -28,14 +28,14 @@ const {
 
 // ── 颜色常量 ──────────────────────────────────────────
 
-const RESET   = '\x1b[0m';
-const BOLD    = '\x1b[1m';
-const DIM     = '\x1b[2m';
-const GREEN   = '\x1b[32m';
-const YELLOW  = '\x1b[33m';
-const CYAN    = '\x1b[36m';
-const RED     = '\x1b[31m';
-const BLUE    = '\x1b[34m';
+const RESET   = c.reset;
+const BOLD    = c.bold;
+const DIM     = c.dim;
+const GREEN   = c.green;
+const YELLOW  = c.yellow;
+const CYAN    = c.cyan;
+const RED     = c.red;
+const BLUE    = c.blue;
 
 // ── 工具函数 ──────────────────────────────────────────
 

package/lib/core/update.js

@@ -12,18 +12,18 @@
 const { execSync } = require('child_process');
 const { fetchLatestVersion, isNewer } = require('./check-update');
 const { t } = require('./i18n');
-const { warn } = require('./chalk');
+const { c, warn } = require('./chalk');
 const { getNpmExecutable } = require('./utils');
 
 // ── ANSI 颜色常量 ──────────────────────────────────
-const RESET   = '\x1b[0m';
-const BOLD    = '\x1b[1m';
-const DIM     = '\x1b[2m';
-const GREEN   = '\x1b[32m';
-const YELLOW  = '\x1b[33m';
-const CYAN    = '\x1b[36m';
-const RED     = '\x1b[31m';
-const MAGENTA = '\x1b[35m';
+const RESET   = c.reset;
+const BOLD    = c.bold;
+const DIM     = c.dim;
+const GREEN   = c.green;
+const YELLOW  = c.yellow;
+const CYAN    = c.cyan;
+const RED     = c.red;
+const MAGENTA = c.magenta;
 
 // ── Spinner 动画 ───────────────────────────────────
 const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];

package/lib/dws/dws-wrapper.js

@@ -12,7 +12,7 @@
 
 const { execSync, spawn } = require('child_process');
 const { t } = require('../core/i18n');
-const { warn } = require('../core/chalk');
+const { c, warn } = require('../core/chalk');
 
 const DWS_BINARY_NAME = 'dws';
 const INSTALL_SCRIPTS = {
@@ -51,16 +51,16 @@ function getDwsVersion() {
  * 显示安装指引
  */
 function showInstallGuide() {
-  const RESET   = '\x1b[0m';
-  const BOLD    = '\x1b[1m';
-  const DIM     = '\x1b[2m';
-  const CYAN    = '\x1b[36m';
-  const GREEN   = '\x1b[32m';
-  const YELLOW  = '\x1b[33m';
-  const BLUE    = '\x1b[34m';
+  const RESET   = c.reset;
+  const BOLD    = c.bold;
+  const DIM     = c.dim;
+  const CYAN    = c.cyan;
+  const GREEN   = c.green;
+  const YELLOW  = c.yellow;
+  const BLUE    = c.blue;
 
-  const BG_BLUE = '\x1b[44m';
-  const WHITE   = '\x1b[37m';
+  const BG_BLUE = c.bgBlue;
+  const WHITE   = c.white;
 
   const isWindows = process.platform === 'win32';
   const installCommand = isWindows ? INSTALL_SCRIPTS.windows : INSTALL_SCRIPTS.unix;
@@ -221,11 +221,11 @@ async function executeDwsCommand(args) {
  * 显示 dws 帮助信息
  */
 function showDwsHelp() {
-  const RESET   = '\x1b[0m';
-  const BOLD    = '\x1b[1m';
-  const CYAN    = '\x1b[36m';
-  const GREEN   = '\x1b[32m';
-  const YELLOW  = '\x1b[33m';
+  const RESET   = c.reset;
+  const BOLD    = c.bold;
+  const CYAN    = c.cyan;
+  const GREEN   = c.green;
+  const YELLOW  = c.yellow;
 
   console.log('');
   console.log(`${BOLD}openyida dws - 钉钉 CLI 集成${RESET}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openyida",
-  "version": "2026.6.1-beta.0",
+  "version": "2026.6.3-beta.0",
   "description": "OpenYida CLI - 宜搭低代码 AI 开发工具（安装即用，零配置）",
   "bin": {
     "openyida": "bin/yida.js",

package/yida-skills/SKILL.md

@@ -181,7 +181,7 @@ openyida copy
 | `yida-corp-manager` | `skills/yida-corp-manager/SKILL.md` | 平台管理员、应用管理员、子管理员与通讯录权限 | `openyida corp-manager <子命令>` |
 | `yida-agent-center` | `skills/yida-agent-center/SKILL.md` | 代理中心：在职流程代理、离职代理、撤销和部分流程范围 | `openyida agent-center <子命令>` |
 | `yida-form-detail` | `skills/yida-form-detail/SKILL.md` | 表单详情页 formDetail 样式优化 | 详见 SKILL.md |
-| `yida-data-management` | `skills/yida-data-management/SKILL.md` | 表单/流程/任务数据查询与变更 | `openyida data query form <appType> <formUuid>` |
+| `yida-data-management` | `skills/yida-data-management/SKILL.md` | 表单/子表/流程/任务数据查询与变更 | `openyida data query form <appType> <formUuid>` |
 | `yida-corp-efficiency` | `skills/yida-corp-efficiency/SKILL.md` | 平台管理企业效能概览、查看明细报表、报表接口模板、学习成果和通知群动作 | `openyida corp-efficiency` |
 | `yida-table-form` | `skills/yida-table-form/SKILL.md` | 表格形态批量录入页面 | 详见 SKILL.md |
 | `yida-process-rule` | `skills/yida-process-rule/SKILL.md` | 配置流程规则、审批/办理/抄送、条件/并行分支、字段权限、跳转规则和官方组件节点配置适配 | `openyida configure-process <appType> <formUuid> <流程JSON>` |
@@ -224,6 +224,9 @@ openyida copy
 - **避免无效重试**：同一命令失败后，先根据错误信息检查登录态、组织、参数和字段 ID；不要无修改地连续重试超过 1 次。
 - **数据性能优先**：统计/聚合类需求优先使用 `yida-report` 原生报表服务端聚合；不要在自定义页面前端分页拉取大量表单数据后自行聚合。
 - **模板优先**：自定义页面、表单字段、报表配置等复杂产物优先使用 `openyida sample` 或现有示例生成骨架，再做最小改动。
+- **官方示例范式优先**：用户要求参考/蒸馏宜搭示例中心时，先按 [官方示例中心 Schema 范式](references/official-example-schema-patterns.md) 理解脱敏 schema 的承载方式，再优化技能或实现方案；不要只凭截图、卡片标题或页面视觉做判断。
+- **按 schema 证据选择技能**：先看 `formType`、组件树和 `dataSource.online`。`receipt/process/report` 分别优先落到表单、流程、报表技能；只有默认页是自定义展示页、或确实需要列表/看板/工具页交互时，才默认落到 `yida-custom-page`。
+- **配置承载优先于代码承载**：字段结构、公式、联动、报表聚合、审批规则、集成自动化、连接器动作应分别由对应技能承载；自定义页面代码只做展示、事件分发和必要胶水。
 
 ### 3. corpId 一致性检查（必须遵守）
 

package/yida-skills/references/official-example-schema-patterns.md

@@ -0,0 +1,217 @@
+# 官方示例中心 Schema 范式
+
+> 来源：2026-06-01 对宜搭「开发者赋能平台 / 示例中心」capacity 标签下 156 个示例做只读 schema 抽取。本文只沉淀脱敏后的结构规律，不保存真实 cookie、CSRF token、用户信息或可直接复用的业务密钥。
+
+## 对 OpenYida 技能的核心启发
+
+官方示例中心反复出现的不是“每个需求都写一整页自定义代码”，而是以下范式：
+
+1. **Schema 类型先行**：先看 `formType`、组件树、`dataSource.online`，再决定技能；不要只按卡片标签或标题选择技能。
+2. **低代码配置优先**：能用表单字段、字段公式、字段联动、原生报表、流程规则、集成自动化表达的能力，不要默认落到自定义页面 JS。
+3. **页面三层结构**：页面型能力通常拆成 `状态 VALUE 数据源`、`REMOTE/连接器数据源`、`薄动作/渲染层`，而不是把状态、请求和 UI 全塞进一个函数。
+4. **单能力薄示例**：示例应用通常围绕一个能力闭环展开，先做可学习、可启用、可验证的小闭环，再扩展为完整业务应用。
+5. **数据源可见可审计**：连接器和远程 API 通过设计器数据源进入 schema，页面代码只通过 `this.dataSourceMap.<name>.load()` 或 OpenYida 封装 API 调用。
+6. **原生报表服务端聚合**：报表类示例优先用 `Youshu*` 原生报表组件和服务端聚合；自定义看板只负责展示和交互增强。
+
+把这些范式反哺技能时，核心不是复制官方 schema 字段，而是改进 Agent 的默认决策：先分类、再选择低代码承载面、最后只在必要处写自定义代码。
+
+## 只读抓取链路
+
+当用户要求“蒸馏示例中心”“参考官方示例”“把示例 schema 反哺技能”时，优先抓 schema，而不是只看截图或卡片文案。
+
+1. 示例中心页面本身是宜搭自定义页面，可通过只读接口获取页面 schema：
+
+```text
+GET /bench/getLatestFormWithNavNew.json?formUuid=coe
+```
+
+2. 示例列表来自模板中心数据源：
+
+```text
+GET /query/loginFreeFormData/listFormDataByType.json?type=templateCenter
+```
+
+关键参数：
+
+```json
+{
+  "pageSize": 24,
+  "currentPage": 1,
+  "userLanguage": "zh_CN",
+  "searchFieldJson": "{\"isShow\":\"n\",\"tags\":\"capacity\",\"templateTitle\":\"\",\"description\":\"\"}",
+  "dynamicOrder": "{\"orderNum\":\"+\"}"
+}
+```
+
+3. 通过模板 ID 获取源模板应用：
+
+```text
+GET /query/appTpl/getAppTplComplexInfo.json?appTplUuid=TPL_XXX
+```
+
+读取 `content.latestOnlineAppTpl.appType`，不要调用 `copyTemplateApp`，那会创建真实应用。
+
+4. 打开模板只读预览页，从 HTML 的 `window.pageConfig.formUuid` 读取默认展示页：
+
+```text
+https://template.aliwork.com/{APP_TYPE}/workbench/?appTplUuid=TPL_XXX&__yida_hide_enable_template__=true
+```
+
+5. 通过模板域名读取页面 schema：
+
+```text
+GET https://template.aliwork.com/alibaba/web/{APP_TYPE}/query/formdesign/getSchemaWithAllNavs.json?formUuid={FORM_UUID}
+```
+
+只读抓取可以落到 `.cache/openyida/<项目名>/`，不要把原始 schema、cookie、token 或模板详情提交进仓库。
+
+## 本轮样本分布
+
+156 个 capacity 示例全部能通过上述链路拿到默认访问页 schema。默认页类型分布：
+
+| 类型 | 数量 | 说明 |
+| --- | ---: | --- |
+| `receipt` | 80 | 普通表单页，常见于表单、公式、集成和连接器示例 |
+| 自定义展示页 | 60 | `content.pages[0].formType` 为空，通常是自定义页面/数据看板/工具页 |
+| `report` | 10 | 原生报表页，组件多为 `Youshu*` |
+| `process` | 5 | 流程表单页 |
+| `view` | 1 | 视图页 |
+
+标签不能直接等同于 schema 类型。例如 `report` 标签下既有原生报表，也有表单数据准备页和自定义看板；`integration` 标签下大多默认打开表单页，自动化逻辑流本体不在默认页面 schema 内。选择 OpenYida 子技能时先看 `formType`、组件树和数据源，再看标签。
+
+组件分布反映了官方默认承载方式：
+
+| 类型 | 高频组件 | 范式解释 |
+| --- | --- | --- |
+| 表单页 | `FormContainer`、`TextField`、`NumberField`、`DateField`、`EmployeeField`、`TableField`、`RichText` | 字段结构、公式和少量说明文本承载能力 |
+| 自定义页 | `Div`、`Text`、`Image`、`Button`、`PageSection`、`Dialog`、`TablePc`、`Pagination` | 列表、看板、工具页、弹窗和分页承载交互 |
+| 报表页 | `YoushuPageHeader`、`YoushuTopFilterContainer`、`YoushuSelectFilter`、`YoushuTable`、`YoushuPieChart` | 原生报表负责筛选、聚合和图表 |
+| 流程页 | `FormContainer` + 表单字段 | 表单只承载数据，审批节点由流程规则承载 |
+
+## 示例中心自身的页面模式
+
+示例中心 `coe` 页面是一个典型“模板列表 + 筛选 + 搜索 + 分页 + 点赞 + 启用弹窗”的自定义页面。它的 schema 规律适合反哺列表页、资源中心、模板中心类页面：
+
+- `VALUE` 数据源保存页面状态：`currentPage`、`pageSize`、`searchWord`、`filterValue`、`tags`、`loading`、`tplItem`、`tplInfo` 等。
+- 列表数据源调用 `listFormDataByType.json?type=templateCenter`，参数由 `state` 组合并 JSON 化。
+- 搜索条件使用 `searchFieldJson`，例如 `isShow`、`tags`、`templateTitle`、`description`。
+- 排序使用 `dynamicOrder`，例如 `{"orderNum":"+"}`。
+- 详情弹窗先按 `appTplUuid` 查模板记录，再查 `getAppTplComplexInfo.json`。
+- 点赞和启用记录通过独立数据源写表；启用模板通过 `copyTemplateApp`，属于有副作用接口，未经用户明确确认不要调用。
+
+## 自定义页面三层范式
+
+官方自定义页反复使用三层模型：
+
+| 层 | schema 形态 | OpenYida 生成时的落点 |
+| --- | --- | --- |
+| 状态层 | `VALUE` 数据源：`loading`、`pageSize`、`currentPage`、`tableData`、`searchFieldJson`、`selectedRowKeys` | `_customState` 固定字段，`setCustomState()` 更新 |
+| 数据层 | `REMOTE` / 连接器数据源：表单查询、任务、流程、保存、删除、连接器动作 | 优先 `this.dataSourceMap.<name>.load()`；否则用 `this.utils.yida.*` |
+| 交互层 | `Div/Text/Button/TablePc/Dialog/Pagination/Tabs/Collapse` + 少量 JS 方法 | `renderJsx` 只做展示和事件分发，业务方法独立 `export function` |
+
+因此，生成列表/看板/工具页时，默认先设计状态字典和数据源清单，再写 JSX。不要一开始就写一个巨大的 `renderJsx`。
+
+## 自定义页面数据源模式
+
+官方自定义页面 schema 中常见 `dataSource.online` 结构：
+
+```json
+{
+  "name": "getData",
+  "protocal": "REMOTE",
+  "dpType": "REMOTE",
+  "type": "legao",
+  "isInit": true,
+  "requestHandler": {
+    "type": "JSExpression",
+    "value": "this.utils.legaoBuiltin.dataSourceHandler"
+  },
+  "options": {
+    "method": "GET",
+    "url": {
+      "type": "variable",
+      "variable": "`/${window.pageConfig.appType || window.g_config.appKey}/v1/form/searchFormDatas.json`"
+    },
+    "params": {
+      "type": "variable",
+      "variable": "{ formUuid: state.formUuid, pageSize: state.pageSize, currentPage: state.currentPage }"
+    },
+    "didFetch": {
+      "source": "function didFetch(content) { return content; }"
+    },
+    "onError": {
+      "source": "function onError(error) { this.utils.toast({ title: error.message, type: 'error' }); }"
+    }
+  },
+  "dataHandler": {
+    "source": "function(data, err) { this.setState({ getData: data }); return data; }"
+  }
+}
+```
+
+落到 OpenYida 手写 `.oyd.jsx` 时，不要照抄低代码 schema 里的 `this.setState`。应转换为：
+
+- 页面状态放在 `_customState`，用 `setCustomState()` 合并更新。
+- 读取宜搭表单/流程/任务数据时优先用 `this.utils.yida.*` 或已建好的 `this.dataSourceMap.<name>.load()`。
+- 远程连接器和第三方 API 必须走设计器数据源，不要在 JSX 里直接 `fetch` 外部地址。
+- 列表页保持 `loading / list / currentPage / pageSize / totalCount / filters / selectedRowKeys` 的稳定状态结构，失败时把 `loading` 置回 `false` 并 toast。
+- 需要搜索或筛选时优先形成 `searchFieldJson` 状态，提交前再 JSON 化；不要把散落的筛选字段硬写进多个请求函数。
+
+## 连接器数据源回读形态
+
+连接器类示例的默认页 schema 中，部分数据源会被平台归一为普通 `REMOTE` 数据源：
+
+```json
+{
+  "protocal": "REMOTE",
+  "dpType": "REMOTE",
+  "type": "legao",
+  "options": {
+    "method": "POST",
+    "url": "/query/publicService/invokeService.json?_csrf_token=***",
+    "params": {
+      "inputs": "{\"Headers\":{},\"Query\":{},\"Body\":{}}",
+      "serviceInfo": "{\"connectorInfo\":{\"connectorId\":\"Http_xxx\",\"actionId\":\"operationId\",\"type\":\"httpConnector\",\"connection\":123}}"
+    }
+  }
+}
+```
+
+因此：
+
+- 新建页面数据源仍按 `yida-data-source-connectors` 技能规划，让设计器能看到数据源和连接器动作。
+- 发布后回读 schema 时，既要接受显式 `YIDACONNECTOR` 形态，也要接受 `REMOTE + publicService/invokeService + serviceInfo.connectorInfo` 这种平台归一形态。
+- 任何 `_csrf_token` 都来自运行时页面配置，不能写死到技能文档或页面源码。
+
+## 原生报表与自定义看板边界
+
+原生报表页 schema 通常满足：
+
+- `formType: "report"`。
+- 组件树包含 `YoushuPageHeader`、`YoushuTopFilterContainer`、`YoushuSelectFilter`、`YoushuTable`、`Youshu*Chart` 等。
+- 标签为 `report` 但 `formType` 不是 `report` 时，往往只是报表数据准备页或自定义页面看板。
+
+落地规则：
+
+- 创建或改造原生报表优先用 `yida-report`，不要手写 `Youshu*` schema。
+- 需要更强视觉和交互时，先用原生报表做服务端聚合，再用 `yida-chart`/`yida-custom-page` 渲染。
+- 不要在自定义页面前端分页拉全量表单数据做大规模聚合。
+
+## 表单、公式、流程与集成边界
+
+- 公式示例主要是 `receipt` 或 `process` schema，公式通常落在字段属性 `valueType: "formula"`、`complexValue.formula`、`formula`，字段引用必须是 `#{fieldId}`。
+- 流程示例默认页可能是表单页，也可能是自定义展示页；审批流节点和规则不一定在默认页面 schema 内，应改用 `yida-process-rule` 查询或配置。
+- 集成自动化示例默认页多是触发表单或说明页；逻辑流本体不在默认页面 schema 内，应改用 `yida-integration` 查询/创建。
+- 连接器示例默认页只能证明页面如何调用数据源，连接器本体和动作定义仍由 `yida-connector` / `yida-connector-safe-actions` 管理。
+
+## 技能选择速查
+
+| schema 观察 | 优先技能 |
+| --- | --- |
+| `formType: "receipt"`，组件多为 `TextField` / `NumberField` / `TableField` | `yida-create-form-page`，公式需求再用 `yida-formula` |
+| `formType: "process"` | `yida-create-process` / `yida-process-rule` |
+| `formType: "report"` 或组件为 `Youshu*` | `yida-report` |
+| 自定义展示页，组件为 `Div` / `Text` / `Button` / `TablePc` / `Dialog` | `yida-custom-page` |
+| 自定义页面里有 `dataSource.online` 的远程接口 | `yida-data-source-connectors` + `yida-custom-page` |
+| `publicService/invokeService` 或 `serviceInfo.connectorInfo` | `yida-connector` / `yida-data-source-connectors` |
+| 默认页看不到逻辑流，但标签是 `integration` | `yida-integration` |

package/yida-skills/skills/yida-create-form-page/SKILL.md

@@ -18,6 +18,16 @@ description: 宜搭表单页面创建与更新。适用于：创建新表单、
 - 字段定义或变更定义需要落盘时，必须写入 `.cache/openyida/<项目名>/`，例如 `.cache/openyida/pm/pm-fields-team.json`；不要在仓库根目录生成 `*-fields*.json` 或 `*-changes*.json`
 - **本技能不读写 memory**：formUuid 等信息输出到 stdout，通过 `.cache/<项目名>-schema.json` 持久化，不依赖跨会话的 memory 状态
 
+## 官方表单示例范式
+
+官方示例中心的表单类能力大多用 `FormContainer + 标准字段 + 字段属性/公式/联动` 承载，少量 `RichText` 用于说明。创建或更新表单时优先按这个顺序落地：
+
+1. 字段结构：用 `TextField`、`NumberField`、`DateField`、`EmployeeField`、`SelectField`、`TableField`、`AssociationFormField` 等标准字段表达数据模型。
+2. 字段公式：计算、默认值、日期/文本转换等用字段 `valueType: "formula"`、`complexValue.formula`、`formula`，不要改写成自定义页面 JS。
+3. 字段联动：显示隐藏、只读、onChange 自动赋值优先用 `rule` 模式；只有 OpenYida DSL 不覆盖的平台属性才用 `patch`。
+4. 说明/示例文字：需要解释能力时可增加 `RichText` 或说明字段，但业务字段仍应保持结构化。
+5. 提交后跨表/通知/流程动作不要塞进字段 JS；分别交给 `yida-integration`、`yida-process-rule` 或 `yida-connector`。
+
 ## 适用场景
 
 用户需要"创建表单"、"新增字段"、"修改表单结构"时使用。

package/yida-skills/skills/yida-custom-page/SKILL.md

@@ -44,6 +44,20 @@ description: 宜搭自定义页面 JSX 开发规范。React 16 宜搭原生 expo
 > 每条规则的代码示例、反模式和常见错误见 [编码指南](references/coding-guide.md)（编写代码前强制必读）。
 > 表单类 JSX 控件、筛选栏、表格、成员/附件等组件写法见 [组件指南](references/component-jsx-guide.md)；未验证的平台组件能力不得编造。
 
+## 官方示例范式内化
+
+官方示例中心的自定义页不是“整页手写逻辑”，而是 `状态层 + 数据源层 + 交互层` 三层结构。生成页面前先列出这三层，再写代码：
+
+| 层 | 默认内容 | 生成要求 |
+| --- | --- | --- |
+| 状态层 | `loading`、`list/tableData`、`currentPage`、`pageSize`、`totalCount`、`filters/searchFieldJson`、`selectedRowKeys`、`dialogVisible` | 放入 `_customState`，所有失败路径必须恢复 `loading: false` |
+| 数据源层 | 表单查询、保存、更新、删除、流程发起、任务列表、连接器动作 | 优先调用已有 `this.dataSourceMap.<name>.load()`；没有数据源且是宜搭内置数据时用 `this.utils.yida.*`；第三方/连接器必须先走 `yida-data-source-connectors` |
+| 交互层 | 筛选栏、表格/卡片列表、分页、弹窗、Tab/Collapse、操作按钮 | `renderJsx` 只负责展示和事件分发，业务逻辑拆成 `export function` |
+
+默认页面结构按官方高频组件范式转译为 JSX：顶部筛选/操作区、主体表格或卡片列表、分页、详情/编辑弹窗、空态/错误态。不要把数据查询、复杂计算和大段 DOM 混在一个 `renderJsx` 里。
+
+如果用户的需求实际是字段公式、字段联动、原生报表、审批规则或集成自动化，先切换到对应技能；自定义页面只在需要跨数据展示、工具页交互、可视化看板或连接器调用界面时承担前端层。
+
 ## 适用场景
 
 **正向触发**：
@@ -456,6 +470,7 @@ openyida check-page pages/src/home.oyd.jsx --json      # 输出机器可读的
 | [编码指南](references/coding-guide.md) | 文件结构模板、状态管理、生命周期、19 条编码规范 | 编写任何页面代码前必读 |
 | [设计规范](references/design-system.md) | 色彩/圆角/字体/间距系统、7 类组件样式模板、8 条反模式 | 实现 UI 样式时必读 |
 | [素材资源](references/assets-guide.md) | 图片/音乐/Icon 素材库、CDN 安全规范 | 需要引入图片、图标、音效时阅读 |
+| [官方示例中心 Schema 范式](../../references/official-example-schema-patterns.md) | 示例中心 156 个 capacity 模板的 schema 抽取链路、类型分布、数据源/报表/连接器模式 | 用户要求参考官方示例、蒸馏模板能力、或实现列表/模板中心/数据源驱动页面时阅读 |
 | **全局共享文档** | | |
 | [宜搭 API](../../references/yida-api.md) | 表单/流程/工具 API 完整参数文档 | 调用 `this.utils.yida.*` 前必读 |
 | [大模型 API](../../references/model-api.md) | AI 文本生成接口参数 | 调用 `txtFromAI` 前必读 |

package/yida-skills/skills/yida-data-management/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: yida-data-management
-description: 宜搭数据管理。表单实例/流程实例/任务中心的查询、新增、更新。表单走 /v1/form/，流程走 /v1/process/，不能混用。
+description: 宜搭数据管理。表单实例/子表/流程实例/任务中心的查询、新增、更新。表单走 /v1/form/，流程走 /v1/process/，不能混用。
 ---
 
 # 数据管理
@@ -20,6 +20,7 @@ description: 宜搭数据管理。表单实例/流程实例/任务中心的查
 - **录入/更新数据前，必须先执行 `openyida get-schema` 获取真实字段 ID，并将字段 ID 映射记录到 `.cache/<项目名>-schema.json`**
 - **生成测试数据或录入/更新数据时，`DateField` / `CascadeDateField` 必须使用 13 位毫秒时间戳（如 `1719705600000`），不要传 `YYYY-MM-DD`、`YYYY-MM-DD HH:mm:ss` 或 ISO 字符串**
 - **录入数据后，必须执行 `openyida data query` 抽查至少 1 条记录，确认 `formData` 中字段有实际值（非空），否则说明字段 ID 有误，需重新排查**
+- **读取子表明细超过 50 行时，必须使用 `openyida data query subform` 或 `listTableDataByFormInstIdAndTableId` 分页查询完整子表；不要把 `searchFormDatas.currentPage` 当作子表分页**
 - **本技能不读写 memory**：数据操作通过 CLI 命令写入宜搭平台，不依赖跨会话的 memory 状态
 - 一次性造数、旧数据修正、字段迁移脚本可以使用 Python 或 JS，优先选择更快更清晰的实现；脚本、导入数据、查询条件文件必须放在 `.cache/openyida/` 下，并复用真实查询到的 appType/formUuid/fieldId/formInstId
 - **禁止在仓库根目录生成导入用的 `*.json`、`*.js`、`*.py`、`*.csv` 临时文件**；推荐使用 `.cache/openyida/data-import/` 存放数据文件，`.cache/openyida/scripts/` 存放一次性执行脚本
@@ -31,6 +32,7 @@ description: 宜搭数据管理。表单实例/流程实例/任务中心的查
 **关键区分**：
 - 操作表单数据记录（增删改查）→ 本技能
 - 修改表单结构（字段增删改）→ `yida-create-form-page`
+- 自定义页面调用连接器或外部 API 数据源 → `yida-data-source-connectors`
 - 表单接口（`/v1/form/`）vs 流程接口（`/v1/process/`）不能混用
 
 ## 触发条件
@@ -43,6 +45,7 @@ description: 宜搭数据管理。表单实例/流程实例/任务中心的查
 **不适用场景（不要触发）**：
 - 修改表单结构（字段增删改）→ `yida-create-form-page`
 - 配置集成自动化 → `yida-integration`
+- 自定义页面接入 HTTP 连接器、第三方接口或外部系统数据 → `yida-data-source-connectors`
 - 获取字段 ID → `yida-get-schema`
 - 表单接口（`/v1/form/`）和流程接口（`/v1/process/`）不能混用
 
@@ -69,11 +72,26 @@ openyida data create form <appType> <formUuid> --data-json '<json>' [--resolve-a
 openyida data create form <appType> <formUuid> --data-file .cache/openyida/data-import/record.json [--resolve-aliases]
 openyida data update form <appType> --inst-id <formInstId> --form-uuid <formUuid> --data-json '<json>' [--resolve-aliases]
 openyida data update form <appType> --inst-id <formInstId> --form-uuid <formUuid> --data-file .cache/openyida/data-import/patch.json [--resolve-aliases]
-openyida data query subform <appType> <formUuid> --inst-id <formInstId> --table-field-id <fieldId|alias> [--resolve-aliases]
+openyida data query subform <appType> <formUuid> --inst-id <formInstId> --table-field-id <fieldId|alias> [--page 1 --size 100] [--resolve-aliases]
 ```
 
 当 JSON 使用宜搭组件别名作为 key 时，追加 `--resolve-aliases`，OpenYida 会先读取表单 Schema 中的 `componentAlias.items`，再将别名转换为真实 `fieldId` 后调用数据接口。更新类命令若要解析别名，必须额外传 `--form-uuid <formUuid>`。
 
+### 子表超过 50 行
+
+当 `searchFormDatas` 或 `getFormDataById` 返回的 `formData.tableField_xxx` 刚好是 50 行时，优先判断为详情接口对子表内嵌数据做了截断，不要直接下结论为"没有更多数据"。
+
+正确处理流程：
+
+1. 先确认主记录的 `formInstId` 和子表真实 `tableFieldId`；如果只有别名，先执行 `openyida get-schema` 或给 `query subform` 追加 `--resolve-aliases`。
+2. 使用 `openyida data query subform <appType> <formUuid> --inst-id <formInstId> --table-field-id <tableFieldId> --page 1 --size 100` 查询子表第一页。
+3. 如果返回 `totalCount` 大于 `data.length`，继续按 `currentPage/pageSize` 翻页，或在脚本中复用 `listTableDataByFormInstIdAndTableId` 拉全量。
+4. 不要通过 DOM、虚拟滚动列表、页面全局变量抓取子表全量数据；这类方式依赖页面实现，不能作为稳定数据管理方案。
+
+注意：`searchFormDatas.currentPage` 分页的是主表实例列表，不是某条实例里的子表行。把 `currentPage` 改为 2 后返回空，只能说明主表第二页没有记录，不能证明子表不支持分页。
+
+不要把"创建自定义数据源"作为解决宜搭表单/子表 50 行截断的首选方案；只有在确实需要调用 HTTP 连接器、第三方接口或外部系统数据时，才切换到 `yida-data-source-connectors`。
+
 ### 流程实例
 
 ```bash
@@ -209,6 +227,7 @@ openyida sample yida-data-management form-field-template   # 表单字段定义
 | 异常场景 | 处理方式 |
 |---------|----------|
 | 查询返回空结果 | 确认 formUuid 正确，检查查询条件是否过于严格 |
+| 子表只返回 50 行 | 不要翻 `searchFormDatas.currentPage`；使用 `query subform` / `listTableDataByFormInstIdAndTableId` 按 `formInstId + tableFieldId` 分页查询 |
 | 新增数据后字段值为空 | 字段 ID 有误，先执行 `openyida get-schema` 获取真实 fieldId |
 | 更新失败（formInstId 不存在） | 先用 query 命令确认记录存在，不要猜测 formInstId |
 | 接口返回 401/未登录 | 执行 `openyida login` 重新登录 |

package/yida-skills/skills/yida-data-source-connectors/SKILL.md

@@ -11,6 +11,8 @@ description: 宜搭自定义页面连接器/远程 API 数据源接入规范。
 
 禁止在自定义页面里直接用 `fetch`、`XMLHttpRequest`、`/query/newconnector/testConnector.json`、`ConnectorFactory.testConnector` 或手写远程 URL 绕过设计器数据源。例外只允许用于一次性本地诊断，不得发布到正式页面 Schema。
 
+官方示例中心的 schema 回读规律见 [官方示例中心 Schema 范式](../../references/official-example-schema-patterns.md)。其中连接器调用有时会被平台归一为 `REMOTE + /query/publicService/invokeService.json + serviceInfo.connectorInfo`，因此验收时既看设计器数据源是否存在，也要识别这种归一形态。
+
 ## 适用场景
 
 - 自定义页面、Dashboard、数据大屏读取外部系统接口。
@@ -18,10 +20,17 @@ description: 宜搭自定义页面连接器/远程 API 数据源接入规范。
 - 用户要求“把连接器操作添加到页面数据源”“左侧数据源里要能看到连接器”“远程 API 不要写死在 JSX 里”。
 - 修复页面一直卡在“加载中”，且原因是代码绕过数据源直接请求连接器或外部域名。
 
+## 不适用场景
+
+- 读取宜搭表单、流程、任务或子表数据 → 使用 `yida-data-management`。
+- 子表内嵌明细只返回 50 行 → 使用 `openyida data query subform` / `listTableDataByFormInstIdAndTableId` 按 `formInstId + tableFieldId` 分页查询，不要为此新建连接器数据源。
+- 修改表单或页面结构 → 使用 `yida-create-form-page` / `yida-custom-page`。
+
 ## 与其他技能的分工
 
 - 创建 HTTP 连接器本体、账号、动作列表：使用 `yida-connector`。
 - 从 API 文件或后端 Controller 生成安全动作 JSON：使用 `yida-connector-safe-actions`。
+- 查询表单、流程、任务或子表数据：使用 `yida-data-management`。
 - 编写自定义页面 UI 和生命周期：使用 `yida-custom-page`。
 - 发布页面：使用 `yida-publish-page`，发布后确认数据源仍被保留或补回。
 
@@ -42,6 +51,16 @@ openyida connector list-actions <connector-id>
 - `tricolorGetUserDtuSns`
 - `tricolorGetDtuSnStateList`
 
+官方示例里高频数据源类别包括表单查询、任务列表、流程发起、保存/更新/删除、连接器动作。OpenYida 生成时应把每个远程能力设计为独立数据源，并为页面状态保留明确字段：
+
+| 能力 | 数据源命名建议 | 状态字段建议 |
+| --- | --- | --- |
+| 查询列表 | `get<Biz>List` | `loading`、`tableData/list`、`currentPage`、`pageSize`、`totalCount`、`filters/searchFieldJson` |
+| 查询详情 | `get<Biz>ById` | `detailLoading`、`currentRecord` |
+| 保存/更新 | `save<Biz>` / `update<Biz>` | `submitting`、`dialogVisible` |
+| 删除/批量删除 | `delete<Biz>` / `batchDelete<Biz>` | `selectedRowKeys`、`deleting` |
+| 连接器动作 | `<service><Action>` | 与动作结果同名的 `result` / `rawResult` |
+
 3. 在页面 Schema 的 Page 根节点 `dataSource.online` 中登记连接器数据源。
 
 数据源必须满足：
@@ -53,6 +72,15 @@ openyida connector list-actions <connector-id>
 - `options.connectorAction.value` 使用动作 `operationId`
 - `options.params.inputs` 包含 `Headers`、`Query`、`Body`
 - `options.shouldFetch: false`，由页面代码按需触发
+- `options.didFetch` 必须返回处理后的 content；返回结构不稳定时做归一化
+- `options.onError` 必须 toast 具体数据源/动作名，并让页面加载态恢复
+
+发布后回读 schema 时，平台可能把连接器数据源归一成以下只读形态；这是可接受的，但不要在源码里写死 `_csrf_token`：
+
+- `dpType: "REMOTE"` / `protocal: "REMOTE"`
+- `options.url` 为 `/query/publicService/invokeService.json?...`
+- `options.params.serviceInfo` 内含 `connectorInfo.connectorId`、`actionId`、`type`、`connection`
+- `requestHandler.value` 仍是 `this.utils.legaoBuiltin.dataSourceHandler`
 
 4. 页面代码只调用数据源。
 
@@ -90,6 +118,7 @@ openyida get-schema <appType> <formUuid> > .cache/openyida/<page>-schema.json
 检查点：
 
 - 设计器左侧“数据源”能看到新增连接器数据源。
+- `dataSource.online` 中能看到显式连接器数据源，或回读为 `REMOTE + publicService/invokeService + serviceInfo.connectorInfo` 的平台归一形态。
 - `actions.module.source` 中没有 `ConnectorFactory.testConnector`、`newconnector/testConnector`、外部 API 域名直连代码。
 - 页面运行时使用 `this.dataSourceMap.<name>.load()`。
 

package/yida-skills/skills/yida-formula/SKILL.md

@@ -41,6 +41,8 @@ description: 宜搭表单公式编写规范，包含函数速查、语法规则
 
 > 完整函数列表参见 `../../references/formula-functions.md`
 
+官方示例中心的公式类示例基本落在普通表单或流程表单 schema 中，而不是自定义页面。遇到“日期转换、流水号、登录人、主管、相隔时间、求和”等能力时，默认先配置字段公式或字段联动；只有公式无法表达、且需要跨表提交后动作时，再切到 `yida-integration` 或 `yida-business-rule`。
+
 ---
 
 ## ⚠️ 重要：公式配置方式说明

package/yida-skills/skills/yida-integration/SKILL.md

@@ -16,6 +16,7 @@ description: 宜搭集成&自动化配置技能。支持创建/查询/开启/关
 - **创建/发布前必须确认**：执行集成自动化创建或发布操作前，必须向用户展示逻辑流配置摘要（触发条件、节点列表、通知对象），获得用户明确同意后再执行
 - 创建前先确认触发表单的 formUuid 和相关字段 ID
 - 创建成功后记录逻辑流 ID 到 `.cache/<项目名>-schema.json`
+- 参考官方示例时不要只看默认页面 schema：集成自动化示例的默认页通常只是触发表单或说明页，逻辑流本体需要通过集成自动化接口/命令查询或创建
 
 ## 适用场景
 
@@ -53,6 +54,8 @@ description: 宜搭集成&自动化配置技能。支持创建/查询/开启/关
 
 本技能用于在宜搭平台创建「集成&自动化」（逻辑流），支持场景：**表单事件触发 → 多节点组合处理 → 钉钉工作通知 / 数据操作**。
 
+官方示例中心体现的集成范式是“表单收集数据，逻辑流处理副作用”。因此，跨表新增/更新、通知、创建待办、调用钉钉能力等提交后动作，默认用本技能；不要把这些副作用塞进表单字段 JS 或自定义页面按钮，除非用户明确要求一次性人工触发工具页。
+
 ## 功能概述
 
 - 监听指定表单的新增 / 更新 / 删除 / 评论事件

package/yida-skills/skills/yida-report/SKILL.md

@@ -16,6 +16,7 @@ description: "宜搭原生报表技能，用于创建宜搭平台内置的原生
 
 - **创建/发布前必须确认**：执行报表创建或发布操作前，必须向用户展示报表配置摘要（图表类型、数据源、字段映射），获得用户明确同意后再执行
 - 普通"报表"、"统计"需求默认使用本技能，不要直接跳到 `yida-chart`
+- 参考官方示例时先确认 schema 证据：只有 `formType: "report"` 或组件树出现 `Youshu*` 报表组件时才按原生报表处理；`report` 标签但默认页是 `receipt` 或自定义页时，先判断是否只是数据准备页或看板页
 - 调用报表数据 API 前必须确认 `reportId` 和 `datasetId` 来自真实报表
 - 解析报表数据时必须处理 `data.rows` 为空的情况，避免页面崩溃
 - 报表配置 JSON 需要落盘时，必须写入 `.cache/openyida/<项目名>/`，例如 `.cache/openyida/pm/pm-report-team.json`；不要在仓库根目录生成 `*-report*.json`
@@ -69,6 +70,8 @@ description: "宜搭原生报表技能，用于创建宜搭平台内置的原生
 ECharts 自定义页面（前端渲染）
 ```
 
+官方示例中心的报表范式是“原生报表先聚合，自定义页面后增强”。因此，除非用户明确要做高级视觉看板，否则先创建或复用原生报表；只有在已有报表提供聚合数据后，再让 `yida-chart` 或 `yida-custom-page` 承担展示层。
+
 **为什么不用 `searchFormDatas` 前端聚合？**
 
 | 对比项 | `searchFormDatas` 前端聚合 | 原生报表 API |