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

package/dist/commands/flow/trigger.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerFlowTrigger = registerFlowTrigger;
+const trigger_1 = require("@/api/trigger");
+const triggerConfig_1 = require("@/services/triggerConfig");
+const output_1 = require("@/utils/output");
+function registerFlowTrigger(flowCmd) {
+    const triggerCmd = flowCmd.command('trigger').description('触发器配置操作');
+    triggerCmd
+        .command('show <flowId>')
+        .description('查看连接流的触发器配置')
+        .option('--json', '以 JSON 格式输出')
+        .action(async (flowId, options) => {
+        try {
+            if (options.json)
+                (0, output_1.setJsonMode)(true);
+            (0, output_1.printInfo)(`获取连接流 ${flowId} 的触发器配置...`);
+            const info = await (0, trigger_1.findTriggerNode)(flowId);
+            if (options.json) {
+                (0, output_1.printStructuredResult)({
+                    ok: true,
+                    data: {
+                        flowId,
+                        nodeId: info.nodeId,
+                        connectorId: info.connectorId,
+                        connectorName: info.connectorName,
+                        actionId: info.actionId,
+                        actionName: info.actionName,
+                        trigger: info.config,
+                    },
+                });
+                return;
+            }
+            (0, output_1.printHeader)(`触发器配置: ${flowId}`);
+            (0, output_1.printKeyValue)([
+                ['Flow ID', flowId],
+                ['节点 ID', info.nodeId],
+                ['连接器', info.connectorName || info.connectorId || '-'],
+                ['动作', info.actionName || info.actionId || '-'],
+            ]);
+            (0, output_1.printKeyValue)((0, triggerConfig_1.formatTriggerConfig)(info.config ?? { mode: 'manual' }));
+            if (!info.config) {
+                (0, output_1.printJson)({
+                    提示: '触发器节点尚未配置（默认 manual），可用 set-cron / set-webhook 配置',
+                });
+            }
+            (0, output_1.printSuccess)('触发器配置获取完成');
+        }
+        catch (error) {
+            if (options.json) {
+                (0, output_1.printStructuredResult)({ ok: false, message: error.message });
+            }
+            else {
+                (0, output_1.printError)(`获取触发器配置失败: ${error.message}`);
+            }
+        }
+    });
+    triggerCmd
+        .command('set-manual <flowId>')
+        .description('将触发器切换为手动触发（清除 cron/webhook 配置）')
+        .option('--json', '以 JSON 格式输出')
+        .action(async (flowId, options) => {
+        try {
+            if (options.json)
+                (0, output_1.setJsonMode)(true);
+            (0, output_1.printInfo)(`正在设置连接流 ${flowId} 为手动触发...`);
+            const info = await (0, trigger_1.setTriggerConfig)(flowId, { mode: 'manual' });
+            if (options.json) {
+                (0, output_1.printStructuredResult)({
+                    ok: true,
+                    id: info.nodeId,
+                    message: '触发器已设置为手动触发',
+                    data: { flowId, nodeId: info.nodeId, trigger: { mode: 'manual' } },
+                });
+            }
+            else {
+                (0, output_1.printSuccess)(`触发器已设置为手动触发（节点 ${info.nodeId}）`);
+            }
+        }
+        catch (error) {
+            if (options.json) {
+                (0, output_1.printStructuredResult)({ ok: false, message: error.message });
+            }
+            else {
+                (0, output_1.printError)(`设置手动触发失败: ${error.message}`);
+            }
+        }
+    });
+    triggerCmd
+        .command('set-cron <flowId>')
+        .description('配置 cron 定时触发器（Quartz 风格表达式，如 "0 0/5 * * * ?"）')
+        .requiredOption('--expression <expr>', 'Quartz cron 表达式（6-7 段：秒 分 时 日 月 周 [年]）')
+        .option('--timezone <tz>', 'IANA 时区标识（如 Asia/Shanghai），默认服务器时区')
+        .option('--json', '以 JSON 格式输出')
+        .action(async (flowId, options) => {
+        try {
+            if (options.json)
+                (0, output_1.setJsonMode)(true);
+            const result = (0, triggerConfig_1.normalizeCronTriggerConfig)({
+                expression: options.expression,
+                timezone: options.timezone,
+            });
+            if (typeof result === 'string') {
+                if (options.json)
+                    (0, output_1.printStructuredResult)({ ok: false, message: result });
+                else
+                    (0, output_1.printError)(`cron 配置校验失败: ${result}`);
+                return;
+            }
+            (0, output_1.printInfo)(`正在为连接流 ${flowId} 配置 cron 触发器...`);
+            const info = await (0, trigger_1.setTriggerConfig)(flowId, result);
+            if (options.json) {
+                (0, output_1.printStructuredResult)({
+                    ok: true,
+                    id: info.nodeId,
+                    message: 'cron 触发器配置成功',
+                    data: { flowId, nodeId: info.nodeId, trigger: result },
+                });
+            }
+            else {
+                (0, output_1.printSuccess)(`cron 触发器配置成功（节点 ${info.nodeId}）`);
+                (0, output_1.printKeyValue)((0, triggerConfig_1.formatTriggerConfig)(result));
+            }
+        }
+        catch (error) {
+            if (options.json) {
+                (0, output_1.printStructuredResult)({ ok: false, message: error.message });
+            }
+            else {
+                (0, output_1.printError)(`配置 cron 触发器失败: ${error.message}`);
+            }
+        }
+    });
+    triggerCmd
+        .command('set-webhook <flowId>')
+        .description('配置 webhook 触发器')
+        .requiredOption('--path <path>', 'webhook 路径，以 / 开头（如 /hooks/flow1）')
+        .option('--method <method>', `HTTP 方法: ${triggerConfig_1.WEBHOOK_HTTP_METHODS.join(' | ')}`, 'POST')
+        .option('--response-mode <mode>', `响应模式: ${triggerConfig_1.WEBHOOK_RESPONSE_MODES.join(' | ')}`, 'IMMEDIATE')
+        .option('--response-data <data>', 'responseMode=CUSTOM 时的自定义响应体（必填）')
+        .option('--auth-required', '启用 webhook 鉴权', false)
+        .option('--auth-header-name <name>', '鉴权 Header 名称（与 --auth-header-value 成对）')
+        .option('--auth-header-value <value>', '鉴权 Header 值（与 --auth-header-name 成对）')
+        .option('--json', '以 JSON 格式输出')
+        .action(async (flowId, options) => {
+        try {
+            if (options.json)
+                (0, output_1.setJsonMode)(true);
+            const result = (0, triggerConfig_1.normalizeWebhookTriggerConfig)({
+                path: options.path,
+                httpMethod: options.method,
+                responseMode: options.responseMode,
+                responseData: options.responseData,
+                authRequired: options.authRequired,
+                authHeaderName: options.authHeaderName,
+                authHeaderValue: options.authHeaderValue,
+            });
+            if (typeof result === 'string') {
+                if (options.json)
+                    (0, output_1.printStructuredResult)({ ok: false, message: result });
+                else
+                    (0, output_1.printError)(`webhook 配置校验失败: ${result}`);
+                return;
+            }
+            (0, output_1.printInfo)(`正在为连接流 ${flowId} 配置 webhook 触发器...`);
+            const info = await (0, trigger_1.setTriggerConfig)(flowId, result);
+            if (options.json) {
+                (0, output_1.printStructuredResult)({
+                    ok: true,
+                    id: info.nodeId,
+                    message: 'webhook 触发器配置成功',
+                    data: { flowId, nodeId: info.nodeId, trigger: result },
+                });
+            }
+            else {
+                (0, output_1.printSuccess)(`webhook 触发器配置成功（节点 ${info.nodeId}）`);
+                (0, output_1.printKeyValue)((0, triggerConfig_1.formatTriggerConfig)(result));
+            }
+        }
+        catch (error) {
+            if (options.json) {
+                (0, output_1.printStructuredResult)({ ok: false, message: error.message });
+            }
+            else {
+                (0, output_1.printError)(`配置 webhook 触发器失败: ${error.message}`);
+            }
+        }
+    });
+}
+//# sourceMappingURL=trigger.js.map

