weaver-work-cli 0.1.7 → 0.1.20

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

@@ -0,0 +1,318 @@
+import { hasNextPage, optionalId, optionalText, parsePage, resolveTimeRange, toBoolean, } from '../shared.js';
+import { caizhilianSuccess } from '../types.js';
+/**
+ * 检索类只读操作（1:1 对应源 scripts/search_plugins.py 的 10 个 plugin
+ * + scripts/doc_compare_plugins.py 的 search_doc_compare_documents）。
+ */
+/** 源 _plugin_helpers.DOC_OUTPUT_DIRECT_KEYS。 */
+const DOC_OUTPUT_DIRECT_KEYS = [
+    'id',
+    'name',
+    'docCreateTime',
+    'docLastUpdateTime',
+    'docAuthorId',
+    'docAuthorName',
+    'docCreatorId',
+    'docCreatorName',
+    'folderPathName',
+    'belongFolderIds',
+];
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+/** 源 get_nested_value(data, "data.list")：取不到或非列表时按空列表处理。 */
+function nestedList(response, ...keys) {
+    let current = response;
+    for (const key of keys) {
+        if (!isRecord(current))
+            return [];
+        current = current[key];
+    }
+    return Array.isArray(current) ? current : [];
+}
+function nestedValue(response, ...keys) {
+    let current = response;
+    for (const key of keys) {
+        if (!isRecord(current))
+            return undefined;
+        current = current[key];
+    }
+    return current;
+}
+/** 源 _plugin_helpers.build_search_doc：白名单直取字段 + docMetadata 派生字段。 */
+export function buildSearchDoc(item) {
+    const doc = {};
+    for (const key of DOC_OUTPUT_DIRECT_KEYS)
+        doc[key] = item[key] ?? null;
+    const meta = isRecord(item.docMetadata) ? item.docMetadata : {};
+    doc.type = meta.type ?? '';
+    doc.size = meta.fileSize ?? '';
+    doc.docStatus = meta.docStatus ?? null;
+    doc.docStatusName = meta.docStatusName ?? item.docStatusName ?? '';
+    return doc;
+}
+/** 文档检索结果分页封装（源 search_documents / search_doc_compare_documents 共用输出结构）。 */
+function documentPage(action, response, pageNo, pageSize) {
+    const raw = nestedList(response, 'data', 'list');
+    return caizhilianSuccess(action, {
+        total: nestedValue(response, 'data', 'total') ?? null,
+        page_no: pageNo,
+        page_size: pageSize,
+        has_next: raw.length >= pageSize,
+        documents: raw.filter(isRecord).map(buildSearchDoc),
+    });
+}
+/** 源 create_time 条件：不支持的取值直接报错（源 resolve_condition_time_range 返回 None 分支）。 */
+function timeCondition(args, field = 'create_time') {
+    const value = optionalText(args[field], field);
+    if (!value)
+        return undefined;
+    return { id: field, type: 'date', value: resolveTimeRange(value, field) };
+}
+// ── caizhilian.document.search ────────────────────────────
+async function searchDocuments(args, env) {
+    const action = 'caizhilian.document.search';
+    const { pageNo, pageSize } = parsePage(args, 40);
+    const body = {
+        viewType: 'list',
+        dimension: 'ALL',
+        includeBelongFolders: true,
+        order: { property: 'default', direction: 'ASC' },
+        searchType: 'all',
+        isSearch: true,
+        pageNo,
+        pageSize,
+    };
+    const keywords = optionalText(args.keywords, 'keywords');
+    if (keywords) {
+        body.keywords = keywords;
+        body.filter = { keywords, type: 'all' };
+    }
+    else {
+        body.filter = { keywords: '', type: 'all' };
+    }
+    const folderId = optionalId(args.folder_id, 'folder_id');
+    if (folderId !== undefined) {
+        body.folder = { id: folderId };
+        // 源逻辑：仅当调用方显式传了 include_sub_folder 才带上该字段。
+        if (args.include_sub_folder !== undefined && args.include_sub_folder !== null) {
+            body.includeSubFolder = toBoolean(args.include_sub_folder);
+        }
+    }
+    const conditions = [];
+    const createTime = timeCondition(args);
+    if (createTime)
+        conditions.push(createTime);
+    const creator = optionalId(args.creator_user_id, 'creator_user_id');
+    if (creator)
+        conditions.push({ id: 'creator', operate: 'eq', type: 'array', value: creator });
+    body.conditions = conditions;
+    const response = await env.host.request({ method: 'POST', path: '/api/doc/documents/list', body, operation: action });
+    return documentPage(action, response, pageNo, pageSize);
+}
+// ── caizhilian.folder.search-virtual ──────────────────────
+/** 源 SearchVirtualFoldersPlugin._CONTENT_RE：content 形如 "名称[路径]"。 */
+const VIRTUAL_CONTENT_RE = /^([^\[]+)\[(.+)\]$/;
+async function searchVirtualFolders(args, env) {
+    const action = 'caizhilian.folder.search-virtual';
+    const { pageNo, pageSize } = parsePage(args, 50);
+    const name = optionalText(args.name, 'name') ?? '';
+    const body = {
+        browserMultiple: true,
+        id: '400',
+        option: '',
+        formDatas: {},
+        type: 'and',
+        useListViewType: true,
+        browserTreeDefaultExpandedLevel: '0',
+        current: pageNo,
+        pageSize,
+        quickSearchDatas: { name },
+    };
+    const response = await env.host.request({
+        method: 'POST',
+        path: '/api/doc/common/browser/data/virtualFolder',
+        body,
+        operation: action,
+    });
+    const items = nestedList(response, 'data', 'data');
+    const folders = [];
+    for (const entry of items) {
+        if (!isRecord(entry))
+            continue;
+        const content = typeof entry.content === 'string' ? entry.content : String(entry.content ?? '');
+        const matched = VIRTUAL_CONTENT_RE.exec(content);
+        folders.push({
+            id: String(entry.id ?? ''),
+            name: matched ? matched[1] : content,
+            path: matched ? matched[2] : '',
+            parent_folder_id: entry.parentFolderId ?? '',
+        });
+    }
+    return caizhilianSuccess(action, {
+        page_no: pageNo,
+        page_size: pageSize,
+        has_next: items.length >= pageSize,
+        folders,
+    });
+}
+function browserSearch(config) {
+    return async (args, env) => {
+        const { pageNo, pageSize } = parsePage(args, 50);
+        const quickSearchDatas = {};
+        const keyword = optionalText(args.keyword, 'keyword');
+        if (keyword)
+            quickSearchDatas[config.quickKey] = keyword;
+        const body = {
+            ...config.head,
+            current: pageNo,
+            pageSize,
+            formDatas: {},
+            quickSearchDatas,
+            type: 'and',
+            ...(config.tail ?? {}),
+        };
+        const response = await env.host.request({
+            method: 'POST',
+            path: config.path,
+            body,
+            operation: config.action,
+        });
+        const items = nestedList(response, 'data', 'data');
+        return caizhilianSuccess(config.action, {
+            page_no: pageNo,
+            page_size: pageSize,
+            has_next: hasNextPage(items, pageSize),
+            [config.resultKey]: items.filter(isRecord).map(config.mapItem),
+        });
+    };
+}
+const idName = (item) => ({ id: String(item.id ?? ''), name: item.name ?? '' });
+const userSearch = browserSearch({
+    action: 'caizhilian.org.search-user',
+    path: '/api/hrm/common/browser/data/resource',
+    quickKey: 'username',
+    resultKey: 'users',
+    head: {
+        browserMultiple: true,
+        authWecahtBook: true,
+        wxDepNeedConvertCount: 0,
+        wxEmpNeedConvertCount: 0,
+        wxTotalNeedConvertCount: 0,
+        cmd: 'all',
+    },
+    tail: { containsNoneAccount: false, containsPartTimeEmployee: false },
+    mapItem: (item) => ({ id: item.id ?? '', name: item.name ?? '', department: item.department ?? '' }),
+});
+const departmentSearch = browserSearch({
+    action: 'caizhilian.org.search-department',
+    path: '/api/hrm/common/browser/data/department',
+    quickKey: 'name',
+    resultKey: 'departments',
+    head: { browserMultiple: true, virtualType: 'ALL', cmd: 'list' },
+    tail: { stopDepartment: false, enableSubcompany: false },
+    mapItem: (item) => ({
+        id: String(item.id ?? ''),
+        name: item.name ?? '',
+        sup_department: item.supDepartment ?? '',
+        parent_id: String(item.parent ?? ''),
+        has_sub: Boolean(item.hasSub ?? false),
+    }),
+});
+const subcompanySearch = browserSearch({
+    action: 'caizhilian.org.search-subcompany',
+    path: '/api/hrm/common/browser/data/subcompany',
+    quickKey: 'name',
+    resultKey: 'subcompanies',
+    head: { browserMultiple: true, virtualType: 'ALL', cmd: 'list' },
+    tail: { stopDepartment: false },
+    mapItem: (item) => ({
+        id: String(item.id ?? ''),
+        name: item.name ?? '',
+        parent_id: String(item.parent ?? ''),
+        sup_department: item.supSubDepartment ?? '',
+    }),
+});
+const externalSearch = browserSearch({
+    action: 'caizhilian.org.search-external',
+    path: '/api/hrm/common/browser/data/external',
+    quickKey: 'name',
+    resultKey: 'externals',
+    head: { browserMultiple: true, cmd: 'list' },
+    mapItem: idName,
+});
+const positionSearch = browserSearch({
+    action: 'caizhilian.org.search-position',
+    path: '/api/hrm/common/browser/data/position',
+    quickKey: 'name',
+    resultKey: 'positions',
+    head: { browserMultiple: true, cmd: 'list' },
+    mapItem: (item) => ({ id: String(item.id ?? ''), name: item.name ?? '', code: item.code ?? '' }),
+});
+const roleSearch = browserSearch({
+    action: 'caizhilian.org.search-role',
+    path: '/api/hrm/common/browser/data/role',
+    quickKey: 'role_name',
+    resultKey: 'roles',
+    head: { browserMultiple: true },
+    mapItem: idName,
+});
+const customerSearch = browserSearch({
+    action: 'caizhilian.org.search-customer',
+    path: '/api/crm/common/browser/data/customer',
+    quickKey: 'customer_name',
+    resultKey: 'customers',
+    head: { browserMultiple: true },
+    mapItem: idName,
+});
+const customerTypeSearch = browserSearch({
+    action: 'caizhilian.org.search-customer-type',
+    path: '/api/crm/common/browser/data/dictionary',
+    quickKey: 'name',
+    resultKey: 'customer_types',
+    head: { browserMultiple: false, propertyType: 'customerType' },
+    mapItem: idName,
+});
+// ── caizhilian.compare.search-documents ───────────────────
+async function searchCompareDocuments(args, env) {
+    const action = 'caizhilian.compare.search-documents';
+    const { pageNo, pageSize } = parsePage(args, 20);
+    const rawName = args.name === undefined || args.name === null ? '' : String(args.name);
+    const nameClean = rawName.trim();
+    const body = {
+        pageNo,
+        pageSize,
+        keywords: nameClean ? rawName : '',
+    };
+    const conditions = [];
+    if (nameClean)
+        conditions.push({ id: 'name', type: 'string', value: rawName });
+    const author = optionalText(args.author, 'author');
+    if (author)
+        conditions.push({ id: 'author', operate: 'eq', type: 'array', value: author });
+    const creator = optionalText(args.creator, 'creator');
+    if (creator)
+        conditions.push({ id: 'creator', operate: 'eq', type: 'array', value: creator });
+    const createTime = timeCondition(args);
+    if (createTime)
+        conditions.push(createTime);
+    const folder = optionalText(args.folder, 'folder');
+    if (folder)
+        conditions.push({ id: 'folder', operate: 'eq', type: 'folder', value: folder });
+    body.conditions = conditions;
+    const response = await env.host.request({ method: 'POST', path: '/api/doc/documents/list', body, operation: action });
+    return documentPage(action, response, pageNo, pageSize);
+}
+export const caizhilianSearchHandlers = {
+    'caizhilian.document.search': { execute: searchDocuments },
+    'caizhilian.folder.search-virtual': { execute: searchVirtualFolders },
+    'caizhilian.org.search-user': { execute: userSearch },
+    'caizhilian.org.search-department': { execute: departmentSearch },
+    'caizhilian.org.search-subcompany': { execute: subcompanySearch },
+    'caizhilian.org.search-external': { execute: externalSearch },
+    'caizhilian.org.search-position': { execute: positionSearch },
+    'caizhilian.org.search-role': { execute: roleSearch },
+    'caizhilian.org.search-customer': { execute: customerSearch },
+    'caizhilian.org.search-customer-type': { execute: customerTypeSearch },
+    'caizhilian.compare.search-documents': { execute: searchCompareDocuments },
+};

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

@@ -0,0 +1,294 @@
+/**
+ * caizhilian.setting-attach — 附件设置（文件设置 → 附件设置）
+ *
+ * 覆盖「文件设置 → 附件设置」页面的 11 项配置：
+ * - 上传最大、上传分片大小、格式控制方式、格式列表
+ * - 非图片/音视频打开方式、图片/音视频打开方式
+ * - 预览显示附件列表、附件列默认展开、附件附加提示
+ * - 附件批量下载、禁止移动端下载
+ *
+ * 接口：
+ * - 拉全量：POST /api/file/tenant/setting
+ * - 保存：POST /api/file/tenant/setting/save（只 POST 改了的字段）
+ */
+import { CaizhilianCliError, caizhilianValidationError } from '../../errors.js';
+import { issueWriteLease } from '../confirm.js';
+import { caizhilianSuccess } from '../types.js';
+const ACTION = 'caizhilian.setting-attach';
+// ── 接口路径 ──────────────────────────────────────────────
+const GET_PATH = '/api/file/tenant/setting';
+const SAVE_PATH = '/api/file/tenant/setting/save';
+// ── 字段映射（CLI key → DTO 字段） ─────────────────────────
+const FIELD_MAP = {
+    'upload-max': { dtoKey: 'sysMaxSingleUploadSize', type: 'string' },
+    'shard-size': { dtoKey: 'uploadShardSize', type: 'number', parse: (v) => parseInt(v, 10) },
+    'format-mode': { dtoKey: 'sysFormatWhitesEnable', type: 'boolean', parse: (v) => v === 'whitelist' || v === '白名单' },
+    'format-list': { dtoKey: 'sysFormatWhites', type: 'string' }, // 实际写入位置取决于 mode
+    'non-image-open': { dtoKey: 'sysNonImageMediaOpenType', type: 'string' },
+    'image-open': { dtoKey: 'sysImageMediaOpenType', type: 'string' },
+    'show-attach-list': { dtoKey: 'sysPreviewShowAttachmentList', type: 'boolean' },
+    'attach-expand': { dtoKey: 'sysAttachmentListDefaultExpand', type: 'boolean' },
+    'custom-msg': { dtoKey: 'sysUploadCustomMsgEnable', type: 'boolean' },
+    'batch-download': { dtoKey: 'sysBatchDownload', type: 'boolean' },
+    'mobile-block': { dtoKey: 'sysAppDownload', type: 'boolean', parse: (v) => !parseBoolean(v) }, // 语义取反
+    'download-pdf-types': { dtoKey: 'sysDownloadToPdfFileTypes', type: 'string' },
+    'img-compress': { dtoKey: 'sysImgCompressEnable', type: 'boolean' },
+    'img-compress-quality': { dtoKey: 'sysImgCompressQuality', type: 'string' },
+    'auto-clear-version': { dtoKey: 'sysAutoClearFileVersion', type: 'boolean' },
+    'version-size': { dtoKey: 'sysFileVersionSize', type: 'number', parse: (v) => parseInt(v, 10) },
+    'version-time': { dtoKey: 'sysFileVersionTime', type: 'number', parse: (v) => parseInt(v, 10) },
+    'print-pdf-types': { dtoKey: 'sysPrintToPdfFileTypes', type: 'string' },
+    'version-clean-type': { dtoKey: 'sysAutoClearFileVersionType', type: 'string' },
+    'version-size-type': { dtoKey: 'sysFileVersionSizeType', type: 'string' },
+    'version-time-type': { dtoKey: 'sysFileVersionTimeType', type: 'string' },
+};
+// ── 辅助函数 ──────────────────────────────────────────────
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function parseBoolean(value) {
+    if (typeof value === 'boolean')
+        return value;
+    const s = String(value).toLowerCase();
+    return ['true', '1', '开', '启用'].includes(s);
+}
+function pyRepr(value) {
+    return JSON.stringify(value);
+}
+function sortedJoin(set) {
+    return [...set].sort().join(', ');
+}
+// ── 读取设置 ──────────────────────────────────────────────
+async function getSettingAttach(args, env) {
+    const response = await env.host.request({
+        method: 'POST',
+        path: GET_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 settings = asRecord(data.data);
+    return caizhilianSuccess(ACTION, {
+        settings: {
+            upload_max: settings.sysMaxSingleUploadSize || '',
+            upload_max_limit: settings.sysMaxSingleUploadLimitSize || '',
+            shard_size: settings.uploadShardSize || 0,
+            format_mode: settings.sysFormatWhitesEnable ? 'whitelist' : 'blacklist',
+            format_list: settings.sysFormatWhitesEnable ? (settings.sysFormatWhites || '*') : (settings.sysFormatBlacks || ''),
+            non_image_open: settings.sysNonImageMediaOpenType || 'newTab',
+            image_open: settings.sysImageMediaOpenType || 'previewComponent',
+            show_attach_list: settings.sysPreviewShowAttachmentList ?? true,
+            attach_expand: settings.sysAttachmentListDefaultExpand ?? true,
+            custom_msg_enable: settings.sysUploadCustomMsgEnable ?? false,
+            custom_msg: settings.sysUploadCustomMsg || '',
+            batch_download: settings.sysBatchDownload ?? true,
+            mobile_block: !(settings.sysAppDownload ?? true), // 语义取反
+            download_pdf_types: settings.sysDownloadToPdfFileTypes || '',
+            img_compress: settings.sysImgCompressEnable ?? false,
+            img_compress_quality: settings.sysImgCompressQuality || 'medium',
+            auto_clear_version: settings.sysAutoClearFileVersion ?? false,
+            version_size: settings.sysFileVersionSize ?? -1,
+            version_time: settings.sysFileVersionTime ?? -1,
+            print_pdf_types: settings.sysPrintToPdfFileTypes || '',
+            version_clean_type: settings.sysAutoClearFileVersionType || 'versionSize',
+            version_size_type: settings.sysFileVersionSizeType || 'selected',
+            version_time_type: settings.sysFileVersionTimeType || 'selected',
+        },
+    });
+}
+// ── 保存设置（prepare/apply）──────────────────────────────────────
+function buildChangedBody(items, current) {
+    const changed = {};
+    for (const [key, value] of Object.entries(items)) {
+        const field = FIELD_MAP[key];
+        if (!field) {
+            throw caizhilianValidationError('unknown_field', `未知字段: ${key}`);
+        }
+        let parsed;
+        if (field.parse) {
+            parsed = field.parse(String(value));
+        }
+        else if (field.type === 'boolean') {
+            parsed = parseBoolean(value);
+        }
+        else if (field.type === 'number') {
+            parsed = parseInt(String(value), 10);
+            if (isNaN(parsed)) {
+                throw caizhilianValidationError('number_invalid', `${key} 必须是数字`);
+            }
+        }
+        else {
+            parsed = String(value);
+        }
+        // 特殊处理：format-list 根据 mode 写入不同字段
+        if (key === 'format-list') {
+            const mode = items['format-mode'] !== undefined
+                ? (items['format-mode'] === 'whitelist' || items['format-mode'] === '白名单')
+                : current.sysFormatWhitesEnable;
+            if (mode) {
+                changed['sysFormatWhites'] = parsed;
+            }
+            else {
+                changed['sysFormatBlacks'] = parsed;
+            }
+        }
+        else if (key === 'custom-msg') {
+            // custom-msg 复合字段：bool + text
+            const enable = parseBoolean(value);
+            changed['sysUploadCustomMsgEnable'] = enable;
+            if (typeof value === 'string' && value.includes('::')) {
+                const text = value.split('::').slice(1).join('::');
+                changed['sysUploadCustomMsg'] = text;
+            }
+        }
+        else {
+            changed[field.dtoKey] = parsed;
+        }
+    }
+    return changed;
+}
+async function setSettingAttachPrepare(args, env) {
+    const items = args.items;
+    if (!isPlainObject(items)) {
+        throw caizhilianValidationError('input_not_object', 'items 必须是对象');
+    }
+    // 读取当前设置
+    const currentResponse = await env.host.request({
+        method: 'POST',
+        path: GET_PATH,
+        body: {},
+        operation: ACTION,
+    });
+    const currentData = asRecord(currentResponse);
+    if (!currentData.status && !currentData.success) {
+        throw new CaizhilianCliError('api', 'business_error', String(currentData.msg || currentData.message || '读取附件设置失败'), {
+            code: currentData.code ?? currentData.status,
+            details: { action: ACTION, message: String(currentData.msg || currentData.message || '读取附件设置失败') },
+            exitCode: 1,
+        });
+    }
+    const current = asRecord(currentData.data);
+    // 构建改动
+    const changed = buildChangedBody(items, current);
+    // 签发 continuation（含环境指纹，防跨账号复用）
+    const lease = await issueWriteLease(env, 'caizhilian.setting-attach.set.apply', args, { changed, items });
+    return caizhilianSuccess('caizhilian.setting-attach.set.prepare', {
+        changed,
+        current: {
+            upload_max: current.sysMaxSingleUploadSize || '',
+            format_mode: current.sysFormatWhitesEnable ? 'whitelist' : 'blacklist',
+            format_list: current.sysFormatWhitesEnable ? (current.sysFormatWhites || '*') : (current.sysFormatBlacks || ''),
+            batch_download: current.sysBatchDownload ?? true,
+            mobile_block: !(current.sysAppDownload ?? true),
+        },
+        continuation: lease.continuation,
+        expires_in_ms: lease.expiresInMs,
+    });
+}
+async function setSettingAttachApply(args, env, lease) {
+    // 使用 lease 中的 changed
+    const changed = lease.changed;
+    if (!changed || Object.keys(changed).length === 0) {
+        throw caizhilianValidationError('continuation_invalid', 'continuation 中无改动');
+    }
+    // 保存
+    const saveResponse = await env.host.request({
+        method: 'POST',
+        path: SAVE_PATH,
+        body: changed,
+        operation: 'caizhilian.setting-attach.set.apply',
+    });
+    const saveData = asRecord(saveResponse);
+    if (!saveData.status && !saveData.success) {
+        throw new CaizhilianCliError('api', 'business_error', String(saveData.msg || saveData.message || '保存附件设置失败'), {
+            code: saveData.code ?? saveData.status,
+            details: { action: 'caizhilian.setting-attach.set.apply', message: String(saveData.msg || saveData.message || '保存附件设置失败') },
+            exitCode: 1,
+        });
+    }
+    // 回读复核
+    const verifyResponse = await env.host.request({
+        method: 'POST',
+        path: GET_PATH,
+        body: {},
+        operation: 'caizhilian.setting-attach.set.apply',
+    });
+    const verifyData = asRecord(verifyResponse);
+    const verified = asRecord(verifyData.data);
+    return caizhilianSuccess('caizhilian.setting-attach.set.apply', {
+        changed,
+        verified: {
+            upload_max: verified.sysMaxSingleUploadSize || '',
+            format_mode: verified.sysFormatWhitesEnable ? 'whitelist' : 'blacklist',
+            format_list: verified.sysFormatWhitesEnable ? (verified.sysFormatWhites || '*') : (verified.sysFormatBlacks || ''),
+            batch_download: verified.sysBatchDownload ?? true,
+            mobile_block: !(verified.sysAppDownload ?? true),
+        },
+    });
+}
+// ── 通过文件夹反查审批流程 ──────────────────────────────────────────
+async function listWorkflowsByFolders(args, env) {
+    const action = 'caizhilian.setting-attach.list-workflows-by-folders';
+    const folderIds = args.folder_ids;
+    if (!Array.isArray(folderIds) || folderIds.length === 0) {
+        throw caizhilianValidationError('folder_ids_required', 'folder_ids 必须是非空数组');
+    }
+    const response = await env.host.request({
+        method: 'POST',
+        path: '/api/doc/approvalWorkflow/listWorkflowByFolders',
+        body: { folderIds },
+        operation: action,
+        tolerateBusinessError: true,
+    });
+    const data = asRecord(response);
+    // 检查接口是否不存在（404 等）
+    if (data.code === 404 || data.status === 404) {
+        throw new CaizhilianCliError('api', 'feature_not_supported', '当前环境暂不支持该功能', {
+            code: 404,
+            details: {
+                action,
+                message: '当前环境暂不支持通过文件夹反查审批流程的功能',
+            },
+            exitCode: 1,
+        });
+    }
+    // 检查业务成功
+    if (!data.status && !data.success && data.code !== 200) {
+        throw new CaizhilianCliError('api', 'business_error', String(data.msg || data.message || '查询失败'), {
+            code: data.code ?? data.status,
+            details: { action, message: String(data.msg || data.message || '查询失败') },
+            exitCode: 1,
+        });
+    }
+    const workflows = Array.isArray(data.data) ? data.data : [];
+    return caizhilianSuccess(action, {
+        folder_ids: folderIds,
+        workflows: workflows.map((item) => ({
+            workflow_id: item.workflowId || '',
+            workflow_name: item.workflowName || '',
+            type_id: item.typeId || '',
+            type_name: item.typeName || '',
+        })),
+        total: workflows.length,
+    });
+}
+// ── 处理器汇总 ────────────────────────────────────────────
+export const caizhilianSettingAttachHandlers = {
+    'caizhilian.setting-attach.get': { execute: getSettingAttach },
+    'caizhilian.setting-attach.list-workflows-by-folders': { execute: listWorkflowsByFolders },
+    'caizhilian.setting-attach.set': {
+        prepare: setSettingAttachPrepare,
+        apply: setSettingAttachApply,
+        targetKeys: ['items'],
+    },
+};