digitalsee-ai-flow-cli 0.9.24-beta → 0.9.29-beta

package/README.md

@@ -396,6 +396,8 @@ ai-flow flow export <flowId> --json
 | `--output` | 否 | `./{name}.yaml` | 输出路径，若为目录则自动追加文件名 |
 | `--json` | 否 | — | 以 JSON 格式输出 `{ ok, id, file, message }` |
 
+导出文件保持服务端 YAML 原样（保证 `flow import` 回导兼容）。当导出内容包含 NodePackage 提交信封字段（`proxy_id` / `mcp_tool_description`）时：人类可读模式输出提示，`--json` 模式额外返回 `envelopeKeys` 数组；可用 `flow node show` 查看解包后的可读结构。
+
 ### flow import
 
 导入 YAML 连接流文件。支持 `.yaml` / `.yml` 格式，文件大小不超过 5MB。
@@ -569,8 +571,14 @@ ai-flow flow node create \
 3. POST 创建节点
 
 > 不传 `--data`/`--data-file` 时使用默认值填充。`--data`/`--data-file` 内容必须为 `{"properties": {"fieldName": "value"}}` 格式，配置字段包裹在 `properties` 中，键名对应配置字段的 `name`。对于特殊节点类型（ConditionNode/LoopNode/SwitchNode），额外字段（`or_list`/`branches`/`type` 等）与 `properties` 同级传入，会自动转发。详见 [特殊节点类型配置指南](docs/special-node-types.md)。`--trigger` 标志会筛选触发器类型的动作。
+>
+> **NodePackage 提交信封**：NodePackage 节点（`action_key + action_ver` 身份）的 `--data` 顶层是提交信封，合法键：`properties`（业务配置）、`position`、`proxy_id`（代理网关 ID，字符串，`"0"`=不使用）、`mcp_tool_description`（MCP 工具描述）、`account_id`（建议用 `--account-id`）。PROXY 类型字段（`node_schema.input_fields` 中 `type=PROXY`）由宿主处理，**写在 `properties` 中不会生效**，会被校验拦截并提示改用顶层 `proxy_id`：
+> ```bash
+> # 正确：代理选择走信封顶层 proxy_id
+> ai-flow flow node create ... --data '{"properties": {"query": "hi"}, "proxy_id": "6880053123997337600"}'
+> ```
 
-> **账号配置**：当动作的 `config_schema` 包含 `account_schema_id` 时，需要通过 `--account-id` 指定账号实例 ID。若未指定且仅 1 个可用账号，CLI 自动选择；多个账号时通过结构化输出返回可用列表。
+> **账号配置**：当动作的 `config_schema` 包含 `account_schema_id` 时，需要通过 `--account-id` 指定账号实例 ID。若未指定且仅 1 个可用账号，CLI 自动选择；多个账号时通过结构化输出返回可用列表；0 个账号时提示通过 `flow account create` 创建。
 
 > **错误处理配置**：通过 `--error-handler-file` 指定 JSON 文件配置节点的错误处理策略，格式如下。`process_type`: `1`=中断流程, `2`=忽略错误；`warn_type`: `1`=启用告警, `0`=禁用。
 > ```json
@@ -609,6 +617,7 @@ ai-flow flow node show <nodeId> --json
   描述      (无)
   账号 ID   (无)
   账号 Schema ID  (无)
+  代理 ID   (无)
 
 --- 配置参数 (3) ---
 字段名         显示名                 类型    必填  当前值        可选值
@@ -620,6 +629,11 @@ timeout        超时时间(ms)          NUMBER   否    5000           -
 { "method": "POST", "content_type": "application/json", "timeout": 5000 }
 ```
 
+NodePackage 节点的 properties 若被包裹为提交信封（`{properties: {...}, account_id, proxy_id, mcp_tool_description}`），会自动解包为业务字段；信封顶层的宿主字段单独展示：
+
+- 人类可读模式：`代理 ID` 显示 proxy_id（`0` 时显示「不使用」）、`MCP 工具描述` 单独分节展示
+- `--json` 模式：`data.properties` 为解包后的业务字段，`data.proxy_id` / `data.mcp_tool_description` 为识别出的信封字段
+
 ### flow node update
 
 更新连接流中的节点配置。使用 `--patch`/`--patch-file` 做深度合并更新（`--data` 已废弃）。支持通过 `--sample-output` 设置节点样本输出，供下游节点测试时引用变量。
