weaver-work-cli 0.1.2 → 0.1.5

package/dist/shortcuts/esb/continuation.js

@@ -0,0 +1,70 @@
+import { createHmac, randomBytes, timingSafeEqual } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+import { esbValidationError } from './errors.js';
+function stateRoot(ctx) {
+    const configured = ctx?.config?.path();
+    if (configured)
+        return resolve(configured, '..');
+    return process.env.WEAVER_WORK_CLI_HOME || process.env.WORK_CLI_HOME || resolve(homedir(), '.weaver-work-cli');
+}
+async function loadKey(ctx) {
+    const keysDir = resolve(stateRoot(ctx), 'keys');
+    const filename = resolve(keysDir, 'esb-continuation.key');
+    await mkdir(keysDir, { recursive: true, mode: 0o700 });
+    if (existsSync(filename))
+        return readFile(filename);
+    const key = randomBytes(32);
+    try {
+        await writeFile(filename, key, { flag: 'wx', mode: 0o600 });
+        if (process.platform !== 'win32')
+            await chmod(filename, 0o600).catch(() => undefined);
+        return key;
+    }
+    catch {
+        return readFile(filename);
+    }
+}
+function encode(value) {
+    return Buffer.from(JSON.stringify(value)).toString('base64url');
+}
+function signature(payload, key) {
+    return createHmac('sha256', key).update(payload).digest('base64url');
+}
+export function createEsbContinuationSigner(ctx) {
+    return {
+        async issue(payload, ttlMs = 10 * 60_000) {
+            const issuedAt = Date.now();
+            const body = encode({ ...payload, issuedAt, expiresAt: issuedAt + ttlMs });
+            const sig = signature(body, await loadKey(ctx));
+            return `${body}.${sig}`;
+        },
+        async verify(token, expectedOperation) {
+            if (typeof token !== 'string' || !token.includes('.')) {
+                throw esbValidationError('continuation_invalid', 'continuation 无效');
+            }
+            const [body, provided] = token.split('.');
+            const expected = signature(body, await loadKey(ctx));
+            const valid = provided.length === expected.length
+                && timingSafeEqual(Buffer.from(provided), Buffer.from(expected));
+            if (!valid)
+                throw esbValidationError('continuation_invalid', 'continuation 签名校验失败');
+            let value;
+            try {
+                value = JSON.parse(Buffer.from(body, 'base64url').toString('utf8'));
+            }
+            catch {
+                throw esbValidationError('continuation_invalid', 'continuation 内容无法解析');
+            }
+            if (value.operation !== expectedOperation) {
+                throw esbValidationError('continuation_mismatch', 'continuation 不属于当前操作');
+            }
+            if (!Number.isSafeInteger(value.expiresAt) || value.expiresAt < Date.now()) {
+                throw esbValidationError('continuation_expired', 'continuation 已过期');
+            }
+            return value;
+        },
+    };
+}

package/dist/shortcuts/esb/errors.js

@@ -0,0 +1,65 @@
+import { CliError, ExitCode } from '../../core/errors.js';
+export class EsbCliError extends CliError {
+    type;
+    subtype;
+    code;
+    retryable;
+    stage;
+    details;
+    constructor(type, subtype, message, options = {}) {
+        super(message, options.exitCode ?? ExitCode.InternalError);
+        this.name = 'EsbCliError';
+        this.type = type;
+        this.subtype = subtype;
+        this.code = options.code;
+        this.retryable = options.retryable ?? false;
+        this.stage = options.stage;
+        this.details = options.details;
+    }
+}
+export function esbValidationError(subtype, message, details) {
+    return new EsbCliError('validation', subtype, message, {
+        details,
+        exitCode: ExitCode.UsageError,
+    });
+}
+export function esbAuthError(subtype, message, details) {
+    return new EsbCliError('authentication', subtype, message, {
+        details,
+        exitCode: ExitCode.AuthError,
+    });
+}
+export function esbNetworkError(subtype, message, options = {}) {
+    return new EsbCliError('network', subtype, message, {
+        ...options,
+        retryable: options.retryable ?? true,
+        exitCode: ExitCode.NetworkError,
+    });
+}
+/** 服务端返回的业务失败（HTTP 已成功、resultCode 非 200）。 */
+export function esbApiError(subtype, message, options = {}) {
+    return new EsbCliError('api', subtype, message, {
+        ...options,
+        retryable: options.retryable ?? false,
+        exitCode: ExitCode.GeneralError,
+    });
+}
+/**
+ * 触发动作流是写操作：请求已发出但结果未知（网络中断、超时、连接被中断）时，
+ * 无法判断动作流是否已经执行，必须标记为结果不确定并禁止自动重试。
+ */
+export function esbWriteUncertain(message, details) {
+    return new EsbCliError('partial', 'write_uncertain', message, {
+        retryable: false,
+        exitCode: ExitCode.Partial,
+        details,
+    });
+}
+/** 权限/租户类业务失败，单独给出 subtype 便于 Agent 直接给出处置建议。 */
+export function esbPermissionError(subtype, message, options = {}) {
+    return new EsbCliError('api', subtype, message, {
+        ...options,
+        retryable: false,
+        exitCode: ExitCode.GeneralError,
+    });
+}

