digitalsee-ai-flow-cli 0.9.15 → 0.9.23-beta

package/dist/commands/flow/node.js

@@ -33,15 +33,104 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseActionIdRef = parseActionIdRef;
+exports.resolveAction = resolveAction;
 exports.registerFlowNode = registerFlowNode;
 const fs = __importStar(require("fs"));
 const flow_1 = require("@/api/flow");
 const node_1 = require("@/api/node");
+const knowledge_1 = require("@/api/knowledge");
 const flowAnalyzer_1 = require("@/services/flowAnalyzer");
 const format_1 = require("@/utils/format");
 const helpers_1 = require("@/commands/flow/helpers");
 const output_1 = require("@/utils/output");
 const exit_code_1 = require("@/constants/exit-code");
+const ACTION_ID_HELP = '动作 ID：纯数字（legacy 动作 id）、action_key（NodePackage 最新版）或 action_key@version（精确版本）';
+/**
+ * 解析 --action-id 的三种形式：
+ * - `action_key@version` → NodePackage 精确版本
+ * - 纯数字 → legacy 动作 id
+ * - `action_key` → NodePackage 最新版（version 需经列表解析）
+ */
+function parseActionIdRef(actionId) {
+    const atIndex = actionId.indexOf('@');
+    if (atIndex > 0) {
+        const key = actionId.slice(0, atIndex).trim();
+        const version = Number(actionId.slice(atIndex + 1).trim());
+        if (key && Number.isFinite(version)) {
+            return { key, version };
+        }
+    }
+    if (/^\d+$/.test(actionId)) {
+        return {};
+    }
+    return { key: actionId };
+}
+/**
+ * 按解析结果获取动作（以 RCS 为标准，旧 API 已移除）：
+ * a. `key@version` → getActionNodeSchema（NodePackage 权威 schema）
+ * b. `key`（需 linkId）→ connectable 按 link_id 解析（RCS loadConnectableNodeActions 语义），
+ *    创建身份遵循 RCS resolveClassicCreateActionId：Long id 直接用，否则 '0' 哨兵
+ *    （真实身份是 action_key + action_ver）
+ * c. 纯数字 legacy 动作 id 不再支持（/acm/actions/:id 已移除）
+ */
+async function resolveAction(actionId, ctx) {
+    const ref = parseActionIdRef(actionId);
+    if (ref.key && ref.version !== undefined) {
+        const nodeSchema = await (0, node_1.getActionNodeSchema)(ref.key, ref.version);
+        return nodeSchemaToAction(nodeSchema);
+    }
+    if (!ref.key || !ctx.linkId) {
+        return undefined;
+    }
+    const result = await (0, knowledge_1.searchNodesByCategory)({
+        mode: 'independent',
+        scene: '',
+        linkId: ctx.linkId,
+        flowId: ctx.flowId,
+        trigger: ctx.trigger || false,
+    });
+    const exact = result.items.find((candidate) => candidate.connector.id === ctx.linkId) ?? result.items[0];
+    const matched = (exact?.matched_actions ?? []).find((a) => a.action_key === ref.key);
+    if (!matched) {
+        return undefined;
+    }
+    matched.id = toClassicCreateActionId(matched);
+    if (matched.node_schema && matched.action_ver === undefined) {
+        matched.action_ver = matched.node_schema.version;
+    }
+    return matched;
+}
+/** RCS classicNodeActionIdentity：创建接口需要 Long action_id；非 Long（字符串 key 等）用 '0' 哨兵 */
+function toClassicCreateActionId(action) {
+    const raw = action.id;
+    if (raw !== undefined && raw !== null && /^\d+$/.test(String(raw))) {
+        return String(raw);
+    }
+    return '0';
+}
+/** 纯数字 id 已随旧 API 移除，给出引导文案 */
+function actionNotFoundMessage(actionId) {
+    if (/^\d+$/.test(actionId.trim())) {
+        return `未找到动作 ${actionId}：本版本不再支持纯数字动作 id，请使用 action_key 或 action_key@version（可用 knowledge actions 查看）`;
+    }
+    return `未找到动作 ${actionId}`;
+}
+function nodeSchemaToAction(nodeSchema) {
+    return {
+        // legacy 哨兵：仅创建接口需要 action_id，不能作为动作持久身份
+        id: '0',
+        backend_action_id: '0',
+        action_key: nodeSchema.key,
+        action_ver: nodeSchema.version,
+        is_trigger: false,
+        name: nodeSchema.name,
+        connector_id: '',
+        status: 'active',
+        config_schema: {},
+        node_schema: nodeSchema,
+    };
+}
 function registerFlowNode(flowCmd) {
     const nodeCmd = flowCmd.command('node').description('节点操作');
     nodeCmd
@@ -179,7 +268,7 @@ function registerFlowNode(flowCmd) {
         .description('在连接流中创建新节点')
         .requiredOption('--flow-id <flowId>', '连接流 ID')
         .requiredOption('--connector-id <connectorId>', '连接器 ID')
-        .requiredOption('--action-id <actionId>', '动作 ID')
+        .requiredOption('--action-id <actionId>', ACTION_ID_HELP)
         .option('--trigger', '作为触发器节点（流中第一个节点建议启用）', false)
         .option('--node-type <type>', '节点类型或动作类型')
         .option('--account-id <id>', '账号实例 ID（需要账号鉴权时指定）')
@@ -218,30 +307,19 @@ function registerFlowNode(flowCmd) {
             let posX = options.positionX !== undefined ? Number(options.positionX) : defaultPos.x;
             let posY = options.positionY !== undefined ? Number(options.positionY) : defaultPos.y;
             const trigger = options.trigger || options.node_type === 'StartEventNode' || false;
-            let action;
-            try {
-                action = await (0, node_1.getActionDetail)(actionId);
-            }
-            catch {
-                // 获取失败则回退到列表查找
-            }
-            if (action) {
-                if (!action.id && action.node_schema) {
-                    // 兼容旧 API：非 node package 节点要求必传 action_id，此处设为 '0' 占位
-                    action.id = '0';
-                }
-            }
-            else {
-                (0, output_1.printInfo)(`获取连接器 ${connectorId} 的动作列表...`);
-                const actions = await (0, node_1.getActions)({
-                    linkId: connectorId,
-                    flowId,
-                    trigger,
-                });
-                action = actions.find((a) => a.id === actionId);
+            (0, output_1.printInfo)(`解析动作 ${actionId}...`);
+            const action = await resolveAction(actionId, {
+                linkId: connectorId,
+                flowId,
+                trigger,
+            });
+            if (action && !action.id) {
+                // legacy 哨兵：创建接口要求必传 action_id，NodePackage 动作数字 id <=0，
+                // 此处 '0' 仅作占位，动作真实身份是 action_key + action_ver
+                action.id = '0';
             }
             if (!action) {
-                const msg = `未找到动作 ${actionId}`;
+                const msg = actionNotFoundMessage(actionId);
                 if (options.json) {
                     (0, output_1.printStructuredResult)({ ok: false, message: msg });
                 }
@@ -358,9 +436,11 @@ function registerFlowNode(flowCmd) {
             if (accountId) {
                 payload.account_id = accountId;
             }
-            if (hasNodeSchema && action.node_schema) {
-                payload.action_key = action.node_schema.key;
-                payload.action_ver = action.node_schema.version;
+            if (hasNodeSchema) {
+                // node_schema.key/version 是权威身份；action_ver 直接字段兜底
+                // （node_schema 缺失但 action_ver 存在的场景）
+                payload.action_key = action.node_schema?.key ?? action.action_key;
+                payload.action_ver = action.node_schema?.version ?? action.action_ver;
             }
             if (options.name) {
                 payload.action_name = options.name;
@@ -391,6 +471,10 @@ function registerFlowNode(flowCmd) {
             (0, output_1.printInfo)('正在创建节点...');
             const result = await (0, node_1.createNode)(payload);
             const resultObj = result;
+            // Loop/SelfLoop 需要自环边（loop → input），提示补连而不自动写流（CLI 无状态，避免隐式副作用）
+            const selfLoopHint = payload.node_type === 'LoopNode' || payload.node_type === 'SelfLoopNode'
+                ? `该节点需要自环边（loop → input），请执行: ai-flow flow edge connect --flow-id ${flowId} --source ${String(resultObj.id || '')} --target ${String(resultObj.id || '')} --source-handle loop --target-handle input`
+                : undefined;
             if (options.json) {
                 const jsonResult = {
                     ok: true,
@@ -402,6 +486,8 @@ function registerFlowNode(flowCmd) {
                     trigger,
                     position: { x: posX, y: posY },
                 };
+                if (selfLoopHint)
+                    jsonResult.hint = selfLoopHint;
                 if (options.name)
                     jsonResult.customName = options.name;
                 if (options.note !== undefined)
@@ -437,6 +523,8 @@ function registerFlowNode(flowCmd) {
                 else if (options.data)
                     pairs.push(['配置数据', '--data']);
                 (0, output_1.printKeyValue)(pairs);
+                if (selfLoopHint)
+                    (0, output_1.printInfo)(selfLoopHint);
             }
         }
         catch (error) {
@@ -461,7 +549,7 @@ function registerFlowNode(flowCmd) {
         .option('--position-y <number>', '节点 Y 坐标')
         .option('--note <text>', '节点备注')
         .option('--connector-id <connectorId>', '更换连接器 ID')
-        .option('--action-id <actionId>', '更换动作 ID')
+        .option('--action-id <actionId>', `更换动作 ID（${ACTION_ID_HELP}）`)
         .option('--account-id <id>', '更换账号实例 ID')
         .option('--error-handler-file <path>', '错误处理配置 JSON 文件')
         .option('--sample-output <json>', '设置节点样本输出，供下游节点测试时引用')
@@ -530,28 +618,38 @@ function registerFlowNode(flowCmd) {
                 return;
             const nd = nodeDetail;
             const hasNodeSchema = !!(nd.action_key && nd.action_ver);
-            // node_schema 模式：获取 action 以拿到 action_key / action_ver
-            let nodeSchemaAction;
+            // node_schema 模式：优先 getActionNodeSchema 拿权威 schema（action_key@action_ver）
+            let nodeSchema;
             if (hasNodeSchema) {
                 try {
-                    const params = {
-                        name: nd.action_key,
-                        flow_id: flowId,
-                        trigger: nd.node_type === 'StartEventNode',
-                        page: 1,
-                        size: 20,
-                    };
-                    const actions = await (0, node_1.searchActions)(params);
-                    nodeSchemaAction = actions.find((a) => a.action_key === nd.action_key);
+                    nodeSchema = await (0, node_1.getActionNodeSchema)(nd.action_key, Number(nd.action_ver));
                 }
-                catch (e) {
-                    (0, output_1.printError)(`获取 node_schema action 失败: ${e.message}`);
+                catch {
                     // 获取失败则回退到旧模式
                 }
             }
+            // --action-id 指定时按新身份解析（三种形式）
+            let replacedAction;
+            if (options.actionId) {
+                replacedAction = await resolveAction(options.actionId, {
+                    linkId: options.connectorId || nd.connector_id || undefined,
+                    flowId,
+                    trigger: nd.node_type === 'StartEventNode',
+                });
+                if (!replacedAction) {
+                    const msg = actionNotFoundMessage(options.actionId);
+                    if (options.json)
+                        (0, output_1.printStructuredResult)({ ok: false, message: msg });
+                    else
+                        (0, output_1.printError)(msg);
+                    return;
+                }
+                if (replacedAction.node_schema) {
+                    nodeSchema = replacedAction.node_schema;
+                }
+            }
             let updateData;
-            if (hasNodeSchema && nodeSchemaAction?.node_schema) {
-                const ns = nodeSchemaAction.node_schema;
+            if (nodeSchema) {
                 const existingProps = nd.properties ?? {};
                 const pos = nd.position ?? { x: 0, y: 0 };
                 updateData = {
@@ -560,8 +658,12 @@ function registerFlowNode(flowCmd) {
                     position: { ...pos },
                     action_id: options.actionId || nd.action_id,
                     account_id: options.accountId ?? nd.account_id ?? null,
-                    action_key: ns.key,
-                    action_ver: ns.version,
+                    action_key: replacedAction
+                        ? (replacedAction.node_schema?.key ?? replacedAction.action_key)
+                        : nodeSchema.key,
+                    action_ver: replacedAction
+                        ? (replacedAction.node_schema?.version ?? replacedAction.action_ver)
+                        : nodeSchema.version,
                 };
             }
             else {
@@ -631,8 +733,7 @@ function registerFlowNode(flowCmd) {
             }
             if (updateData.properties) {
                 if (hasNodeSchema) {
-                    const inputFields = (nodeSchemaAction?.node_schema?.input_fields ??
-                        []);
+                    const inputFields = (nodeSchema?.input_fields ?? []);
                     if (inputFields.length > 0) {
                         if ((0, helpers_1.checkPropertyValidation)((0, helpers_1.validateNodeSchemaProperties)(updateData.properties, inputFields), !!options.json))
                             return;

package/dist/commands/flow/offline.js

@@ -2,12 +2,31 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerFlowOffline = registerFlowOffline;
 const flow_1 = require("@/api/flow");
+const flowVersion_1 = require("@/api/flowVersion");
 const helpers_1 = require("@/commands/flow/helpers");
 const output_1 = require("@/utils/output");
+function isNotFound(error) {
+    return error.code === 'NOT_FOUND';
+}
+/** 版本化下线优先，旧后端（404）回退到 op/v2/:id/OFFLINE */
+async function offlineWithFallback(flowId) {
+    try {
+        const result = await (0, flowVersion_1.offlineFlowVersion)(flowId);
+        const opStatus = result?.op_status;
+        return typeof opStatus === 'string' && opStatus ? opStatus : 'OFFLINE';
+    }
+    catch (error) {
+        if (!isNotFound(error))
+            throw error;
+        (0, output_1.printError)('版本化下线接口不可用（404），已回退到旧版下线接口');
+        await (0, flow_1.updateFlowOpStatus)(flowId, 'OFFLINE');
+        return 'OFFLINE';
+    }
+}
 function registerFlowOffline(flowCmd) {
     flowCmd
         .command('offline <flowId>')
-        .description('下线连接流（ONLINE → OFFLINE）')
+        .description('下线连接流（ONLINE/ON_WARN → OFFLINE）')
         .option('--json', '以 JSON 格式输出')
         .action(async (flowId, options) => {
         try {
@@ -16,30 +35,38 @@ function registerFlowOffline(flowCmd) {
             const flow = await (0, flow_1.getFlowDetail)(flowId);
             const currentStatus = flow.op_status;
             if (currentStatus === 'OFFLINE' || currentStatus === 'UNPUBLISHED') {
+                const msg = `流程已处于 ${(0, helpers_1.formatOpStatus)(currentStatus)} 状态，无需重复下线`;
+                if (options.json) {
+                    (0, output_1.printStructuredResult)({ ok: false, message: msg });
+                }
+                else {
+                    (0, output_1.printWarning)(msg);
+                }
+                return;
+            }
+            if (currentStatus === 'ONLINE_ING') {
+                const msg = `流程正在升级中（${(0, helpers_1.formatOpStatus)(currentStatus)}），请等待升级完成后再执行下线`;
                 if (options.json) {
-                    (0, output_1.printStructuredResult)({
-                        ok: false,
-                        message: `流程已处于 ${(0, helpers_1.formatOpStatus)(currentStatus)} 状态，无需重复下线`,
-                    });
+                    (0, output_1.printStructuredResult)({ ok: false, message: msg });
                 }
                 else {
-                    (0, output_1.printWarning)(`流程已处于 ${(0, helpers_1.formatOpStatus)(currentStatus)} 状态，无需重复下线`);
+                    (0, output_1.printWarning)(msg);
                 }
                 return;
             }
             if (options.json) {
-                await (0, flow_1.updateFlowOpStatus)(flowId, 'OFFLINE');
+                const opStatus = await offlineWithFallback(flowId);
                 (0, output_1.printStructuredResult)({
                     ok: true,
                     id: flowId,
-                    op_status: 'OFFLINE',
+                    op_status: opStatus,
                     message: '连接流下线成功',
                 });
             }
             else {
                 (0, output_1.printInfo)(`正在下线连接流 ${flow.name || flowId}...`);
-                await (0, flow_1.updateFlowOpStatus)(flowId, 'OFFLINE');
-                (0, output_1.printSuccess)('连接流下线成功');
+                const opStatus = await offlineWithFallback(flowId);
+                (0, output_1.printSuccess)(`连接流下线成功，当前状态: ${(0, helpers_1.formatOpStatus)(opStatus)}`);
             }
         }
         catch (error) {

package/dist/commands/flow/online.js

@@ -6,7 +6,7 @@ const output_1 = require("@/utils/output");
 function registerFlowOnline(flowCmd) {
     flowCmd
         .command('online <flowId>')
-        .description('强制上线连接流')
+        .description('强制上线连接流（特殊恢复手段，跳过流程检查；常规上/下线请使用 flow publish / flow offline）')
         .option('--force', '跳过确认提示')
         .option('--json', '以 JSON 格式输出')
         .action(async (flowId, options) => {
@@ -14,8 +14,8 @@ function registerFlowOnline(flowCmd) {
             if (options.json)
                 (0, output_1.setJsonMode)(true);
             if (!options.force && !options.json) {
-                (0, output_1.printWarning)('强制上线将跳过流程检查，可能影响正在运行的任务');
-                (0, output_1.printInfo)('如需继续，请使用 --force 参数');
+                (0, output_1.printWarning)('强制上线为特殊恢复手段，将跳过流程检查，可能影响正在运行的任务');
+                (0, output_1.printInfo)('常规上/下线请使用 flow publish / flow offline；如确需强制上线，请使用 --force 参数');
                 return;
             }
             if (options.json) {
@@ -27,7 +27,7 @@ function registerFlowOnline(flowCmd) {
                 });
             }
             else {
-                (0, output_1.printInfo)(`正在强制上线连接流 ${flowId}...`);
+                (0, output_1.printInfo)(`正在强制上线连接流 ${flowId}（特殊恢复手段，常规操作请使用 flow publish）...`);
                 await (0, flow_1.onlineFlow)(flowId);
                 (0, output_1.printSuccess)('连接流强制上线成功');
             }

package/dist/commands/flow/publish.js

@@ -2,45 +2,149 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerFlowPublish = registerFlowPublish;
 const flow_1 = require("@/api/flow");
+const flowVersion_1 = require("@/api/flowVersion");
+const exit_code_1 = require("@/constants/exit-code");
 const helpers_1 = require("@/commands/flow/helpers");
+const version_1 = require("@/commands/flow/version");
 const output_1 = require("@/utils/output");
+const VERSION_NAME_MAX = 100;
+const REMARK_MAX = 500;
+function isNotFound(error) {
+    return error.code === 'NOT_FOUND';
+}
+function isForbidden(error) {
+    return error.code === 'FORBIDDEN';
+}
+/** 版本化发布优先，旧后端（404）回退到 op/v2/:id/ONLINE。返回 null 表示已走旧接口 */
+async function publishWithFallback(flowId, request) {
+    try {
+        return await (0, flowVersion_1.publishFlowVersion)(flowId, request);
+    }
+    catch (error) {
+        if (!isNotFound(error))
+            throw error;
+        (0, output_1.printError)('服务端不支持版本发布，已回退旧接口');
+        await (0, flow_1.updateFlowOpStatus)(flowId, 'ONLINE');
+        return null;
+    }
+}
 function registerFlowPublish(flowCmd) {
     flowCmd
         .command('publish <flowId>')
-        .description('发布连接流（UNPUBLISHED → ONLINE）')
+        .description('发布草稿为新版本并上线（UNPUBLISHED/OFFLINE → ONLINE）')
+        .option('--name <versionName>', '版本命名（≤100 字符）')
+        .option('--remark <remark>', '发布备注（≤500 字符）')
+        .option('--force', '跳过发布校验强制发布（可能影响运行中的任务）')
         .option('--json', '以 JSON 格式输出')
         .action(async (flowId, options) => {
         try {
             if (options.json)
                 (0, output_1.setJsonMode)(true);
+            if (options.name && options.name.length > VERSION_NAME_MAX) {
+                const msg = `版本命名不能超过 ${VERSION_NAME_MAX} 字符`;
+                if (options.json)
+                    (0, output_1.printStructuredResult)({ ok: false, message: msg });
+                else
+                    (0, output_1.printError)(msg);
+                process.exitCode = exit_code_1.ExitCode.FAILURE;
+                return;
+            }
+            if (options.remark && options.remark.length > REMARK_MAX) {
+                const msg = `发布备注不能超过 ${REMARK_MAX} 字符`;
+                if (options.json)
+                    (0, output_1.printStructuredResult)({ ok: false, message: msg });
+                else
+                    (0, output_1.printError)(msg);
+                process.exitCode = exit_code_1.ExitCode.FAILURE;
+                return;
+            }
             const flow = await (0, flow_1.getFlowDetail)(flowId);
             const currentStatus = flow.op_status;
-            if (currentStatus === 'ONLINE' || currentStatus === 'ONLINE_ING') {
+            if (currentStatus === 'ONLINE_ING') {
+                // message 需保持纯文本（--json 模式禁止 ANSI 颜色码），着色交给 printWarning/printError
+                const msg = `流程正在升级中（${helpers_1.OP_STATUS_MAP[currentStatus] || currentStatus}），请等待升级完成后再发布`;
+                if (options.json)
+                    (0, output_1.printStructuredResult)({ ok: false, message: msg });
+                else
+                    (0, output_1.printWarning)(msg);
+                process.exitCode = exit_code_1.ExitCode.FAILURE;
+                return;
+            }
+            if (currentStatus === 'ONLINE' || currentStatus === 'ON_WARN') {
+                // 版本化语义：已发布且草稿无未发布变更时无需重复发布；
+                // 旧后端（版本状态接口 404）维持旧的拦截语义
+                let alreadyLatest = true;
+                try {
+                    const status = await (0, flowVersion_1.getFlowVersionStatus)(flowId);
+                    alreadyLatest = status.published && !status.has_unpublished_changes;
+                }
+                catch (error) {
+                    if (!isNotFound(error))
+                        throw error;
+                }
+                if (alreadyLatest) {
+                    const msg = `流程已处于 ${helpers_1.OP_STATUS_MAP[currentStatus] || currentStatus} 状态且无未发布变更，无需重复发布`;
+                    if (options.json)
+                        (0, output_1.printStructuredResult)({ ok: false, message: msg });
+                    else
+                        (0, output_1.printWarning)(msg);
+                    process.exitCode = exit_code_1.ExitCode.FAILURE;
+                    return;
+                }
+            }
+            const request = {
+                version_name: options.name,
+                remark: options.remark,
+                force: options.force === true,
+            };
+            let version;
+            try {
+                version = await publishWithFallback(flowId, request);
+            }
+            catch (error) {
+                if (!options.force && !isForbidden(error)) {
+                    const hint = '发布校验未通过，可加 --force 强制发布（可能影响运行中的任务）';
+                    if (options.json) {
+                        (0, output_1.printStructuredResult)({
+                            ok: false,
+                            message: `${error.message}；${hint}`,
+                            forceAvailable: true,
+                        });
+                    }
+                    else {
+                        (0, output_1.printError)(`发布失败: ${error.message}`);
+                        (0, output_1.printWarning)(hint);
+                    }
+                    process.exitCode = exit_code_1.ExitCode.FAILURE;
+                    return;
+                }
+                throw error;
+            }
+            if (version === null) {
                 if (options.json) {
                     (0, output_1.printStructuredResult)({
-                        ok: false,
-                        message: `流程已处于 ${(0, helpers_1.formatOpStatus)(currentStatus)} 状态，无需重复发布`,
+                        ok: true,
+                        id: flowId,
+                        op_status: 'ONLINE',
+                        message: '连接流发布成功',
                     });
                 }
                 else {
-                    (0, output_1.printWarning)(`流程已处于 ${(0, helpers_1.formatOpStatus)(currentStatus)} 状态，无需重复发布`);
+                    (0, output_1.printSuccess)('连接流发布成功（旧接口）');
                 }
                 return;
             }
             if (options.json) {
-                await (0, flow_1.updateFlowOpStatus)(flowId, 'ONLINE');
-                (0, output_1.printStructuredResult)({
-                    ok: true,
-                    id: flowId,
-                    op_status: 'ONLINE',
-                    message: '连接流发布成功',
-                });
-            }
-            else {
-                (0, output_1.printInfo)(`正在发布连接流 ${flow.name || flowId}...`);
-                await (0, flow_1.updateFlowOpStatus)(flowId, 'ONLINE');
-                (0, output_1.printSuccess)('连接流发布成功');
+                (0, output_1.printStructuredResult)({ ok: true, data: version });
+                return;
             }
+            (0, output_1.printInfo)(`正在发布连接流 ${flow.name || flowId}...`);
+            (0, output_1.printSuccess)(`连接流发布成功: v${version.version_no} 已上线`);
+            (0, output_1.printKeyValue)([
+                ['版本', `v${version.version_no}`],
+                ['命名', version.version_name || '-'],
+                ['发布时间', (0, version_1.formatPublishTime)(version.publish_time)],
+            ]);
         }
         catch (error) {
             if (options.json) {
@@ -49,6 +153,7 @@ function registerFlowPublish(flowCmd) {
             else {
                 (0, output_1.printError)(`发布连接流失败: ${error.message}`);
             }
+            process.exitCode = exit_code_1.ExitCode.FAILURE;
         }
     });
 }

package/dist/commands/flow/validate.js

@@ -4,6 +4,7 @@ exports.registerFlowValidate = registerFlowValidate;
 const flow_1 = require("@/api/flow");
 const output_1 = require("@/utils/output");
 const format_1 = require("@/utils/format");
+const portValidator_1 = require("@/services/portValidator");
 function registerFlowValidate(flowCmd) {
     flowCmd
         .command('validate <flowId>')
@@ -41,6 +42,16 @@ function registerFlowValidate(flowCmd) {
                     }
                 }
             }
+            // node_schema 端口级校验（legacy 节点自动跳过）
+            (0, output_1.printInfo)('正在校验节点端口连线...');
+            const portResult = await (0, portValidator_1.validateFlowPorts)({ nodes, edges });
+            for (const v of portResult.violations) {
+                const label = `边 ${v.edgeId || `${v.sourceNodeId}→${v.targetNodeId}`}`;
+                errors.push(`[端口/${v.code}] ${label}: ${v.message}`);
+            }
+            for (const u of portResult.unresolvedNodes) {
+                warnings.push(`节点 ${u.nodeId} 的 node_schema (${u.actionKey}@${u.actionVer}) 获取失败，已跳过端口校验`);
+            }
             if (options.json) {
                 (0, output_1.printStructuredResult)({
                     ok: errors.length === 0,
@@ -50,6 +61,7 @@ function registerFlowValidate(flowCmd) {
                     edgeCount: edges.length,
                     errors,
                     warnings,
+                    portViolations: portResult.violations,
                 });
                 return;
             }