@@ -653,6 +667,12 @@ ai-flow flow node update <nodeId> --flow-id <flowId> --connector-id <id> --actio
 ai-flow flow node update <nodeId> --flow-id <flowId> --account-id <accountId>
 ai-flow flow node update <nodeId> --flow-id <flowId> --error-handler-file ./error-handler.json
 
+# 更新 NodePackage 信封字段（代理网关 / MCP 工具描述，与 properties 同级）
+ai-flow flow node update <nodeId> --flow-id <flowId> \
+  --patch '{"properties": {"query": "hi"}, "proxy_id": "6880053123997337600"}'
+ai-flow flow node update <nodeId> --flow-id <flowId> \
+  --patch '{"properties": {}, "mcp_tool_description": "encode tool"}'
+
 # 设置样本输出（下游节点可通过 {{N<nodeId>.field}} 引用）
 ai-flow flow node update <nodeId> --flow-id <flowId> --sample-output '{"key":"value"}'
 ai-flow flow node update <nodeId> --flow-id <flowId> --sample-output-file ./sample.json
@@ -689,6 +709,8 @@ ai-flow flow node update <nodeId> --flow-id <flowId> --patch-file ./config.json
 
 > `--patch` 与 `--data` 的区别：`--patch` 与现有配置做深度合并，语义明确为 patch 操作；`--data` 为旧参数，语义不统一，已废弃。
 
+> **NodePackage 信封字段**：NodePackage 节点（`action_key + action_ver` 身份）的 `--patch` 顶层可携带 `proxy_id`（代理网关 ID，字符串，`"0"`=不使用）与 `mcp_tool_description`（MCP 工具描述），与 `properties` 同级。PROXY 类型字段写在 `properties` 中会被校验拦截，须改用顶层 `proxy_id`。节点已有信封字段在更新时自动回传，详见 [特殊节点类型配置指南](docs/special-node-types.md)。
+
 ### flow node delete
 
 删除连接流中的节点。默认需 `--yes` 确认（面向 Agent 的非交互模式）。
@@ -739,6 +761,128 @@ ai-flow flow account list <connectorId> --json
 | `--account-schema-id` | 否 | 按账号模型过滤 |
 | `--json` | 否 | 以 JSON 格式输出 |
 