package/dist/shortcuts/esb/host.js

@@ -0,0 +1,187 @@
+import { requireE10Session } from '../../internal/e10/context.js';
+import { getActiveProfile } from '../../internal/e10/auth/session.js';
+import { E10ApiError, createE10RequestRuntime } from '../../internal/e10/request-runtime.js';
+import { EsbCliError, esbApiError, esbAuthError, esbNetworkError, esbPermissionError, esbValidationError, esbWriteUncertain, } from './errors.js';
+/** 源接口文档给出的去域名路径；域名与认证由 E10 会话层托管。 */
+export const ESB_PATHS = {
+    inputFormat: '/api/bs/esb/setting/customData/application/copyCustomData',
+    trigger: '/api/esb/server/event/triggerActionFlow',
+};
+/**
+ * triggerActionFlow 的 resultCode 语义，逐条取自源接口文档「错误码对照表」。
+ * 未列出的码回落到 business_error，并把服务端 resultMsg 原样带出。
+ */
+const TRIGGER_RESULT_CODES = {
+    100: { subtype: 'parameter_invalid' },
+    101: { subtype: 'batch_key_invalid' },
+    201: { subtype: 'flow_not_bound' },
+    202: { subtype: 'execute_failed' },
+    203: { subtype: 'execute_timeout', retryable: true },
+    204: { subtype: 'permission_denied', permission: true },
+    400: { subtype: 'license_required' },
+    401: { subtype: 'tenant_permission_denied', permission: true },
+    402: { subtype: 'flow_disabled' },
+    403: { subtype: 'tenant_missing', permission: true },
+    404: { subtype: 'flow_not_found' },
+    500: { subtype: 'execute_failed' },
+    501: { subtype: 'result_fetch_failed', retryable: true },
+    502: { subtype: 'result_fetch_timeout', retryable: true },
+    505: { subtype: 'flow_running', retryable: true },
+    506: { subtype: 'execution_loop_conflict' },
+    507: { subtype: 'throttled', retryable: true },
+    508: { subtype: 'throttled', retryable: true },
+    509: { subtype: 'execution_terminated' },
+    510: { subtype: 'memory_exceeded' },
+    511: { subtype: 'throttled', retryable: true },
+    512: { subtype: 'flow_in_recycle_bin' },
+};
+/** 「目标动作流本身不可用」的错误：prepare 阶段回查命中时必须阻断。 */
+export const TARGET_FATAL_SUBTYPES = new Set([
+    'flow_not_found',
+    'flow_not_bound',
+    'flow_disabled',
+    'flow_in_recycle_bin',
+    'parameter_invalid',
+]);
+export function isEsbFlowUnavailable(error) {
+    return error instanceof EsbCliError && TARGET_FATAL_SUBTYPES.has(error.subtype);
+}
+export function triggerResultCode(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const raw = value.resultCode;
+    if (raw === undefined || raw === null || raw === '')
+        return undefined;
+    const numeric = Number(raw);
+    return Number.isFinite(numeric) ? numeric : undefined;
+}
+function assertPath(requestPath) {
+    if (typeof requestPath !== 'string' || !requestPath.startsWith('/') || requestPath.startsWith('//')) {
+        throw esbValidationError('path_invalid', '请求路径必须是相对绝对路径');
+    }
+    if (/^https?:/i.test(requestPath) || /[\r\n]/.test(requestPath) || requestPath.includes('/../')) {
+        throw esbValidationError('path_invalid', '请求路径不允许跨域或路径逃逸');
+    }
+    if (!requestPath.startsWith('/api/')) {
+        throw esbValidationError('path_not_allowed', 'ESB 动作流只能调用 /api/ 路径');
+    }
+}
+function mapRuntimeNetworkError(error) {
+    if (error instanceof E10ApiError && error.type === 'network') {
+        throw esbNetworkError(error.subtype, error.message, {
+            retryable: error.retryable,
+            details: error.details,
+        });
+    }
+    throw error;
+}
+export function createEsbHost(ctx, dependencies = {}) {
+    let e10Session = null;
+    let sessionContext = null;
+    const requireSession = dependencies.requireSession || requireE10Session;
+    async function ensureSession() {
+        if (!e10Session) {
+            e10Session = await requireSession(ctx);
+            sessionContext = {
+                baseUrl: e10Session.getBaseUrl(),
+                profile: ctx.getGlobalOptions().profile || getActiveProfile(),
+                userId: e10Session.userId,
+                tenantKey: e10Session.tenantKey,
+                eteamsId: e10Session.eteamsId,
+            };
+        }
+        return e10Session;
+    }
+    async function getSession() {
+        await ensureSession();
+        return sessionContext;
+    }
+    async function runtime() {
+        return createE10RequestRuntime(ctx, await ensureSession(), { fetch: dependencies.fetch });
+    }
+    async function send(operation, path, body) {
+        assertPath(path);
+        let response;
+        try {
+            response = await (await runtime()).requestJson({
+                module: 'esb',
+                operation,
+                method: 'POST',
+                path,
+                body,
+                headers: { 'X-Requested-With': 'XMLHttpRequest' },
+                timeoutMs: 60_000,
+            });
+        }
+        catch (error) {
+            mapRuntimeNetworkError(error);
+        }
+        if (response.status === 401 || response.status === 302) {
+            throw esbAuthError('session_expired', 'E10 登录态已失效，请先确认 E10 登录域名，再运行 weaver-work-cli auth login --base-url <域名> 完成登录', { httpStatus: response.status });
+        }
+        if (response.parseError) {
+            if (response.status < 200 || response.status >= 300) {
+                throw esbApiError('http_error', `泛微接口 HTTP ${response.status}`, {
+                    code: response.status,
+                    details: { status: response.status },
+                });
+            }
+            throw esbNetworkError('protocol', `接口返回不是合法 JSON（HTTP ${response.status}）`, { retryable: false });
+        }
+        if (response.status < 200 || response.status >= 300) {
+            throw esbApiError('http_error', `泛微接口 HTTP ${response.status}`, {
+                code: response.status,
+                details: { status: response.status },
+            });
+        }
+        return response.value;
+    }
+    function assertTriggerSuccess(value, operation) {
+        const code = triggerResultCode(value);
+        const record = (value && typeof value === 'object' ? value : {});
+        const serverMessage = typeof record.resultMsg === 'string' ? record.resultMsg.trim() : '';
+        if (code === undefined) {
+            throw esbNetworkError('protocol', '触发接口未返回 resultCode，无法判定执行结果', {
+                retryable: false,
+                details: { operation },
+            });
+        }
+        if (code === 200)
+            return value;
+        const rule = TRIGGER_RESULT_CODES[code] || { subtype: 'business_error' };
+        const message = serverMessage || `动作流执行失败（resultCode=${code}）`;
+        const options = {
+            code,
+            retryable: rule.retryable ?? false,
+            details: { operation, resultCode: code, resultMsg: serverMessage },
+        };
+        if (rule.permission)
+            throw esbPermissionError(rule.subtype, message, options);
+        throw esbApiError(rule.subtype, message, options);
+    }
+    return {
+        async inputFormat(applicationId) {
+            const value = await send('esb.input-format', ESB_PATHS.inputFormat, { applicationId });
+            const code = triggerResultCode(value);
+            // 该接口正常返回模板对象（无 resultCode 信封）；若平台改为统一错误信封则按错误码处理。
+            if (code !== undefined && code !== 200)
+                assertTriggerSuccess(value, 'esb.input-format');
+            return value;
+        },
+        async trigger(payload) {
+            let value;
+            try {
+                value = await send('esb.trigger.apply', ESB_PATHS.trigger, payload);
+            }
+            catch (error) {
+                // 写操作已发出但结果未知：不得判定为「未执行」，也不得自动重试。
+                if (error instanceof EsbCliError && error.type === 'network') {
+                    throw esbWriteUncertain(`触发请求已发出但未取得结果（${error.subtype}）：无法确认动作流是否已执行，请先在 ESB 中心查看动作流运行日志后再决定是否重试`, { cause: error.message });
+                }
+                throw error;
+            }
+            return assertTriggerSuccess(value, 'esb.trigger.apply');
+        },
+        getSession,
+    };
+}

