weaver-work-cli 0.1.8 → 0.1.20

package/dist/shortcuts/caizhilian/operations/handlers/setting-storage.js

@@ -0,0 +1,364 @@
+/**
+ * caizhilian.setting-storage — 存储设置（文件设置 → 存储设置）
+ *
+ * 覆盖「文件设置 → 存储设置」页面：
+ * - 存储实例（list/get）
+ * - 存储规则（list/form/search/save/delete/enable/order）
+ *
+ * 接口（papi 端点，带 wea_link_keep_freepass=1&tenant_langType=zh_CN）：
+ * - 列实例：POST /papi/file/storage/listStorageInstance
+ * - 单实例详情：POST /papi/file/storage/getStorageInstance
+ * - 拉规则表单：GET /papi/file/storage/rule/frontComp/ruleForm
+ * - 保存规则：POST /papi/file/storage/rule/saveData
+ * - 改顺序：POST /papi/file/storage/rule/saveOrder
+ * - 改启用：POST /papi/file/storage/rule/saveOpen
+ * - 删除：POST /papi/file/storage/rule/delete
+ * - 高级搜索：POST /papi/file/storage/rule/search
+ * - 拉规则表：GET /papi/file/storage/rule/frontComp/ruleTable
+ */
+import { CaizhilianCliError, caizhilianValidationError } from '../../errors.js';
+import { caizhilianSuccess } from '../types.js';
+import { requireId } from '../shared.js';
+const ACTION = 'caizhilian.setting-storage';
+// ── 接口路径（papi 端点，需带通用 query）──────────────────────────────
+const PAPI_SUFFIX = '?wea_link_keep_freepass=1&tenant_langType=zh_CN';
+const LIST_INSTANCES_PATH = `/papi/file/storage/listStorageInstance${PAPI_SUFFIX}`;
+const GET_INSTANCE_PATH = `/papi/file/storage/getStorageInstance${PAPI_SUFFIX}`;
+const GET_RULE_FORM_PATH = `/papi/file/storage/rule/frontComp/ruleForm${PAPI_SUFFIX}`;
+const SAVE_RULE_PATH = `/papi/file/storage/rule/saveData${PAPI_SUFFIX}`;
+const SAVE_ORDER_PATH = `/papi/file/storage/rule/saveOrder${PAPI_SUFFIX}`;
+const SAVE_OPEN_PATH = `/papi/file/storage/rule/saveOpen${PAPI_SUFFIX}`;
+const DELETE_RULE_PATH = `/papi/file/storage/rule/delete${PAPI_SUFFIX}`;
+const SEARCH_RULE_PATH = `/papi/file/storage/rule/search${PAPI_SUFFIX}`;
+const GET_RULE_TABLE_PATH = `/papi/file/storage/rule/frontComp/ruleTable${PAPI_SUFFIX}`;
+// ── 辅助函数 ──────────────────────────────────────────────
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function asList(value) {
+    return Array.isArray(value) ? value : [];
+}
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+// ── 列出存储实例 ──────────────────────────────────────────
+async function listStorageInstances(args, env) {
+    const response = await env.host.request({
+        method: 'POST',
+        path: LIST_INSTANCES_PATH,
+        body: { pageNo: args.page_no || 1, pageSize: args.page_size || 20 },
+        operation: ACTION,
+    });
+    const data = asRecord(response);
+    if (!data.status && !data.success) {
+        throw new CaizhilianCliError('api', 'business_error', String(data.msg || data.message || '查询存储实例失败'), {
+            code: data.code ?? data.status,
+            details: { action: ACTION, message: String(data.msg || data.message || '查询存储实例失败') },
+            exitCode: 1,
+        });
+    }
+    const result = asRecord(data.data);
+    const instances = asList(result.data).map((item) => ({
+        id: item.id,
+        name: item.instanceName || '',
+        type: item.instanceType || '',
+        status: item.status || '',
+        create_time: item.createTime || '',
+    }));
+    return caizhilianSuccess(ACTION, {
+        total: result.total || 0,
+        page_no: args.page_no || 1,
+        page_size: args.page_size || 20,
+        instances,
+    });
+}
+// ── 获取存储实例详情 ──────────────────────────────────────
+async function getStorageInstance(args, env) {
+    const instanceId = requireId(args.id, 'id');
+    const response = await env.host.request({
+        method: 'POST',
+        path: GET_INSTANCE_PATH,
+        body: { id: instanceId, instanceType: args.instance_type },
+        operation: ACTION,
+    });
+    const data = asRecord(response);
+    if (!data.status && !data.success) {
+        throw new CaizhilianCliError('api', 'business_error', String(data.msg || data.message || '查询存储实例失败'), {
+            code: data.code ?? data.status,
+            details: { action: ACTION, message: String(data.msg || data.message || '查询存储实例失败') },
+            exitCode: 1,
+        });
+    }
+    const result = asRecord(data.data);
+    return caizhilianSuccess(ACTION, {
+        instance: {
+            id: instanceId,
+            form: result.weaForm || {},
+            enc_field_list: result.encFieldList || [],
+            read_only: result.readOnly ?? false,
+        },
+    });
+}
+// ── 拉规则表单 ──────────────────────────────────────────
+async function getRuleForm(args, env) {
+    const ruleId = args.id ? requireId(args.id, 'id') : '';
+    const url = ruleId
+        ? `${GET_RULE_FORM_PATH}&defaultRule=true&id=${ruleId}&sysStorageRule=true`
+        : `${GET_RULE_FORM_PATH}&defaultRule=true&sysStorageRule=true`;
+    const response = await env.host.request({
+        method: 'GET',
+        path: url,
+        operation: ACTION,
+    });
+    const data = asRecord(response);
+    if (!data.status && !data.success) {
+        throw new CaizhilianCliError('api', 'business_error', String(data.msg || data.message || '查询规则表单失败'), {
+            code: data.code ?? data.status,
+            details: { action: ACTION, message: String(data.msg || data.message || '查询规则表单失败') },
+            exitCode: 1,
+        });
+    }
+    const result = asRecord(data.data);
+    return caizhilianSuccess(ACTION, {
+        default_fs_rule: result.defaultFsRuleWeaForm || {},
+        fs_rule: result.fsRuleWeaForm || {},
+        default_static_rule: result.defaultStaticRuleWeaForm || {},
+    });
+}
+// ── 拉规则表 ──────────────────────────────────────────
+async function getRuleTable(args, env) {
+    const response = await env.host.request({
+        method: 'GET',
+        path: GET_RULE_TABLE_PATH,
+        operation: ACTION,
+    });
+    const data = asRecord(response);
+    if (!data.status && !data.success) {
+        throw new CaizhilianCliError('api', 'business_error', String(data.msg || data.message || '查询规则表失败'), {
+            code: data.code ?? data.status,
+            details: { action: ACTION, message: String(data.msg || data.message || '查询规则表失败') },
+            exitCode: 1,
+        });
+    }
+    const result = asRecord(data.data);
+    return caizhilianSuccess(ACTION, {
+        default_fs_rule: result.defaultFsRuleWeaForm || {},
+        fs_rule_table: result.fsRuleTable || {},
+    });
+}
+// ── 高级搜索规则 ──────────────────────────────────────────
+async function searchRules(args, env) {
+    const conditions = args.conditions || [];
+    const ruleType = args.rule_type;
+    const body = { conditionArr: conditions };
+    if (ruleType)
+        body.ruleType = ruleType;
+    const response = await env.host.request({
+        method: 'POST',
+        path: SEARCH_RULE_PATH,
+        body,
+        operation: ACTION,
+    });
+    const data = asRecord(response);
+    if (!data.status && !data.success) {
+        throw new CaizhilianCliError('api', 'business_error', String(data.msg || data.message || '搜索规则失败'), {
+            code: data.code ?? data.status,
+            details: { action: ACTION, message: String(data.msg || data.message || '搜索规则失败') },
+            exitCode: 1,
+        });
+    }
+    const result = asRecord(data.data);
+    return caizhilianSuccess(ACTION, {
+        rules: asList(result.ruleInfoList).map((item) => ({
+            id: item.id,
+            name: item.ruleName || '',
+            type: item.ruleType || '',
+            enabled: item.openStatus ?? false,
+            create_time: item.createTime || '',
+        })),
+    });
+}
+// ── 保存规则（prepare/apply）──────────────────────────────────────
+async function saveRulePrepare(args, env) {
+    const ruleInfoList = args.rule_info_list;
+    if (!Array.isArray(ruleInfoList) || ruleInfoList.length === 0) {
+        throw caizhilianValidationError('list_required', 'rule_info_list 必须是非空数组');
+    }
+    // 签发 continuation
+    const continuation = await env.continuation.issue({
+        operation: 'caizhilian.setting-storage.rule.save.apply',
+        ruleInfoList,
+        defaultRule: args.default_rule ?? false,
+    });
+    return caizhilianSuccess('caizhilian.setting-storage.rule.save.prepare', {
+        rule_info_list: ruleInfoList,
+        default_rule: args.default_rule ?? false,
+        continuation,
+    });
+}
+async function saveRuleApply(args, env, lease) {
+    const ruleInfoList = lease.payload?.ruleInfoList;
+    const defaultRule = lease.payload?.defaultRule;
+    const response = await env.host.request({
+        method: 'POST',
+        path: SAVE_RULE_PATH,
+        body: { defaultRule, ruleInfoList },
+        operation: 'caizhilian.setting-storage.rule.save.apply',
+    });
+    const data = asRecord(response);
+    if (!data.status && !data.success) {
+        throw new CaizhilianCliError('api', 'business_error', String(data.msg || data.message || '保存规则失败'), {
+            code: data.code ?? data.status,
+            details: { action: 'caizhilian.setting-storage.rule.save.apply', message: String(data.msg || data.message || '保存规则失败') },
+            exitCode: 1,
+        });
+    }
+    const result = asRecord(data.data);
+    return caizhilianSuccess('caizhilian.setting-storage.rule.save.apply', {
+        rules: asList(result.ruleInfoList).map((item) => ({
+            id: item.id,
+            name: item.ruleName || '',
+            type: item.ruleType || '',
+            enabled: item.openStatus ?? false,
+        })),
+    });
+}
+// ── 删除规则（prepare/apply）──────────────────────────────────────
+async function deleteRulePrepare(args, env) {
+    const ruleIds = args.rule_ids;
+    if (!Array.isArray(ruleIds) || ruleIds.length === 0) {
+        throw caizhilianValidationError('list_required', 'rule_ids 必须是非空数组');
+    }
+    // 签发 continuation
+    const continuation = await env.continuation.issue({
+        operation: 'caizhilian.setting-storage.rule.delete.apply',
+        ruleIds,
+    });
+    return caizhilianSuccess('caizhilian.setting-storage.rule.delete.prepare', {
+        rule_ids: ruleIds,
+        continuation,
+    });
+}
+async function deleteRuleApply(args, env, lease) {
+    const ruleIds = lease.payload?.ruleIds;
+    const response = await env.host.request({
+        method: 'POST',
+        path: DELETE_RULE_PATH,
+        body: { ruleIdList: ruleIds },
+        operation: 'caizhilian.setting-storage.rule.delete.apply',
+    });
+    const data = asRecord(response);
+    if (!data.status && !data.success) {
+        throw new CaizhilianCliError('api', 'business_error', String(data.msg || data.message || '删除规则失败'), {
+            code: data.code ?? data.status,
+            details: { action: 'caizhilian.setting-storage.rule.delete.apply', message: String(data.msg || data.message || '删除规则失败') },
+            exitCode: 1,
+        });
+    }
+    return caizhilianSuccess('caizhilian.setting-storage.rule.delete.apply', {
+        deleted: true,
+        rule_ids: ruleIds,
+    });
+}
+// ── 启停规则（prepare/apply）──────────────────────────────────────
+async function enableRulePrepare(args, env) {
+    const ruleInfoList = args.rule_info_list;
+    if (!Array.isArray(ruleInfoList) || ruleInfoList.length === 0) {
+        throw caizhilianValidationError('list_required', 'rule_info_list 必须是非空数组');
+    }
+    // 签发 continuation
+    const continuation = await env.continuation.issue({
+        operation: 'caizhilian.setting-storage.rule.enable.apply',
+        ruleInfoList,
+    });
+    return caizhilianSuccess('caizhilian.setting-storage.rule.enable.prepare', {
+        rule_info_list: ruleInfoList,
+        continuation,
+    });
+}
+async function enableRuleApply(args, env, lease) {
+    const ruleInfoList = lease.payload?.ruleInfoList;
+    const response = await env.host.request({
+        method: 'POST',
+        path: SAVE_OPEN_PATH,
+        body: { ruleInfoList },
+        operation: 'caizhilian.setting-storage.rule.enable.apply',
+    });
+    const data = asRecord(response);
+    if (!data.status && !data.success) {
+        throw new CaizhilianCliError('api', 'business_error', String(data.msg || data.message || '启停规则失败'), {
+            code: data.code ?? data.status,
+            details: { action: 'caizhilian.setting-storage.rule.enable.apply', message: String(data.msg || data.message || '启停规则失败') },
+            exitCode: 1,
+        });
+    }
+    return caizhilianSuccess('caizhilian.setting-storage.rule.enable.apply', {
+        enabled: true,
+        rule_info_list: ruleInfoList,
+    });
+}
+// ── 改顺序（prepare/apply）──────────────────────────────────────
+async function saveOrderPrepare(args, env) {
+    const ruleIdList = args.rule_ids;
+    if (!Array.isArray(ruleIdList) || ruleIdList.length === 0) {
+        throw caizhilianValidationError('list_required', 'rule_ids 必须是非空数组');
+    }
+    // 签发 continuation
+    const continuation = await env.continuation.issue({
+        operation: 'caizhilian.setting-storage.rule.order.apply',
+        ruleIdList,
+    });
+    return caizhilianSuccess('caizhilian.setting-storage.rule.order.prepare', {
+        rule_ids: ruleIdList,
+        continuation,
+    });
+}
+async function saveOrderApply(args, env, lease) {
+    const ruleIdList = lease.payload?.ruleIdList;
+    const response = await env.host.request({
+        method: 'POST',
+        path: SAVE_ORDER_PATH,
+        body: { ruleIdList },
+        operation: 'caizhilian.setting-storage.rule.order.apply',
+    });
+    const data = asRecord(response);
+    if (!data.status && !data.success) {
+        throw new CaizhilianCliError('api', 'business_error', String(data.msg || data.message || '改顺序失败'), {
+            code: data.code ?? data.status,
+            details: { action: 'caizhilian.setting-storage.rule.order.apply', message: String(data.msg || data.message || '改顺序失败') },
+            exitCode: 1,
+        });
+    }
+    return caizhilianSuccess('caizhilian.setting-storage.rule.order.apply', {
+        ordered: true,
+        rule_ids: ruleIdList,
+    });
+}
+// ── 处理器汇总 ────────────────────────────────────────────
+export const caizhilianSettingStorageHandlers = {
+    'caizhilian.setting-storage.instance.list': { execute: listStorageInstances },
+    'caizhilian.setting-storage.instance.get': { execute: getStorageInstance },
+    'caizhilian.setting-storage.rule.form': { execute: getRuleForm },
+    'caizhilian.setting-storage.rule.table': { execute: getRuleTable },
+    'caizhilian.setting-storage.rule.search': { execute: searchRules },
+    'caizhilian.setting-storage.rule.save': {
+        prepare: saveRulePrepare,
+        apply: saveRuleApply,
+        targetKeys: ['rule_info_list'],
+    },
+    'caizhilian.setting-storage.rule.delete': {
+        prepare: deleteRulePrepare,
+        apply: deleteRuleApply,
+        targetKeys: ['rule_ids'],
+    },
+    'caizhilian.setting-storage.rule.enable': {
+        prepare: enableRulePrepare,
+        apply: enableRuleApply,
+        targetKeys: ['rule_info_list'],
+    },
+    'caizhilian.setting-storage.rule.order': {
+        prepare: saveOrderPrepare,
+        apply: saveOrderApply,
+        targetKeys: ['rule_ids'],
+    },
+};