+### flow account create
+
+为连接器创建账号实例。凭据字段校验复用字段类型契约注册表（credential schema 字段的 required/类型/pattern 等规则），非法数据在提交前被拦截；PASSWORD 类字段在输出中脱敏展示。
+
+```bash
+# 基本用法：凭据 JSON 内联提供
+ai-flow flow account create <connectorId> --account-schema-id <schemaId> --data '{"host":"db.local","port":3306,"username":"root","password":"***"}'
+
+# 从文件读取凭据（与 --data 互斥）
+ai-flow flow account create <connectorId> --account-schema-id <schemaId> --data-file credentials.json
+
+# 指定实例名称与代理网关
+ai-flow flow account create <connectorId> --account-schema-id <schemaId> --data-file credentials.json --name "生产库" --proxy-id <proxyId>
+
+# JSON 输出（含脱敏后的凭据回显）
+ai-flow flow account create <connectorId> --account-schema-id <schemaId> --data '...' --json
+```
+
+| 选项 | 必填 | 说明 |
+|------|------|------|
+| `--account-schema-id` | 是 | 账号模型 ID（数字 schema id 或 account_key） |
+| `--data` | 是* | 凭据字段 JSON（key → 值），与 `--data-file` 互斥 |
+| `--data-file` | 是* | 凭据字段 JSON 文件路径 |
+| `--name` | 否 | 实例显示名称（缺省使用账号模型名称） |
+| `--proxy-id` | 否 | 代理网关 ID |
+| `--json` | 否 | 以 JSON 格式输出 `{ ok, id, account, message }` |
+
+创建成功后可直接用于 `flow node create`（单实例时自动选中）。当目标账号不存在时，`flow node create` 的错误信息会提示本命令。
+
+### flow account test
+
+测试账号实例连通性（服务端校验凭据，RDBMS 类账号会真实建连）。失败时输出服务端返回的字段级错误（如凭据 JSON 消息中的 `errors` 数组）。
+
+```bash
+ai-flow flow account test <accountId>
+ai-flow flow account test <accountId> --json
+```
+
+| 选项 | 必填 | 说明 |
+|------|------|------|
+| `--json` | 否 | 以 JSON 格式输出 `{ ok, data: { account_id, result }, message }`，失败时附 `fieldErrors` |
+
+> 典型链路：`flow account create` → `flow node create`（自动选号）→ `flow account test`，全程无需回 UI。
+
+### flow trigger — 触发器配置（cron / webhook）
+
+读取与配置连接流的触发器（对齐 rcs/DIP `DipTriggerConfig` 契约）。配置存储在触发器节点（`StartEventNode`）的 `properties` 上，要求流中已存在触发器节点（通过 `flow node create --trigger` 创建，见上文）。三种触发模式：`manual`（手动）、`cron`（定时）、`webhook`（Web 回调）。
+
+```bash
+# 查看当前触发器配置（未配置时显示 manual）
+ai-flow flow trigger show <flowId> [--json]
+
+# 配置 cron 定时触发器（Quartz 风格表达式：秒 分 时 日 月 周 [年]）
+ai-flow flow trigger set-cron <flowId> --expression "0 0/5 * * * ?" --timezone Asia/Shanghai
+
+# 配置 webhook 触发器
+ai-flow flow trigger set-webhook <flowId> --path /hooks/flow1 \
+  --method POST --response-mode IMMEDIATE
+
+# webhook + 自定义响应体（responseMode=CUSTOM 时 --response-data 必填）
+ai-flow flow trigger set-webhook <flowId> --path /hooks/flow1 \
+  --response-mode CUSTOM --response-data '{"ok": true}'
+
+# webhook + Header 鉴权（--auth-header-name 与 --auth-header-value 必须成对）
+ai-flow flow trigger set-webhook <flowId> --path /hooks/flow1 \
+  --auth-required --auth-header-name X-Api-Key --auth-header-value secret123
+
+# 切回手动触发（清除 cron/webhook 配置）
+ai-flow flow trigger set-manual <flowId>
+```
+
+#### flow trigger show
+
+| 选项 | 必填 | 说明 |
+|------|------|------|
+| `--json` | 否 | 以 JSON 输出 `{ ok, data: { flowId, nodeId, connectorId, connectorName, actionId, actionName, trigger } }` |
+
+`trigger` 字段结构（未配置时为 `null`，人类可读模式显示为 manual）：
+
+```json
+// cron
+{ "mode": "cron", "expression": "0 0/5 * * * ?", "timezone": "Asia/Shanghai" }
+// webhook
+{ "mode": "webhook", "path": "/hooks/flow1", "httpMethod": "POST",
+  "responseMode": "IMMEDIATE", "authRequired": false }
+// manual
+{ "mode": "manual" }
+```
+
+#### flow trigger set-cron
+
+| 选项 | 必填 | 默认值 | 说明 |
+|------|------|--------|------|
+| `--expression` | 是 | — | Quartz cron 表达式，6-7 段（秒 分 时 日 月 周 [年]），支持 `*` `?` 数字、区间 `a-b`、步长 `n/m`、列表 `a,b,c`，周字段支持 `MON-FRI` / `SUN` 名称（1-7） |
+| `--timezone` | 否 | 服务器时区 | IANA 时区标识（如 `Asia/Shanghai`） |
+| `--json` | 否 | — | 以 JSON 输出 `{ ok, id, message, data: { trigger } }` |
+
+示例表达式：`0 0/5 * * * ?`（每 5 分钟）、`0 0 12 * * ?`（每天 12:00）、`30 15 * * ? MON-FRI`（工作日 15:30）、`0 0 0 1 1 ? 2027`（2027 年元旦）。
+
+#### flow trigger set-webhook
+
+| 选项 | 必填 | 默认值 | 说明 |
+|------|------|--------|------|
+| `--path` | 是 | — | webhook 路径，以 `/` 开头，最大 256 字符 |
+| `--method` | 否 | `POST` | HTTP 方法：`GET` \| `POST` |
+| `--response-mode` | 否 | `IMMEDIATE` | 响应模式：`IMMEDIATE`（立即返回）\| `LAST_NODE`（末节点输出）\| `CUSTOM`（自定义响应体） |
+| `--response-data` | CUSTOM 时必填 | — | 自定义响应体字符串 |
+| `--auth-required` | 否 | `false` | 启用 Header 鉴权（提供 auth 选项对时自动视为启用） |
+| `--auth-header-name` | 否 | — | 鉴权 Header 名称（与 `--auth-header-value` 成对，字母开头） |
+| `--auth-header-value` | 否 | — | 鉴权 Header 值（与 `--auth-header-name` 成对） |
+| `--json` | 否 | — | 以 JSON 输出 |
+
+#### flow trigger set-manual
+
+| 选项 | 必填 | 说明 |
+|------|------|------|
+| `--json` | 否 | 以 JSON 输出 |
+
+> 校验规则：非法 cron 表达式（段数、取值范围、区间端点、步长）、不以 `/` 开头或含非法字符的 path、非 `GET/POST` 方法、非枚举 responseMode、`CUSTOM` 缺少 `responseData`、`authHeaderName/Value` 不成对均会被拦截并以退出码 1 失败。
+>
+> 与 `flow node create --trigger` 的衔接：先创建触发器节点（选择 cron/webhook 触发器动作），再用 `flow trigger set-*` 写入具体配置；`flow trigger show` 回读校验配置一致。
+
 ## flow edge connect
 
 连接节点（支持单条和批量）。通过 `--source-handle` / `--target-handle` 连接到多端点节点的特定出口/入口。