package/dist/shortcuts/esb/index.js

@@ -0,0 +1,112 @@
+import { readFile } from 'node:fs/promises';
+import { ExitCode, isCliError, toErrorEnvelope } from '../../core/errors.js';
+import { createEsbContinuationSigner } from './continuation.js';
+import { createEsbHost } from './host.js';
+import { esbManifest } from './manifest.js';
+import { executeEsbOperation } from './operations.js';
+import { esbValidationError } from './errors.js';
+function asOptions(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}
+/**
+ * Windows PowerShell 的管道与 Set-Content -Encoding utf8 会在内容前写入 UTF-8 BOM，
+ * 且可能重复写入多次；JSON.parse 不接受前导 BOM，必须先剥离。
+ */
+function stripBom(value) {
+    return value.replace(/^\uFEFF+/, '');
+}
+export async function inputFrom(options, extra = {}) {
+    const opts = asOptions(options);
+    let input = {};
+    if (opts.input && opts.inputJson) {
+        throw esbValidationError('input_conflict', '不能同时传 --input 和 --input-json');
+    }
+    if (opts.inputJson) {
+        input = parseJsonInput(String(opts.inputJson), '--input-json');
+    }
+    if (opts.input) {
+        let raw;
+        try {
+            raw = stripBom(opts.input === '-' ? await readStdin() : await readFile(String(opts.input), 'utf8'));
+        }
+        catch {
+            throw esbValidationError('input_unreadable', `无法读取 --input：${String(opts.input)}`);
+        }
+        input = parseJsonInput(raw, '--input');
+    }
+    return {
+        ...input,
+        ...Object.fromEntries(Object.entries(extra).filter(([, value]) => value !== undefined && value !== '')),
+    };
+}
+function parseJsonInput(raw, label) {
+    try {
+        const parsed = JSON.parse(stripBom(raw));
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            throw new Error('input must be an object');
+        }
+        return parsed;
+    }
+    catch {
+        throw esbValidationError('input_invalid', `${label} 不是合法 JSON 对象`);
+    }
+}
+export function successEnvelope(operation, result) {
+    return {
+        schemaVersion: 1,
+        ok: true,
+        operation,
+        data: result.data === undefined ? null : result.data,
+        ...(result.meta ? { meta: result.meta } : {}),
+        warnings: result.warnings ?? [],
+    };
+}
+function failureEnvelope(error) {
+    return {
+        schemaVersion: 1,
+        ok: false,
+        error: toErrorEnvelope(error),
+    };
+}
+async function executeAndPrint(ctx, operation, input) {
+    try {
+        const result = await executeEsbOperation(operation, input, {
+            ctx,
+            host: createEsbHost(ctx),
+            continuation: createEsbContinuationSigner(ctx),
+        });
+        ctx.output.write(successEnvelope(operation, result), { json: true });
+    }
+    catch (error) {
+        console.error(JSON.stringify(failureEnvelope(error), null, 2));
+        process.exitCode = isCliError(error) ? error.exitCode : ExitCode.GeneralError;
+    }
+}
+export const esbShortcut = {
+    name: 'esb',
+    description: '泛微E10 ESB 中心自定义触发动作流 CLI',
+    category: 'shortcut',
+    register({ program, action }) {
+        const esb = program.command('esb').description('泛微E10 ESB 中心自定义触发动作流（取入参模板 / 确认后触发）');
+        esb.command('schema')
+            .description('Print esb operation manifest for agents')
+            .action(action((ctx) => {
+            ctx.output.write(esbManifest, { json: true });
+        }));
+        esb.command('run')
+            .description('Run an esb operation with JSON input')
+            .argument('<operation>', 'operation name, e.g. esb.trigger.prepare')
+            .option('--input <path>', 'JSON input file, or - for stdin')
+            .option('--input-json <json>', 'inline JSON input object')
+            .action(action(async (ctx, operation, options) => {
+            await executeAndPrint(ctx, String(operation), await inputFrom(options));
+        }));
+    },
+};