package/dist/shortcuts/caizhilian/operations/handlers/system.js

@@ -0,0 +1,106 @@
+import { CaizhilianCliError, caizhilianAuthError } from '../../errors.js';
+import { caizhilianSuccess } from '../types.js';
+/**
+ * 系统自检（1:1 对应源 scripts/system_plugins.py::CheckSystemHealthPlugin）。
+ *
+ * 源从 assets/config.json 的 health_check 块读取探测地址与判定条件：
+ *   url = /api/doc/config/getUserConfiguration?configKeys
+ *   http_code = 200, success_path = code, success_value = 200
+ * 这里把该配置固化为常量（weaver-work-cli 侧没有 config.json 可热改）。
+ */
+const HEALTH_CHECK_URL = '/api/doc/config/getUserConfiguration?configKeys';
+const HEALTH_EXPECTED_HTTP_CODE = 200;
+const HEALTH_EXPECTED_BUSINESS_CODE = 200;
+/** 源 environment.provider：CLI 侧固定为内置 E10 认证。 */
+const ENVIRONMENT_PROVIDER = 'weaver-work-cli:e10-auth';
+function round1(value) {
+    return Math.round(value * 10) / 10;
+}
+/** 源「Provider 未就绪」分支：success=false + data={environment, healthy:false}。 */
+function sessionUnavailableError(error) {
+    const message = error instanceof Error && error.message ? error.message : 'E10 登录态不可用';
+    return caizhilianAuthError('session_unavailable', message, {
+        environment: { provider: ENVIRONMENT_PROVIDER, loggedIn: false, baseUrl: '', user: '' },
+        healthy: false,
+    });
+}
+export const caizhilianSystemHandlers = {
+    'caizhilian.system.health': {
+        async execute(_args, env) {
+            const action = 'caizhilian.system.health';
+            let session;
+            try {
+                session = await env.host.getSession();
+            }
+            catch (error) {
+                throw sessionUnavailableError(error);
+            }
+            const environment = {
+                provider: ENVIRONMENT_PROVIDER,
+                loggedIn: true,
+                baseUrl: session.baseUrl,
+                user: session.userId,
+            };
+            const startedAt = process.hrtime.bigint();
+            let statusCode = 0;
+            let businessCode = null;
+            const diagnosis = [];
+            let message;
+            try {
+                const response = await env.host.request({ method: 'GET', path: HEALTH_CHECK_URL, operation: action });
+                // host.request 仅在 HTTP 2xx 且业务成功时返回，因此这里等价于源的 http_ok && resp.success。
+                statusCode = HEALTH_EXPECTED_HTTP_CODE;
+                const record = response && typeof response === 'object' ? response : {};
+                businessCode = record.code ?? null;
+                if (businessCode !== HEALTH_EXPECTED_BUSINESS_CODE)
+                    diagnosis.push('business_code_mismatch');
+            }
+            catch (error) {
+                if (error instanceof CaizhilianCliError) {
+                    message = error.message;
+                    if (error.type === 'network') {
+                        statusCode = 0;
+                        diagnosis.push('network_error');
+                    }
+                    else if (error.subtype === 'session_expired') {
+                        statusCode = Number(error.details && error.details.httpStatus) || 401;
+                        diagnosis.push('http_error', 'http_status_mismatch');
+                    }
+                    else if (error.subtype === 'http_error') {
+                        statusCode = Number(error.code) || 0;
+                        diagnosis.push('http_error');
+                        if (statusCode !== HEALTH_EXPECTED_HTTP_CODE)
+                            diagnosis.push('http_status_mismatch');
+                    }
+                    else if (error.subtype === 'business_error') {
+                        statusCode = HEALTH_EXPECTED_HTTP_CODE;
+                        businessCode = error.code ?? null;
+                        diagnosis.push('business_code_mismatch');
+                    }
+                    else {
+                        statusCode = 0;
+                        diagnosis.push('request_failed');
+                    }
+                }
+                else {
+                    message = error instanceof Error ? error.message : String(error);
+                    statusCode = 0;
+                    diagnosis.push('network_error');
+                }
+            }
+            const elapsedMs = round1(Number(process.hrtime.bigint() - startedAt) / 1e6);
+            const healthy = statusCode === HEALTH_EXPECTED_HTTP_CODE && diagnosis.length === 0;
+            return caizhilianSuccess(action, {
+                environment,
+                healthy,
+                base_url: session.baseUrl,
+                url: HEALTH_CHECK_URL,
+                status_code: statusCode,
+                business_code: businessCode,
+                diagnosis: diagnosis.length ? diagnosis.join(',') : 'ok',
+                elapsed_ms: elapsedMs,
+                ...(message ? { message } : {}),
+            }, { profile: session.profile, tenantKey: session.tenantKey });
+        },
+    },
+};

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

