weaver-work-cli 0.1.8 → 0.1.20

package/dist/shortcuts/caizhilian/host.js

@@ -0,0 +1,190 @@
+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 { CaizhilianCliError, caizhilianAuthError, caizhilianNetworkError, caizhilianValidationError, } from './errors.js';
+/** 业务请求默认超时（源 assets/config.json：http.timeout = 12 秒）。 */
+export const CAIZHILAN_TIMEOUT_MS = 12_000;
+/** 上传/下载专用超时（源 _plugin_helpers.UPLOAD_DOWNLOAD_TIMEOUT = 120 秒）。 */
+export const CAIZHILAN_TRANSFER_TIMEOUT_MS = 120_000;
+/** 附件下载体积上限（源 assets/config.json：http.download.max_size_mb = 100）。 */
+export const CAIZHILAN_MAX_DOWNLOAD_BYTES = 100 * 1024 * 1024;
+function inferProfile(ctx) {
+    const options = ctx.getGlobalOptions();
+    return options.profile || getActiveProfile();
+}
+/**
+ * 判断响应是否业务成功。采知连（E10 文档中心）响应约定：
+ * 源 assets/config.json 的 response_convention 为 success_path=code / success_value=200，
+ * 少数 folderpermission 接口改回 status/success 布尔字段，这里按「先看 code，再看布尔」兜底。
+ */
+export function isCaizhilianBusinessSuccess(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    if (value.code !== undefined && value.code !== null)
+        return Number(value.code) === 200;
+    if (typeof value.success === 'boolean')
+        return value.success;
+    if (typeof value.status === 'boolean')
+        return value.status;
+    return false;
+}
+export function caizhilianBusinessMessage(value) {
+    if (!value || typeof value !== 'object')
+        return '采知连接口返回业务失败';
+    const candidates = [value.msg, value.message, value.errMsg, value.data?.msg, value.data?.message];
+    for (const item of candidates) {
+        if (typeof item === 'string' && item.trim())
+            return item;
+    }
+    return '采知连接口返回业务失败';
+}
+function caizhilianBusinessCode(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const code = value.code ?? value.status;
+    if (typeof code === 'string' || typeof code === 'number')
+        return code;
+    return undefined;
+}
+export function assertCaizhilianPath(requestPath) {
+    if (typeof requestPath !== 'string' || !requestPath.startsWith('/') || requestPath.startsWith('//')) {
+        throw caizhilianValidationError('path_invalid', '请求路径必须是相对绝对路径');
+    }
+    if (/^https?:/i.test(requestPath) || /[\r\n]/.test(requestPath) || requestPath.includes('/../')) {
+        throw caizhilianValidationError('path_invalid', '请求路径不允许跨域或路径逃逸');
+    }
+    if (!requestPath.startsWith('/api/')) {
+        throw caizhilianValidationError('path_not_allowed', '采知连模块只能调用 /api/ 路径');
+    }
+}
+function formBody(form) {
+    if (!form)
+        return undefined;
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(form)) {
+        if (value === undefined || value === null)
+            continue;
+        params.set(key, typeof value === 'string' ? value : JSON.stringify(value));
+    }
+    return params;
+}
+function omitEmptyQueryValues(query) {
+    if (!query)
+        return undefined;
+    return Object.fromEntries(Object.entries(query).filter(([, value]) => value !== ''));
+}
+function mapRuntimeNetworkError(error) {
+    if (error instanceof E10ApiError && error.type === 'network') {
+        throw caizhilianNetworkError(error.subtype, error.message, {
+            retryable: error.retryable,
+            details: error.details,
+        });
+    }
+    throw error;
+}
+export function createCaizhilianHost(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: inferProfile(ctx),
+                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(), {
+            interceptors: dependencies.interceptors,
+            fetch: dependencies.fetch,
+        });
+    }
+    async function doRequest(request, binary) {
+        const { method, path, query, body, operation, form, multipart, headers: extraHeaders = {}, timeoutMs = CAIZHILAN_TIMEOUT_MS, } = request;
+        assertCaizhilianPath(path);
+        const resolvedMethod = method || (body === undefined && form === undefined && multipart === undefined ? 'GET' : 'POST');
+        const rt = await runtime();
+        const response = binary
+            ? await rt.requestBinary({
+                module: 'caizhilian',
+                operation,
+                method: resolvedMethod,
+                path,
+                query: omitEmptyQueryValues(query),
+                body: multipart === undefined ? body : undefined,
+                form: multipart === undefined && form === undefined ? undefined : formBody(form ?? {}),
+                formData: multipart,
+                headers: { 'X-Requested-With': 'XMLHttpRequest', ...extraHeaders },
+                timeoutMs,
+            })
+            : await rt.requestJson({
+                module: 'caizhilian',
+                operation,
+                method: resolvedMethod,
+                path,
+                query: omitEmptyQueryValues(query),
+                body: multipart === undefined ? body : undefined,
+                form: multipart === undefined && form === undefined ? undefined : formBody(form ?? {}),
+                formData: multipart,
+                headers: { 'X-Requested-With': 'XMLHttpRequest', ...extraHeaders },
+                timeoutMs,
+            });
+        return response;
+    }
+    async function request(request) {
+        const response = await doRequest(request, false).catch((error) => mapRuntimeNetworkError(error));
+        if (response.status === 401 || response.status === 302) {
+            throw caizhilianAuthError('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 new CaizhilianCliError('api', 'http_error', `采知连接口 HTTP ${response.status}`, {
+                    code: response.status,
+                    details: { status: response.status },
+                    exitCode: 1,
+                });
+            }
+            throw caizhilianNetworkError('protocol', `接口返回不是合法 JSON（HTTP ${response.status}）`, { retryable: false });
+        }
+        if (response.status < 200 || response.status >= 300) {
+            throw new CaizhilianCliError('api', 'http_error', `采知连接口 HTTP ${response.status}`, {
+                code: response.status,
+                details: { status: response.status, message: caizhilianBusinessMessage(response.value) },
+                exitCode: 1,
+            });
+        }
+        if (!request.tolerateBusinessError && !isCaizhilianBusinessSuccess(response.value)) {
+            throw new CaizhilianCliError('api', 'business_error', caizhilianBusinessMessage(response.value), {
+                code: caizhilianBusinessCode(response.value),
+                details: { code: caizhilianBusinessCode(response.value), message: caizhilianBusinessMessage(response.value) },
+                exitCode: 1,
+            });
+        }
+        return response.value;
+    }
+    async function requestBinary(request) {
+        const response = await doRequest(request, true).catch((error) => mapRuntimeNetworkError(error));
+        if (response.status === 401 || response.status === 302) {
+            throw caizhilianAuthError('session_expired', 'E10 登录态已失效，请先登录', { httpStatus: response.status });
+        }
+        if (response.status < 200 || response.status >= 300) {
+            throw new CaizhilianCliError('api', 'http_error', `采知连下载 HTTP ${response.status}`, {
+                code: response.status,
+                details: { status: response.status },
+                exitCode: 1,
+            });
+        }
+        return { status: response.status, contentType: response.contentType, content: response.content, headers: response.headers };
+    }
+    return { request, requestBinary, getSession };
+}