package/dist/commands/flow/validate.js

@@ -5,6 +5,9 @@ const flow_1 = require("@/api/flow");
 const output_1 = require("@/utils/output");
 const format_1 = require("@/utils/format");
 const portValidator_1 = require("@/services/portValidator");
+const flowValidator_1 = require("@/services/flowValidator");
+const helpers_1 = require("@/commands/flow/helpers");
+const nodeSchemaCache_1 = require("@/utils/nodeSchemaCache");
 function registerFlowValidate(flowCmd) {
     flowCmd
         .command('validate <flowId>')
@@ -42,6 +45,29 @@ function registerFlowValidate(flowCmd) {
                     }
                 }
             }
+            // 特殊节点（ConditionNode/LoopNode/SelfLoopNode/SwitchNode）业务字段校验
+            for (const node of nodes) {
+                const nodeType = node.node_type || 'ActionNode';
+                if (nodeType === 'ActionNode')
+                    continue;
+                const specialErrors = (0, format_1.validateSpecialNodeType)(nodeType, { properties: node.properties || {} }, node.config_schema);
+                for (const e of specialErrors) {
+                    errors.push(`节点 ${node.n_id || node.id}: [${e.rule}] ${e.message}`);
+                }
+            }
+            // 环检测 / 孤立节点 / 触发器检查
+            (0, output_1.printInfo)('正在校验流图结构（环/孤立节点/触发器）...');
+            const graphResult = (0, flowValidator_1.validateFlowGraph)({ nodes, edges });
+            for (const issue of graphResult.issues) {
+                const line = `[${issue.code}] ${issue.message}`;
+                if (issue.severity === 'error')
+                    errors.push(line);
+                else
+                    warnings.push(line);
+            }
+            // node_schema 节点 properties 字段级校验（legacy 节点自动跳过）
+            (0, output_1.printInfo)('正在校验 node_schema 节点配置字段...');
+            await validateNodeSchemaFields(nodes, errors, warnings);
             // node_schema 端口级校验（legacy 节点自动跳过）
             (0, output_1.printInfo)('正在校验节点端口连线...');
             const portResult = await (0, portValidator_1.validateFlowPorts)({ nodes, edges });