package/dist/shortcuts/esb/manifest.js

@@ -0,0 +1,91 @@
+/** 动作流 ID 在源资料示例中为长整型数字串，一律按字符串传递，避免精度丢失。 */
+const flowId = { type: 'string', pattern: '^\\d+$', minLength: 1, maxLength: 32 };
+/**
+ * customParams 及 mainTable 的子字段名由目标动作流定义（主表字段、detail1/detail2 明细表），
+ * 无法在 schema 中穷举，因此这两层不设 additionalProperties: false；顶层输入仍然严格禁止额外字段。
+ */
+const customParams = {
+    type: 'object',
+    minProperties: 1,
+    properties: {
+        mainTable: { type: 'object' },
+    },
+    required: ['mainTable'],
+    description: '动作流自定义输入参数，须包含 mainTable；主表与明细表字段以 esb.input-format 返回的模板为准',
+};
+const triggerProperties = {
+    esbFlowId: { ...flowId, description: '普通触发：动作流 ID（esbFlowId）' },
+    uniqueIndent: {
+        type: 'string',
+        minLength: 1,
+        maxLength: 128,
+        description: '唯一值触发：动作流唯一值，取值为 esb_application.primary_key（需在 esb_setting 库查得后传入）',
+    },
+    employeeId: { type: 'string', minLength: 1, maxLength: 64, description: '触发人员 ID（必填）' },
+    customParams,
+    moduleSource: { type: 'string', minLength: 1, maxLength: 64, description: '触发来源标识，默认不要传；仅二开场景传 ecode' },
+};
+export const esbOperations = [
+    {
+        name: 'esb.input-format',
+        summary: '按 applicationId 获取自定义触发动作流的入参模板（只读，无副作用）',
+        risk: 'read',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                applicationId: { ...flowId, description: '动作流 ID（与触发接口的 esbFlowId 指向同一动作流）' },
+            },
+            required: ['applicationId'],
+        },
+    },
+    {
+        name: 'esb.trigger.prepare',
+        summary: '触发前的只读回查与请求体组装，签发 apply 所需的 continuation（不产生业务副作用）',
+        risk: 'read-before-write',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: triggerProperties,
+            required: ['employeeId', 'customParams'],
+            oneOf: [{ required: ['esbFlowId'] }, { required: ['uniqueIndent'] }],
+        },
+    },
+    {
+        name: 'esb.trigger.apply',
+        summary: '按 continuation 执行动作流触发（高风险写操作，可能产生业务副作用）',
+        risk: 'high-risk-write',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                continuation: { type: 'string', minLength: 1, description: 'esb.trigger.prepare 返回的 continuation，有效期 10 分钟' },
+                confirm: { const: true, description: '必须显式为 true，表示用户已确认执行该动作流' },
+            },
+            required: ['continuation', 'confirm'],
+        },
+    },
+];
+export const esbManifest = {
+    schemaVersion: 1,
+    name: 'esb',
+    title: '泛微E10 ESB动作流执行',
+    version: '0.1.0',
+    host: 'e10-esb',
+    status: 'builtin',
+    sourceSkill: 'weaver-e10-customesb-execute',
+    operations: esbOperations,
+    withheldOperations: [
+        {
+            name: 'esb.actionflow.resolve',
+            reason: '按动作流名称解析 esbFlowId 需要 ESB 中心动作流列表查询接口，源资料未给出该接口的路径、请求字段与返回结构，无法安全实现；请用户直接提供动作流 ID。',
+        },
+        {
+            name: 'esb.unique-indent.resolve',
+            reason: '唯一值触发所需的 primary_key 需直接查询 esb_setting 库（SELECT primary_key FROM esb_application WHERE id = ?），CLI 没有数据库通道，只能由调用方查得后通过 uniqueIndent 传入。',
+        },
+    ],
+};
+export function hasEsbOperation(operation) {
+    return esbOperations.some((item) => item.name === operation);
+}