@@ -1587,7 +1731,7 @@ src/
 │   │   ├── test.ts        # flow test
 │   │   ├── node.ts        # flow node (show/create/update/delete/list)
 │   │   ├── edge.ts        # flow edge (connect/disconnect)
-│   │   ├── account.ts     # flow account list
+│   │   ├── account.ts     # flow account list/create/test
 │   │   ├── variables.ts   # flow variables (show/inject)
 │   │   ├── log.ts         # flow log (list/show)
 │   │   ├── draft.ts       # flow draft (create/commit/discard)

package/dist/api/client.js

@@ -24,6 +24,15 @@ function isEnvelopeBusinessError(body) {
     return code !== '' && !ENVELOPE_SUCCESS_CODES.has(code.toUpperCase());
 }
 function envelopeErrorMessage(body) {
+    // error 为对象形态（{code, message}）：拼成 "[code] message" 优先透出
+    if (body.error && typeof body.error === 'object') {
+        const record = body.error;
+        const msg = [record.message, record.msg, record.error].find((m) => typeof m === 'string' && m !== '');
+        const code = record.code ?? body.code;
+        if (msg)
+            return code !== undefined ? `[${String(code)}] ${msg}` : msg;
+        return JSON.stringify(body.error);
+    }
     const code = body.error ?? body.code;
     return (body.error_description ||
         body.message ||

package/dist/api/flow.js

@@ -125,12 +125,15 @@ async function copyFlow(flowId) {
 async function deleteFlow(flowId) {
     return (0, client_1.apiDelete)(`/acm/flows/${flowId}`);
 }
+/** 导出连接流为 YAML 并写入文件，返回服务端返回的原始 YAML 文本 */
 async function exportFlow(flowId, outputPath) {
     const client = (0, client_1.getClient)();
     const response = await client.get(`/acm/export/flowInstance/${flowId}`, {
         responseType: 'text',
     });
-    fs.writeFileSync(outputPath, response.data, 'utf-8');
+    const yamlText = typeof response.data === 'string' ? response.data : String(response.data);
+    fs.writeFileSync(outputPath, yamlText, 'utf-8');
+    return yamlText;
 }
 async function importFlow(filePath) {
     const client = (0, client_1.getClient)();

package/dist/api/node.js

@@ -2,11 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getActionDetail = getActionDetail;
 exports.getActionNodeSchema = getActionNodeSchema;
+exports.getActions = getActions;
+exports.searchActions = searchActions;
 exports.isNodePackageSupported = isNodePackageSupported;
 exports.getNodeDetail = getNodeDetail;
 exports.createNode = createNode;
 exports.updateNode = updateNode;
 exports.getAccountInstances = getAccountInstances;
+exports.getAccountInstanceDetail = getAccountInstanceDetail;
+exports.getAccountModel = getAccountModel;
+exports.createAccountInstance = createAccountInstance;
+exports.testAccountInstance = testAccountInstance;
 exports.deleteNode = deleteNode;
 exports.testRunNode = testRunNode;
 exports.cancelDebugNode = cancelDebugNode;
@@ -20,9 +26,20 @@ const encoding_1 = require("@/utils/encoding");
  * whose persistent identity is `action_key + action_ver` — the path params
  * there are the string action key and the numeric action version, not a
  * backend id.
+ *
+ * id 未命中时服务端返回 result:true 的空 data 信封（无 data 键，拦截器不解包）：
+ * 此处识别信封形态返回 undefined，避免空信封被调用方误当动作对象
+ * （曾致创建链路带 action_id='0' 且无 action_key，服务端报
+ * "The node key cannot be empty"）。
  */
 async function getActionDetail(id, version) {
-    return await (0, client_1.apiGet)(`/acm/actions/${id}${version ? '/' + version : ''}`);
+    const detail = await (0, client_1.apiGet)(`/acm/actions/${id}${version ? '/' + version : ''}`);
+    // 与 client 拦截器的信封判定对齐（data 键存在时已被解包，此处只见未解包的信封）
+    const looksLikeEnvelope = detail instanceof Object && ('result' in detail || 'error' in detail || 'code' in detail);
+    if (looksLikeEnvelope) {
+        return undefined;
+    }
+    return detail;
 }
 function parseMaybeJson(value) {
     if (typeof value !== 'string') {
@@ -78,19 +95,47 @@ async function getActionNodeSchema(nodeKey, version) {
     const response = await (0, client_1.apiGet)(`/acm/actions/${encodeURIComponent(nodeKey)}/${version}`);
     return normalizeActionNodeSchemaResponse(response, nodeKey, version);
 }
+async function getActions(params) {
+    const data = await (0, client_1.apiGet)('/acm/actions/v2', params);
+    if (Array.isArray(data))
+        return data;
+    if (data && Array.isArray(data.items))
+        return data.items;
+    if (data && Array.isArray(data.actions))
+        return data.actions;
+    if (data && Array.isArray(data.data))
+        return data.data;
+    return [];
+}
+async function searchActions(params) {
+    const data = await (0, client_1.apiPost)('/acm/links/search', params);
+    const actions = [];
+    if (data && data.items && Array.isArray(data.items)) {
+        for (const item of data.items) {
+            if (item.matched_actions && Array.isArray(item.matched_actions)) {
+                actions.push(...item.matched_actions);
+            }
+        }
+    }
+    return actions;
+}
 /**
  * Single-request probe for NodePackage support.
  *
- * Calls `getNodeCategories()` once: a successful array response (including an
- * empty array) means the connectable API exists → true. A 404/NOT_FOUND (or a
- * non-array payload) means unsupported → false. Any other error (network,
- * auth, 5xx) is re-thrown so callers can distinguish transient failures from
- * a definitive "unsupported" conclusion.
+ * Calls `getNodeCategories({mode:'independent', scene:'normal', trigger:false})` once:
+ * a successful array response (including an empty array) means the connectable API
+ * exists → true. A 404/NOT_FOUND (or a non-array payload) means unsupported → false.
+ * Any other error (network, auth, 5xx) is re-thrown so callers can distinguish
+ * transient failures from a definitive "unsupported" conclusion.
  */
 async function isNodePackageSupported() {
     let categories;
     try {
-        categories = await (0, knowledge_1.getNodeCategories)({ mode: 'independent', scene: 'normal', trigger: false });
+        categories = await (0, knowledge_1.getNodeCategories)({
+            mode: 'independent',
+            scene: 'normal',
+            trigger: false,
+        });
     }
     catch (error) {
         if (error instanceof Error && error.code === 'NOT_FOUND') {
@@ -129,6 +174,32 @@ async function getAccountInstances(linkId, accountSchemaId) {
         return data.items;
     return [];
 }
+async function getAccountInstanceDetail(id) {
+    return (0, client_1.apiGet)(`/acm/accountInstance/${id}`);
+}
+/** 账号模型（credential schema），GET /acm/accounts/:key[/:version] */
+async function getAccountModel(accountKey, version) {
+    const url = `/acm/accounts/${encodeURIComponent(accountKey)}${version ? `/${encodeURIComponent(version)}` : ''}`;
+    return (0, client_1.apiGet)(url);
+}
+/**
+ * 创建账号实例，POST /acm/accountInstance。
+ * 对齐 rcs/IAM-Console：body 为 Base64(JSON) 字符串，Content-Type: text/plain。
+ */
+async function createAccountInstance(payload) {
+    return (0, client_1.apiPost)('/acm/accountInstance', (0, encoding_1.encodeBase64)(payload), {
+        headers: {
+            'Content-Type': 'text/plain',
+        },
+    });
+}
+/**
+ * 测试账号实例连通性，POST /acm/accountInstance/test（普通 JSON body）。
+ * 仅 RDBMS_ACCOUNT 类凭据在 rcs 中展示"测试连接"，此处不限制类型，由服务端判定。
+ */
+async function testAccountInstance(payload) {
+    return (0, client_1.apiPost)('/acm/accountInstance/test', payload);
+}
 async function deleteNode(nodeId) {
     return (0, client_1.apiDelete)(`/acm/flows/nodes/v2/${nodeId}`);
 }

package/dist/api/trigger.js

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTriggerNode = isTriggerNode;
+exports.parseTriggerConfig = parseTriggerConfig;
+exports.findTriggerNode = findTriggerNode;
+exports.setTriggerConfig = setTriggerConfig;
+const flow_1 = require("@/api/flow");
+const node_1 = require("@/api/node");
+const node_type_1 = require("@/constants/node-type");
+const nodeEnvelope_1 = require("@/utils/nodeEnvelope");
+/**
+ * 触发器配置 API 封装。
+ *
+ * ACM/DIP 侧未暴露独立的 trigger 读写端点，触发器配置存储在
+ * 触发器节点（StartEventNode）的 properties 上（DipTriggerConfig 契约）。
+ * 读：flow detail → 定位触发器节点 → node detail → 解包 properties；
+ * 写：读节点详情 → 合并新配置 → PATCH /acm/flows/nodes/v2/:nodeId。
+ */
+/** 判断节点是否为触发器节点 */
+function isTriggerNode(node) {
+    const type = node.node_type || '';
+    return ((0, node_type_1.isTriggerNodeType)(type) ||
+        type === 'START' ||
+        (node.connector_name?.toLowerCase().includes('webhook') ?? false));
+}
+/** DipTriggerConfig 的 wire 键名（snake_case） */
+const TRIGGER_WIRE_KEYS = new Set([
+    'mode',
+    'expression',
+    'timezone',
+    'path',
+    'http_method',
+    'httpmethod',
+    'response_mode',
+    'responsemode',
+    'response_data',
+    'responsedata',
+    'auth_required',
+    'authrequired',
+    'auth_header_name',
+    'authheadername',
+    'auth_header_value',
+    'authheadervalue',
+]);
+function pickString(props, keys) {
+    for (const key of keys) {
+        const v = props[key];
+        if (typeof v === 'string' && v !== '')
+            return v;
+    }
+    return undefined;
+}
+function pickBoolean(props, keys) {
+    for (const key of keys) {
+        const v = props[key];
+        if (typeof v === 'boolean')
+            return v;
+        if (v === 'true')
+            return true;
+        if (v === 'false')
+            return false;
+    }
+    return undefined;
+}
+/**
+ * 从节点 properties 中识别 DipTriggerConfig。
+ *
+ * 兼容字段命名风格：snake_case（http_method）与 camelCase（httpMethod），
+ * 字符串值自动大写归一（httpMethod/responseMode）。
+ */
+function parseTriggerConfig(properties) {
+    const rawMode = properties.mode ?? properties.trigger_mode ?? properties.triggerMode;
+    if (typeof rawMode !== 'string' || !rawMode) {
+        // 无 mode 字段时，按特征键推断
+        const hasCronKeys = pickString(properties, ['expression', 'cron', 'cron_expression', 'cronExpression']) !==
+            undefined;
+        const hasWebhookKeys = pickString(properties, ['path', 'hook_url', 'hookUrl']) !== undefined;
+        if (hasWebhookKeys)
+            return parseWebhookConfig(properties);
+        if (hasCronKeys)
+            return parseCronConfig(properties);
+        return null;
+    }
+    const mode = rawMode.toLowerCase();
+    if (mode === 'manual')
+        return { mode: 'manual' };
+    if (mode === 'cron')
+        return parseCronConfig(properties);
+    if (mode === 'webhook')
+        return parseWebhookConfig(properties);
+    return null;
+}
+function parseCronConfig(properties) {
+    const expression = pickString(properties, [
+        'expression',
+        'cron',
+        'cron_expression',
+        'cronExpression',
+    ]);
+    if (!expression)
+        return null;
+    const config = { mode: 'cron', expression };
+    const timezone = pickString(properties, ['timezone', 'time_zone', 'timeZone']);
+    if (timezone)
+        config.timezone = timezone;
+    return config;
+}
+function parseWebhookConfig(properties) {
+    const path = pickString(properties, ['path', 'hook_url', 'hookUrl']);
+    if (!path)
+        return null;
+    const rawMethod = (pickString(properties, ['http_method', 'httpMethod', 'method']) || 'POST').toUpperCase();
+    const rawResponseMode = (pickString(properties, ['response_mode', 'responseMode']) || 'IMMEDIATE').toUpperCase();
+    const config = {
+        mode: 'webhook',
+        path,
+        httpMethod: rawMethod === 'GET' ? 'GET' : 'POST',
+        responseMode: rawResponseMode === 'LAST_NODE' || rawResponseMode === 'CUSTOM'
+            ? rawResponseMode
+            : 'IMMEDIATE',
+    };
+    const responseData = pickString(properties, ['response_data', 'responseData']);
+    if (responseData !== undefined)
+        config.responseData = responseData;
+    const authRequired = pickBoolean(properties, ['auth_required', 'authRequired']);
+    if (authRequired !== undefined)
+        config.authRequired = authRequired;
+    const authHeaderName = pickString(properties, ['auth_header_name', 'authHeaderName']);
+    if (authHeaderName)
+        config.authHeaderName = authHeaderName;
+    const authHeaderValue = pickString(properties, ['auth_header_value', 'authHeaderValue']);
+    if (authHeaderValue)
+        config.authHeaderValue = authHeaderValue;
+    return config;
+}
+/**
+ * 查找连接流的触发器节点信息。
+ * flow 中无触发器节点时抛错。
+ */
+async function findTriggerNode(flowId) {
+    const flow = await (0, flow_1.getFlowDetail)(flowId);
+    const nodes = flow.nodes || [];
+    const triggerNode = nodes.find((n) => isTriggerNode(n));
+    if (!triggerNode) {
+        throw new Error(`连接流 ${flowId} 中未找到触发器节点（StartEventNode），请先通过 flow node create --trigger 创建`);
+    }
+    const nodeId = triggerNode.n_id || triggerNode.id;
+    const nodeDetail = await (0, node_1.getNodeDetail)(nodeId);
+    const envelope = (0, nodeEnvelope_1.unwrapNodeDetailEnvelope)(nodeDetail);
+    const config = parseTriggerConfig(envelope.properties);
+    return {
+        nodeId,
+        connectorId: triggerNode.connector_id,
+        connectorName: triggerNode.connector_name,
+        actionId: triggerNode.action_id,
+        actionName: triggerNode.action_name,
+        config,
+        properties: envelope.properties,
+    };
+}
+/** 将 TriggerConfig 写入节点 properties（清除旧触发器键，写入规范 snake_case 键） */
+function triggerConfigToProperties(config) {
+    const props = { mode: config.mode };
+    if (config.mode === 'cron') {
+        props.expression = config.expression;
+        if (config.timezone)
+            props.timezone = config.timezone;
+    }
+    else if (config.mode === 'webhook') {
+        props.path = config.path;
+        props.http_method = config.httpMethod;
+        props.response_mode = config.responseMode;
+        if (config.responseData !== undefined)
+            props.response_data = config.responseData;
+        if (config.authRequired !== undefined)
+            props.auth_required = config.authRequired;
+        if (config.authHeaderName !== undefined)
+            props.auth_header_name = config.authHeaderName;
+        if (config.authHeaderValue !== undefined)
+            props.auth_header_value = config.authHeaderValue;
+    }
+    return props;
+}
+/**
+ * 写入触发器配置：读取触发器节点详情 → 清除旧触发器键 →
+ * 合并新配置 → PATCH 提交（保留 position/action 等既有信封字段）。
+ */
+async function setTriggerConfig(flowId, config) {
+    const flow = await (0, flow_1.getFlowDetail)(flowId);
+    const nodes = flow.nodes || [];
+    const triggerNode = nodes.find((n) => isTriggerNode(n));
+    if (!triggerNode) {
+        throw new Error(`连接流 ${flowId} 中未找到触发器节点（StartEventNode），请先通过 flow node create --trigger 创建`);
+    }
+    const nodeId = triggerNode.n_id || triggerNode.id;
+    const nodeDetail = await (0, node_1.getNodeDetail)(nodeId);
+    if (!nodeDetail) {
+        throw new Error(`未找到节点 ${nodeId}`);
+    }
+    const envelope = (0, nodeEnvelope_1.unwrapNodeDetailEnvelope)(nodeDetail);
+    // 清除旧触发器配置键（兼容 snake/camel 及 classic 键），再写入新配置
+    const nextProperties = {};
+    for (const [key, value] of Object.entries(envelope.properties)) {
+        const lower = key.toLowerCase();
+        if (TRIGGER_WIRE_KEYS.has(key) || TRIGGER_WIRE_KEYS.has(lower))
+            continue;
+        if ([
+            'cron',
+            'cron_expression',
+            'cronexpression',
+            'hook_url',
+            'hookurl',
+            'trigger_mode',
+            'triggermode',
+        ].includes(lower)) {
+            continue;
+        }
+        nextProperties[key] = value;
+    }
+    Object.assign(nextProperties, triggerConfigToProperties(config));
+    const updatePayload = {
+        ...nodeDetail,
+        flow_id: flowId,
+        properties: nextProperties,
+    };
+    if (envelope.proxyId !== undefined)
+        updatePayload.proxy_id = envelope.proxyId;
+    if (envelope.mcpToolDescription !== undefined) {
+        updatePayload.mcp_tool_description = envelope.mcpToolDescription;
+    }
+    await (0, node_1.updateNode)(nodeId, updatePayload);
+    return {
+        nodeId,
+        connectorId: triggerNode.connector_id,
+        connectorName: triggerNode.connector_name,
+        actionId: triggerNode.action_id,
+        actionName: triggerNode.action_name,
+        config,
+        properties: nextProperties,
+    };
+}
+//# sourceMappingURL=trigger.js.map