@@ -0,0 +1,151 @@
+import { caizhilianValidationError } from '../errors.js';
+import { assertLeaseArgs, assertLeaseTarget, verifyLease } from './confirm.js';
+import { caizhilianCollabHandlers } from './handlers/collab.js';
+import { caizhilianDocumentHandlers } from './handlers/document.js';
+import { caizhilianFileCollectionHandlers } from './handlers/file-collection.js';
+import { caizhilianFileopsHandlers } from './handlers/fileops.js';
+import { caizhilianFileUploadHandlers } from './handlers/file-upload.js';
+import { caizhilianFolderHandlers } from './handlers/folder.js';
+import { caizhilianSearchHandlers } from './handlers/search.js';
+import { caizhilianSettingAttachHandlers } from './handlers/setting-attach.js';
+import { caizhilianSettingBackupHandlers } from './handlers/setting-backup.js';
+import { caizhilianSettingEncryptHandlers } from './handlers/setting-encrypt.js';
+import { caizhilianSettingStorageHandlers } from './handlers/setting-storage.js';
+import { caizhilianSystemHandlers } from './handlers/system.js';
+import { caizhilianOperationSpecs } from './specs.js';
+import { applySchemaOf, isWriteHandler } from './types.js';
+/**
+ * 操作注册表：specs.ts 提供 WHAT（name/resource/risk/inputSchema），
+ * handlers/*.ts 提供 HOW（execute 或 prepare/apply）。
+ *
+ * 60 个 canonical spec 在这里展开成 87 条对外 operation：
+ * 33 个只读 spec → 1 条；27 个写 spec（requiresConfirmation）→ `<name>.prepare` + `<name>.apply` 2 条。
+ * 两侧必须严格一一对应：任一侧多出条目或形态不符都直接抛错，避免 schema 与实际能力漂移。
+ */
+const PREPARE_SUFFIX = '.prepare';
+const APPLY_SUFFIX = '.apply';
+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 caizhilian operation handler: ${name}`);
+            merged[name] = handler;
+        }
+    }
+    return merged;
+}
+const caizhilianHandlers = mergeHandlers([
+    caizhilianDocumentHandlers,
+    caizhilianFileCollectionHandlers,
+    caizhilianFileopsHandlers,
+    caizhilianFileUploadHandlers,
+    caizhilianFolderHandlers,
+    caizhilianSearchHandlers,
+    caizhilianCollabHandlers,
+    caizhilianSettingAttachHandlers,
+    caizhilianSettingBackupHandlers,
+    caizhilianSettingEncryptHandlers,
+    caizhilianSettingStorageHandlers,
+    caizhilianSystemHandlers,
+]);
+/** 只读 spec：直接暴露 execute。 */
+function readDefinition(spec, entry) {
+    return {
+        ...spec,
+        handler: (args, env) => entry.execute(args, env),
+    };
+}
+/** 写 spec 的 prepare：只读回查 + 组装请求体 + 签发 continuation，不产生副作用。 */
+function prepareDefinition(spec, entry) {
+    return {
+        ...spec,
+        name: `${spec.name}${PREPARE_SUFFIX}`,
+        action: `${spec.action}${PREPARE_SUFFIX}`,
+        summary: `${spec.summary}｜prepare：只读校验与请求体预览，签发 apply 所需的 continuation，不产生副作用`,
+        risk: 'read-before-write',
+        requiresConfirmation: true,
+        handler: (args, env) => entry.prepare(args, env),
+    };
+}
+/**
+ * 写 spec 的 apply：统一的确认闸门（confirm + continuation + 环境/账号 + 入参指纹 + 目标键），
+ * 通过后才调用各 handler 自己的 apply。handler 内不重复校验票据。
+ */
+function applyDefinition(spec, entry) {
+    const name = `${spec.name}${APPLY_SUFFIX}`;
+    const base = spec.inputSchema;
+    return {
+        ...spec,
+        name,
+        action: `${spec.action}${APPLY_SUFFIX}`,
+        summary: `${spec.summary}｜apply：校验 confirm + continuation 后执行，会产生服务端副作用`,
+        requiresConfirmation: true,
+        inputSchema: applySchemaOf(spec.inputSchema, base.required ?? []),
+        handler: async (args, env) => {
+            const lease = await verifyLease(args, name, env);
+            assertLeaseArgs(lease, args, name);
+            assertLeaseTarget(lease, args, entry.targetKeys ?? [], name);
+            return entry.apply(args, env, lease);
+        },
+    };
+}
+function buildRegistry() {
+    const registry = new Map();
+    const add = (definition) => {
+        if (registry.has(definition.name))
+            throw new Error(`duplicate caizhilian operation: ${definition.name}`);
+        registry.set(definition.name, definition);
+    };
+    for (const spec of caizhilianOperationSpecs) {
+        const entry = caizhilianHandlers[spec.name];
+        if (!entry)
+            throw new Error(`caizhilian operation ${spec.name} has no handler`);
+        if (isWriteHandler(entry)) {
+            if (!spec.requiresConfirmation) {
+                throw new Error(`caizhilian operation ${spec.name} 是 prepare/apply 形态，但 spec 未声明 requiresConfirmation`);
+            }
+            add(prepareDefinition(spec, entry));
+            add(applyDefinition(spec, entry));
+            continue;
+        }
+        if (spec.requiresConfirmation) {
+            throw new Error(`caizhilian operation ${spec.name} 声明了 requiresConfirmation，但 handler 只有 execute`);
+        }
+        add(readDefinition(spec, entry));
+    }
+    for (const name of Object.keys(caizhilianHandlers)) {
+        if (!caizhilianOperationSpecs.some((spec) => spec.name === name)) {
+            throw new Error(`caizhilian handler ${name} is not declared in specs`);
+        }
+    }
+    return registry;
+}
+const caizhilianRegistry = buildRegistry();
+export function caizhilianOperationDefinitions() {
+    return [...caizhilianRegistry.values()];
+}
+export function getCaizhilianOperation(operation) {
+    const definition = caizhilianRegistry.get(operation);
+    if (!definition) {
+        throw caizhilianValidationError('operation_unknown', `采知连不支持操作：${operation}`);
+    }
+    return definition;
+}
+export function hasCaizhilianOperation(operation) {
+    return caizhilianRegistry.has(operation);
+}
+/** manifest 用的契约视图（剥掉 handler）。 */
+export function caizhilianOperationContracts() {
+    return caizhilianOperationDefinitions().map((definition) => ({
+        name: definition.name,
+        resource: definition.resource,
+        summary: definition.summary,
+        risk: definition.risk,
+        ...(definition.requiresConfirmation ? { requiresConfirmation: true } : {}),
+        sourceOperation: definition.sourceOperation,
+        ...(definition.deprecatedInputAliases ? { deprecatedInputAliases: definition.deprecatedInputAliases } : {}),
+        ...(definition.permissions ? { permissions: definition.permissions } : {}),
+        inputSchema: definition.inputSchema,
+    }));
+}