package/dist/shortcuts/esb/operations/input-format.js

@@ -0,0 +1,31 @@
+import { esbSuccess } from './types.js';
+import { collectPlaceholders, flowIdString } from './shared.js';
+function normalizeTemplate(raw, applicationId) {
+    const record = raw && typeof raw === 'object' && !Array.isArray(raw) ? raw : {};
+    const customParams = record.customParams ?? null;
+    const esbFlowId = record.esbFlowId === undefined || record.esbFlowId === null
+        ? applicationId
+        : String(record.esbFlowId);
+    const moduleSource = typeof record.moduleSource === 'string' && record.moduleSource.trim()
+        ? record.moduleSource.trim()
+        : 'AISKILL';
+    const optionalFields = collectPlaceholders(customParams);
+    const warnings = [];
+    if (customParams === null) {
+        warnings.push('接口未返回 customParams：请确认该动作流是否配置了自定义入参模板，未配置时按目标动作流要求直接组装 mainTable');
+    }
+    if (optionalFields.length > 0) {
+        warnings.push(`模板含 ${optionalFields.length} 个 #可选 占位字段，触发时替换为真实业务值或删除不需要的字段`);
+    }
+    return {
+        template: { applicationId, esbFlowId, moduleSource, customParams, optionalFields },
+        warnings,
+    };
+}
+export const esbInputFormatHandlers = {
+    'esb.input-format': async (input, { host }) => {
+        const applicationId = flowIdString(input.applicationId, 'applicationId');
+        const { template, warnings } = normalizeTemplate(await host.inputFormat(applicationId), applicationId);
+        return esbSuccess('esb.input-format', template, { status: 'COMPLETE' }, warnings);
+    },
+};