@@ -61,6 +87,7 @@ function registerFlowValidate(flowCmd) {
                     edgeCount: edges.length,
                     errors,
                     warnings,
+                    cycles: graphResult.cycles,
                     portViolations: portResult.violations,
                 });
                 return;
@@ -94,4 +121,34 @@ function registerFlowValidate(flowCmd) {
         }
     });
 }
+/**
+ * NodePackage 节点（action_key + action_ver）按 node_schema.input_fields
+ * 校验 properties（必填/类型/元数据）。schema 拉取失败的节点跳过并提示。
+ */
+async function validateNodeSchemaFields(nodes, errors, warnings) {
+    await Promise.all(nodes.map(async (node) => {
+        const nodeId = node.n_id || node.id;
+        const actionKey = node.action_key;
+        const actionVer = node.action_ver;
+        if (!actionKey || actionVer === undefined || actionVer === null)
+            return;
+        const schema = await (0, nodeSchemaCache_1.getNodePackageSchema)(String(actionKey), Number(actionVer));
+        if (!schema) {
+            warnings.push(`节点 ${nodeId} 的 node_schema (${actionKey}@${actionVer}) 获取失败，已跳过字段校验`);
+            return;
+        }
+        const inputFields = (schema.input_fields ?? []);
+        if (inputFields.length === 0)
+            return;
+        const properties = node.properties ?? {};
+        const fieldErrors = (0, helpers_1.validateNodeSchemaProperties)(properties, inputFields);
+        for (const e of fieldErrors) {
+            errors.push(`节点 ${nodeId}: [${e.rule}] ${e.message}`);
+        }
+        const proxyMisuse = (0, helpers_1.findProxyFieldMisuse)(properties, inputFields);
+        for (const msg of proxyMisuse) {
+            errors.push(`节点 ${nodeId}: ${msg}`);
+        }
+    }));
+}
 //# sourceMappingURL=validate.js.map

package/dist/commands/flow/variables.js

@@ -99,6 +99,7 @@ function registerFlowVariables(flowCmd) {
                     (0, output_1.printError)(`获取全局变量失败: ${error.message}`);
                 }
             }
+            (0, output_1.printInfo)('提示: 配置值中可通过 {{global.<key>}} 引用全局变量、{{sys_tenant_id}} / {{response.<path>}} 引用内置变量');
             (0, output_1.printSuccess)('变量查询完成');
         }
         catch (error) {

package/dist/commands/flow.js

@@ -22,6 +22,7 @@ const export_1 = require("@/commands/flow/export");
 const import_1 = require("@/commands/flow/import");
 const delete_1 = require("@/commands/flow/delete");
 const version_1 = require("@/commands/flow/version");
+const trigger_1 = require("@/commands/flow/trigger");
 function registerFlowCommand(program) {
     const flowCmd = program.command('flow').description('连接流操作');
     (0, create_1.registerFlowCreate)(flowCmd);
@@ -45,5 +46,6 @@ function registerFlowCommand(program) {
     (0, import_1.registerFlowImport)(flowCmd);
     (0, delete_1.registerFlowDelete)(flowCmd);
     (0, version_1.registerFlowVersion)(flowCmd);
+    (0, trigger_1.registerFlowTrigger)(flowCmd);
 }
 //# sourceMappingURL=flow.js.map

package/dist/constants/node-type.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRIGGER_NODE_TYPES = void 0;
+exports.isTriggerNodeType = isTriggerNodeType;
+/**
+ * 触发器类节点类型集合。
+ *
+ * 对齐 uep-service acm NodeEnum 注释：StartEventNode 为通用触发器，
+ * UserSyncAiNode / UserPushAiNode 为通讯录集成新版协议 trigger 节点。
+ * 读路径（api.trigger / flowAnalyzer / flowValidator 的 isTriggerNode）
+ * 与写路径（flow node create 的 trigger 推断 / 首节点检查）统一引用，
+ * 避免判定逻辑漂移。
+ */
+exports.TRIGGER_NODE_TYPES = new Set([
+    'StartEventNode',
+    'UserSyncAiNode',
+    'UserPushAiNode',
+]);
+/** 判断节点类型是否为触发器类（不含 START 旧数据别名与 webhook 连接器名启发式） */
+function isTriggerNodeType(type) {
+    return exports.TRIGGER_NODE_TYPES.has(type);
+}
+//# sourceMappingURL=node-type.js.map