package/dist/shortcuts/caizhilian/index.js

@@ -0,0 +1,186 @@
+import { readFile } from 'node:fs/promises';
+import { ExitCode, isCliError, toErrorEnvelope } from '../../core/errors.js';
+import { createCaizhilianContinuationSigner } from './continuation.js';
+import { caizhilianValidationError } from './errors.js';
+import { createCaizhilianHost } from './host.js';
+import { caizhilianManifest } from './manifest.js';
+import { executeCaizhilianOperation } from './operations.js';
+import { caizhilianOperationDefinitions } from './operations/registry.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+/, '');
+}
+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 caizhilianValidationError('input_invalid', `${label} 不是合法 JSON 对象`);
+    }
+}
+export async function inputFrom(options, extra = {}) {
+    const opts = asOptions(options);
+    let input = {};
+    if (opts.input && opts.inputJson) {
+        throw caizhilianValidationError('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 caizhilianValidationError('input_unreadable', `无法读取 --input：${String(opts.input)}`);
+        }
+        input = parseJsonInput(raw, '--input');
+    }
+    return {
+        ...input,
+        ...Object.fromEntries(Object.entries(extra).filter(([, value]) => value !== undefined && value !== '')),
+    };
+}
+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) {
+    const structured = error;
+    return {
+        schemaVersion: 1,
+        ok: false,
+        ...(structured?.partialData === undefined ? {} : { data: structured.partialData }),
+        error: toErrorEnvelope(error),
+    };
+}
+async function executeAndPrint(ctx, operation, input) {
+    try {
+        const result = await executeCaizhilianOperation(operation, input, {
+            ctx,
+            host: createCaizhilianHost(ctx),
+            continuation: createCaizhilianContinuationSigner(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;
+    }
+}
+/** 按 resource 分组的操作清单（87 条对外 operation，便于 Agent 检索）。 */
+function operationsCatalog() {
+    const groups = new Map();
+    for (const definition of caizhilianOperationDefinitions()) {
+        const list = groups.get(definition.resource) ?? [];
+        list.push({
+            name: definition.name,
+            summary: definition.summary,
+            risk: definition.risk,
+            ...(definition.requiresConfirmation ? { requiresConfirmation: true } : {}),
+            sourceOperation: definition.sourceOperation,
+        });
+        groups.set(definition.resource, list);
+    }
+    return {
+        schemaVersion: 1,
+        ok: true,
+        module: caizhilianManifest.name,
+        sourceSkill: caizhilianManifest.sourceSkill,
+        total: caizhilianOperationDefinitions().length,
+        groups: [...groups.entries()].map(([resource, operations]) => ({ resource, operations })),
+        withheldOperations: caizhilianManifest.withheldOperations,
+    };
+}
+function withJsonInputOptions(command) {
+    return command
+        .option('--input <path>', 'JSON input file, or - for stdin')
+        .option('--input-json <json>', 'inline JSON input object');
+}
+export const caizhilianShortcut = {
+    name: 'caizhilian',
+    description: '泛微E10采知连（文档中心）CLI',
+    category: 'shortcut',
+    register({ program, action }) {
+        const caizhilian = program
+            .command('caizhilian')
+            .description('泛微E10采知连文档中心（文档/文件夹/权限共享/标签/参与人/附件/封面/文档比对）');
+        caizhilian
+            .command('schema')
+            .description('Print caizhilian operation manifest for agents')
+            .action(action((ctx) => {
+            ctx.output.write(caizhilianManifest, { json: true });
+        }));
+        caizhilian
+            .command('operations')
+            .description('List caizhilian operations grouped by resource')
+            .action(action((ctx) => {
+            ctx.output.write(operationsCatalog(), { json: true });
+        }));
+        withJsonInputOptions(caizhilian
+            .command('run')
+            .description('Run a caizhilian operation with JSON input')
+            .argument('<operation>', 'operation name, e.g. caizhilian.document.search / caizhilian.tag.add.apply')
+            .option('--continuation <token>', 'prepare 返回的确认票据（apply 必填）')
+            .option('--yes', 'confirm the write operation（apply 必填）')).action(action(async (ctx, operation, options) => {
+            const opts = asOptions(options);
+            await executeAndPrint(ctx, String(operation), await inputFrom(options, {
+                continuation: opts.continuation,
+                confirm: opts.yes === true ? true : undefined,
+            }));
+        }));
+        // ---- 高频便捷命令 ----
+        withJsonInputOptions(caizhilian
+            .command('search')
+            .description('检索文档（caizhilian.document.search 薄包装）')
+            .option('--keywords <kw>', '检索关键词')
+            .option('--folder-id <id>', '文件夹 ID：100=系统，200=公共，300=个人')
+            .option('--page-no <n>', '页码（1-indexed）')
+            .option('--page-size <n>', '每页条数')).action(action(async (ctx, options) => {
+            const opts = asOptions(options);
+            await executeAndPrint(ctx, 'caizhilian.document.search', await inputFrom(options, {
+                keywords: opts.keywords,
+                folder_id: opts.folderId,
+                page_no: opts.pageNo,
+                page_size: opts.pageSize,
+            }));
+        }));
+        withJsonInputOptions(caizhilian
+            .command('get')
+            .description('查询文档详情（caizhilian.document.get 薄包装）')
+            .option('--doc-id <id>', '文档 ID（必填）')).action(action(async (ctx, options) => {
+            const opts = asOptions(options);
+            await executeAndPrint(ctx, 'caizhilian.document.get', await inputFrom(options, { doc_id: opts.docId }));
+        }));
+        caizhilian
+            .command('health')
+            .description('采知连接口连通性与登录态自检（caizhilian.system.health 薄包装）')
+            .action(action(async (ctx) => {
+            await executeAndPrint(ctx, 'caizhilian.system.health', {});
+        }));
+    },
+};

package/dist/shortcuts/caizhilian/manifest.js

@@ -0,0 +1,42 @@
+import { caizhilianOperationContracts } from './operations/registry.js';
+/**
+ * 禁用边界：源 Skill 的 64 个 operation 中，4 个属于「本地多环境配置」能力，
+ * 在 weaver-work-cli 里由框架层统一承担（config / e10 auth），模块 CLI 不重复实现，
+ * 因此不进入 operations，仅在此显式声明，避免 Agent 误以为能力缺失。
+ */
+const WITHHELD = [
+    {
+        name: 'caizhilian.system.list-systems',
+        reason: '源 list_systems 读取的是 Skill 自带 assets/config.json 的多环境配置与登录态；weaver-work-cli 的环境与登录态由框架统一管理，请用 `weaver-work-cli config list` 与 `weaver-work-cli auth status` 查看，连通性自检用 caizhilian.system.health。',
+    },
+    {
+        name: 'caizhilian.system.get-loaded-config',
+        reason: '源 get_loaded_config 会输出 Skill 本地 config.json 的生效内容（含 cookies 掩码、下载目录等）；CLI 侧等价信息来自框架配置，请用 `weaver-work-cli config list`，不在业务模块内暴露配置快照。',
+    },
+    {
+        name: 'caizhilian.system.reload-config',
+        reason: '源 reload_config 重新加载 Skill 本地 config.json；CLI 每次进程启动即读取框架配置，无进程内缓存需要刷新，故不提供该操作。',
+    },
+    {
+        name: 'caizhilian.system.switch-config',
+        reason: '源 switch_config 在 Skill 本地多套环境配置间切换；CLI 的环境切换由 `weaver-work-cli config set` / `weaver-work-cli auth login --base-url <域名>` 承担，业务模块不做环境切换。',
+    },
+];
+function buildOperations() {
+    return caizhilianOperationContracts();
+}
+export const caizhilianManifest = {
+    schemaVersion: 1,
+    name: 'caizhilian',
+    title: '泛微E10采知连（文档中心：文档/文件夹/权限共享/标签/参与人/附件/封面/比对）',
+    version: '0.1.0',
+    host: 'e10-caizhilian',
+    status: 'builtin',
+    sourceSkill: 'weaver-e10-caizhilian',
+    capabilities: ['caizhilian'],
+    operations: buildOperations(),
+    withheldOperations: WITHHELD,
+};
+export function hasCaizhilianManifestOperation(operation) {
+    return caizhilianManifest.operations.some((item) => item.name === operation);
+}