package/dist/shortcuts/esb/operations/registry.js

@@ -0,0 +1,48 @@
+import { esbManifest } from '../manifest.js';
+import { esbValidationError } from '../errors.js';
+import { esbInputFormatHandlers } from './input-format.js';
+import { esbTriggerHandlers } from './trigger.js';
+function mergeHandlers(maps) {
+    const merged = {};
+    for (const map of maps) {
+        for (const [name, handler] of Object.entries(map)) {
+            if (merged[name])
+                throw new Error(`duplicate esb operation handler: ${name}`);
+            merged[name] = handler;
+        }
+    }
+    return merged;
+}
+const esbHandlers = mergeHandlers([esbInputFormatHandlers, esbTriggerHandlers]);
+/**
+ * manifest 提供 WHAT（name/summary/risk/inputSchema），handler 提供 HOW。
+ * 两侧必须严格一一对应：任一侧多出条目都直接抛错，避免 schema 与实际能力漂移。
+ */
+function buildRegistry() {
+    const registry = new Map();
+    for (const contract of esbManifest.operations) {
+        const handler = esbHandlers[contract.name];
+        if (!handler)
+            throw new Error(`esb operation ${contract.name} has no handler`);
+        registry.set(contract.name, { ...contract, handler });
+    }
+    for (const name of Object.keys(esbHandlers)) {
+        if (!registry.has(name))
+            throw new Error(`esb handler ${name} is not declared in manifest`);
+    }
+    return registry;
+}
+const esbOperationRegistry = buildRegistry();
+export function esbOperationDefinitions() {
+    return [...esbOperationRegistry.values()];
+}
+export function getEsbOperation(operation) {
+    const definition = esbOperationRegistry.get(operation);
+    if (!definition) {
+        throw esbValidationError('operation_unknown', `ESB 动作流不支持操作：${operation}`);
+    }
+    return definition;
+}
+export function hasEsbOperation(operation) {
+    return esbOperationRegistry.has(operation);
+}