weaver-work-cli 0.1.4 → 0.1.5

package/dist/internal/e10/request-runtime.js

@@ -1,5 +1,6 @@
 import { CliError, ExitCode } from '../../core/errors.js';
 const DEFAULT_TIMEOUT_MS = 30_000;
+const DEFAULT_BIG_INT_STRINGS = true;
 const RESERVED_HEADERS = [
     'authorization',
     'cookie',
@@ -81,7 +82,7 @@ export class E10RequestRuntime {
             formData: request.formData,
             timeoutMs: request.timeoutMs || DEFAULT_TIMEOUT_MS,
             responseType: request.responseType || 'json',
-            bigIntStrings: request.bigIntStrings === true,
+            bigIntStrings: request.bigIntStrings ?? DEFAULT_BIG_INT_STRINGS,
         };
     }
     sessionContext() {
@@ -184,7 +185,7 @@ export class E10RequestRuntime {
             clearTimeout(timer);
         }
     }
-    async readResponse(response, responseType, bigIntStrings = false) {
+    async readResponse(response, responseType, bigIntStrings = DEFAULT_BIG_INT_STRINGS) {
         if (responseType === 'binary') {
             return {
                 status: response.status,

package/dist/shortcuts/index.js

@@ -6,9 +6,11 @@ import { fnaShortcut } from './fna/index.js';
 import { hrmShortcut } from './hrm/index.js';
 import { invoiceShortcut } from './invoice/index.js';
 import { mailShortcut } from './mail/index.js';
+import { meetingShortcut } from './meeting/index.js';
 import { planShortcut } from './plan/index.js';
 import { jiuchuanhuiShortcut } from './jiuchuanhui/index.js';
 import { assetShortcut } from './asset/index.js';
+import { yimiaobanShortcut } from './yimiaoban/index.js';
 export const builtinShortcuts = [
     invoiceShortcut,
     ehrShortcut,
@@ -17,8 +19,10 @@ export const builtinShortcuts = [
     fnaShortcut,
     hrmShortcut,
     mailShortcut,
+    meetingShortcut,
     planShortcut,
     esbShortcut,
     jiuchuanhuiShortcut,
     assetShortcut,
+    yimiaobanShortcut
 ];

package/dist/shortcuts/meeting/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 { meetingValidationError } 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, 'meeting-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 createMeetingContinuationSigner(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 meetingValidationError('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 meetingValidationError('continuation_invalid', 'continuation 签名校验失败');
+            let value;
+            try {
+                value = JSON.parse(Buffer.from(body, 'base64url').toString('utf8'));
+            }
+            catch {
+                throw meetingValidationError('continuation_invalid', 'continuation 内容无法解析');
+            }
+            if (value.operation !== expectedOperation) {
+                throw meetingValidationError('continuation_mismatch', 'continuation 不属于当前操作');
+            }
+            if (!Number.isSafeInteger(value.expiresAt) || value.expiresAt < Date.now()) {
+                throw meetingValidationError('continuation_expired', 'continuation 已过期');
+            }
+            return value;
+        },
+    };
+}

package/dist/shortcuts/meeting/errors.js

@@ -0,0 +1,63 @@
+import { CliError, ExitCode } from '../../core/errors.js';
+export class MeetingCliError extends CliError {
+    type;
+    subtype;
+    code;
+    retryable;
+    stage;
+    details;
+    partialData;
+    constructor(type, subtype, message, options = {}) {
+        super(message, options.exitCode ?? ExitCode.InternalError);
+        this.name = 'MeetingCliError';
+        this.type = type;
+        this.subtype = subtype;
+        this.code = options.code;
+        this.retryable = options.retryable ?? false;
+        this.stage = options.stage;
+        this.details = options.details;
+        this.partialData = options.partialData;
+    }
+}
+export function meetingValidationError(subtype, message, details) {
+    return new MeetingCliError('validation', subtype, message, {
+        details,
+        exitCode: ExitCode.UsageError,
+    });
+}
+export function meetingAuthError(subtype, message, details) {
+    return new MeetingCliError('authentication', subtype, message, {
+        details,
+        exitCode: ExitCode.AuthError,
+    });
+}
+export function meetingNetworkError(subtype, message, options = {}) {
+    return new MeetingCliError('network', subtype, message, {
+        ...options,
+        retryable: options.retryable ?? true,
+        exitCode: ExitCode.NetworkError,
+    });
+}
+export function meetingConfirmationError(action, details) {
+    return new MeetingCliError('confirmation', 'required', '该操作需要明确确认', {
+        details: { action, ...details },
+        exitCode: ExitCode.ConfirmationRequired,
+    });
+}
+export function meetingPartialError(message, partialData, details) {
+    return new MeetingCliError('partial', 'write_uncertain', message, {
+        details,
+        partialData,
+        exitCode: ExitCode.Partial,
+    });
+}
+/**
+ * 冲突命中（cansub=false 禁止提交）或冲突检测接口失败：一律拒绝建会。
+ * 与业务规范一致：禁止提交 → 直接拒绝；仅提醒 → 由调用方看 warnings。
+ */
+export function meetingConflictError(subtype, message, details) {
+    return new MeetingCliError('policy', subtype, message, {
+        details,
+        exitCode: ExitCode.ConfirmationRequired,
+    });
+}

package/dist/shortcuts/meeting/host.js

@@ -0,0 +1,167 @@
+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 { MeetingCliError, meetingAuthError, meetingNetworkError, meetingValidationError } from './errors.js';
+function inferProfile(ctx) {
+    const options = ctx.getGlobalOptions();
+    return options.profile || getActiveProfile();
+}
+/**
+ * E10 标准版（Java REST）与 EB 版（eBuilder formdata）响应契约：
+ * `code=200` 成功；或 `status=true` 成功（EB formdata 与部分标准接口）。
+ */
+export function isBusinessSuccess(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    if (typeof value.status === 'boolean')
+        return value.status;
+    if (value.code !== undefined && value.code !== null)
+        return Number(value.code) === 200;
+    return false;
+}
+export function businessMessage(value) {
+    if (!value || typeof value !== 'object')
+        return '泛微接口返回业务失败';
+    // actionMsg.message 是服务端权限/业务提示的常见载体（如"您没有变更权限！"），
+    // 必须优先保留原文，供 Agent 原样告知用户。
+    const candidates = [
+        value.msg,
+        value.message,
+        value.errMsg,
+        value.actionMsg?.message,
+        value.actionMsg?.msg,
+        value.data?.message,
+        value.data?.msg,
+    ];
+    for (const item of candidates) {
+        if (typeof item === 'string' && item.trim())
+            return item;
+    }
+    return '泛微接口返回业务失败';
+}
+function businessCode(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;
+}
+function assertPath(requestPath) {
+    if (typeof requestPath !== 'string' || !requestPath.startsWith('/') || requestPath.startsWith('//')) {
+        throw meetingValidationError('path_invalid', '请求路径必须是相对绝对路径');
+    }
+    if (/^https?:/i.test(requestPath) || /[\r\n]/.test(requestPath) || requestPath.includes('/../')) {
+        throw meetingValidationError('path_invalid', '请求路径不允许跨域或路径逃逸');
+    }
+    if (!requestPath.startsWith('/api/')) {
+        throw meetingValidationError('path_not_allowed', '会议模块只能调用 /api/ 路径');
+    }
+}
+function omitEmptyQueryValues(query) {
+    if (!query)
+        return undefined;
+    return Object.fromEntries(Object.entries(query).filter(([, value]) => value !== '' && value !== undefined));
+}
+function mapRuntimeNetworkError(error) {
+    if (error instanceof E10ApiError && error.type === 'network') {
+        throw meetingNetworkError(error.subtype, error.message, {
+            retryable: error.retryable,
+            details: error.details,
+        });
+    }
+    throw error;
+}
+export function createMeetingHost(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 request(request) {
+        const { method, path, query, body, operation, headers: extraHeaders = {}, timeoutMs = 30_000 } = request;
+        assertPath(path);
+        // 标准版会议接口硬性约定（standalone skill 实测）：不能带 workflow 专用头
+        // （Referer: /workflow/newflow 等），否则 400 系统错误；等价于 standalone
+        // 执行器的 --simple-header（仅 Content-Type + Cookie，由 runtime 托管）。
+        const resolvedMethod = method || (body === undefined ? 'GET' : 'POST');
+        let response;
+        try {
+            response = await (await runtime()).requestJson({
+                module: 'meeting',
+                operation,
+                method: resolvedMethod,
+                path,
+                query: omitEmptyQueryValues(query),
+                body,
+                headers: { ...extraHeaders },
+                // 会议接口存在裸数字长 ID（如 meetingExtend.mtId / creater），超 2^53 会被
+                // JSON.parse 舍入；开启大整数保护后按字符串保留，保证 ID 回查不失真。
+                bigIntStrings: true,
+                timeoutMs,
+            });
+        }
+        catch (error) {
+            mapRuntimeNetworkError(error);
+        }
+        if (response.status === 401 || response.status === 302) {
+            throw meetingAuthError('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 MeetingCliError('api', 'http_error', `泛微接口 HTTP ${response.status}`, {
+                    code: response.status,
+                    details: { status: response.status },
+                    exitCode: 1,
+                });
+            }
+            throw meetingNetworkError('protocol', `接口返回不是合法 JSON（HTTP ${response.status}）`, { retryable: false });
+        }
+        if (response.status < 200 || response.status >= 300) {
+            throw new MeetingCliError('api', 'http_error', `泛微接口 HTTP ${response.status}`, {
+                code: response.status,
+                details: { status: response.status, message: businessMessage(response.value) },
+                exitCode: 1,
+            });
+        }
+        if (!isBusinessSuccess(response.value)) {
+            const code = businessCode(response.value);
+            const message = businessMessage(response.value);
+            if (code === 403) {
+                throw new MeetingCliError('api', 'permission_denied', message || '当前租户未开放该会议接口权限，请联系管理员', {
+                    code,
+                    details: { code, message },
+                    exitCode: 1,
+                });
+            }
+            throw new MeetingCliError('api', 'business_error', message, {
+                code,
+                details: { code, message },
+                exitCode: 1,
+            });
+        }
+        return response.value;
+    }
+    return { request, getSession };
+}

package/dist/shortcuts/meeting/index.js

@@ -0,0 +1,123 @@
+import { readFile } from 'node:fs/promises';
+import { ExitCode, isCliError, toErrorEnvelope } from '../../core/errors.js';
+import { createMeetingContinuationSigner } from './continuation.js';
+import { createMeetingHost } from './host.js';
+import { meetingManifest } from './manifest.js';
+import { executeMeetingOperation } from './operations.js';
+import { meetingValidationError } 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 meetingValidationError('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 meetingValidationError('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 meetingValidationError('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 } : {}),
+        ...(result.warnings && result.warnings.length > 0 ? { warnings: result.warnings } : { 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 executeMeetingOperation(operation, input, {
+            ctx,
+            host: createMeetingHost(ctx),
+            continuation: createMeetingContinuationSigner(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 meetingShortcut = {
+    name: 'meeting',
+    description: '泛微E10会议管理 CLI（标准版：查询/冲突/预约/回执/签到）',
+    category: 'shortcut',
+    register({ program, action }) {
+        const meeting = program.command('meeting').description('泛微E10会议管理（模式探测/会议列表/会议室/类型/冲突检测/预约/回执/签到）');
+        meeting.command('schema')
+            .description('Print meeting operation manifest for agents')
+            .action(action((ctx) => {
+            ctx.output.write(meetingManifest, { json: true });
+        }));
+        meeting.command('run')
+            .description('Run a meeting operation with JSON input')
+            .argument('<operation>', 'operation name, e.g. meeting.room.list')
+            .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));
+        }));
+        // 高频便捷命令（薄包装，最终调用同一 operation 执行器）
+        meeting.command('today')
+            .description('查询今天的会议（meeting.list 薄包装）')
+            .action(action(async (ctx) => {
+            const today = new Date();
+            const pad = (value) => String(value).padStart(2, '0');
+            const date = `${today.getFullYear()}-${pad(today.getMonth() + 1)}-${pad(today.getDate())}`;
+            await executeAndPrint(ctx, 'meeting.list', { filterDate: date });
+        }));
+    },
+};

package/dist/shortcuts/meeting/manifest.js

@@ -0,0 +1,64 @@
+import { meetingOperationDefinitions } from './operations/registry.js';
+/**
+ * 未实现能力（禁用边界，不得编造或绕过）：
+ * - EB 版业务链路（query_mtDetail_list / create_meeting / 三件套 / 议题 / 纪要 / 报表）：
+ *   依赖 eBuilder formdata 动态字段与工作流集成，未随 v1 实现。
+ * - 周期会议走工作流（repeatWorkFlowBaseIds 非空）与 onlyFlowCreate=1 的流程建会：
+ *   需要 workflow 集成，create.prepare 会主动拒绝并提示。
+ * - 提前结束会议（meeting.over）：服务端为空实现（假成功），CLI 不提供。
+ * - 签到二维码（getQrCode 入参契约未确认）、签到写操作（signMeeting 等）、
+ *   会议室/会议类型管理（add/update/delete/lock/详情）：待后续版本评估。
+ *
+ * 已实现的生命周期写操作：meeting.change（变更：按会议状态自动选 operateType，
+ * 草稿=UPDATE / 正常=CHANGE）、meeting.cancel（取消）、meeting.delete（彻底删除），
+ * 均走 prepare→apply 确认链。权限由服务端按会议状态判定并返回原文提示，CLI 原样透传。
+ */
+const WITHHELD = [
+    {
+        name: 'meeting.eb.*',
+        reason: 'EB 版业务链路依赖 eBuilder formdata 动态字段结构与工作流集成，v1 未实现；请使用 EB 版独立流程或后续版本。',
+    },
+    {
+        name: 'meeting.create.workflow',
+        reason: 'onlyFlowCreate=1 或周期会议配置工作流时必须走流程建会；CLI v1 未集成工作流发起，create.prepare 会主动拒绝。',
+    },
+    {
+        name: 'meeting.over',
+        reason: '服务端提前结束会议（overMeeting）为空实现：MeetingDetailController.overMeetingDetail 中 service 调用被注释，接口直接返回成功但不生效；CLI 不提供该能力，禁止绕过（调用只会得到“假成功”）。',
+    },
+    {
+        name: 'meeting.sign.qrcode',
+        reason: '签到二维码接口（getQrCode）入参契约未在源资料中确认，未实现，不得猜测参数。',
+    },
+    {
+        name: 'meeting.sign.submit',
+        reason: '签到写操作（signMeeting 等）未实现，不得绕过确认链直接调用。',
+    },
+    {
+        name: 'meeting.room.admin / meeting.type.admin',
+        reason: '会议室/会议类型管理（add/update/delete/lock/详情）未实现，待后续版本评估。',
+    },
+];
+function buildOperations() {
+    return meetingOperationDefinitions().map((definition) => ({
+        name: definition.name,
+        resource: definition.resource,
+        summary: definition.summary,
+        capability: definition.capability,
+        risk: definition.risk,
+        ...(definition.requiresConfirmation ? { requiresConfirmation: true } : {}),
+        inputSchema: definition.inputSchema,
+    }));
+}
+export const meetingManifest = {
+    schemaVersion: 1,
+    name: 'meeting',
+    title: '泛微E10会议管理（标准版：查询/冲突/预约/取消/回执/签到）',
+    version: '1.0.0',
+    host: 'e10-meeting',
+    status: 'builtin',
+    sourceSkill: 'weaver-e10-meeting',
+    capabilities: ['env', 'meeting', 'room', 'type', 'conflict', 'lifecycle', 'receipt', 'sign'],
+    operations: buildOperations(),
+    withheldOperations: WITHHELD,
+};

package/dist/shortcuts/meeting/operations/catalogs.js

@@ -0,0 +1,58 @@
+import { meetingSuccess } from './types.js';
+import { extractRows } from './shared.js';
+// ---------------------------------------------------------------------------
+// 会议类型列表（mt_type browser 组件；总数走 count 接口）
+// ---------------------------------------------------------------------------
+const meetingTypeList = {
+    name: 'meeting.type.list',
+    resource: 'type',
+    method: 'type.list',
+    action: 'meeting.type.list',
+    summary: '查询会议类型列表（mt_type browser 组件，权限友好；includeCount=true 时再调 count/mt_type 取总数）',
+    capability: 'type',
+    risk: 'read',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            name: { type: 'string', description: '按类型名称过滤' },
+            current: { type: 'integer', description: '页码，默认 1' },
+            pageSize: { type: 'integer', description: '页大小，默认 100' },
+            includeCount: { type: 'boolean', description: '是否调用 count/mt_type 返回总数' },
+        },
+    },
+    handler: async (args, { host }) => {
+        const body = {
+            browserMultiple: false,
+            current: typeof args.current === 'number' && args.current > 0 ? args.current : 1,
+            pageSize: typeof args.pageSize === 'number' && args.pageSize > 0 ? args.pageSize : 100,
+            formDatas: typeof args.name === 'string' && args.name.trim()
+                ? { name: [{ nameCondition: 'in', name: args.name.trim() }] }
+                : {},
+            quickSearchDatas: {},
+            type: 'and',
+        };
+        const response = await host.request({
+            method: 'POST',
+            path: '/api/meeting/common/browser/data/mt_type',
+            operation: 'meeting.type.list',
+            body,
+        });
+        const { rows } = extractRows(response);
+        let total;
+        if (args.includeCount === true) {
+            const countResponse = await host.request({
+                method: 'POST',
+                path: '/api/meeting/common/browser/count/mt_type',
+                operation: 'meeting.type.list',
+                body: { ...body, formDatas: typeof args.name === 'string' && args.name.trim() ? body.formDatas : {} },
+            });
+            total = countResponse?.data?.total;
+        }
+        return meetingSuccess('meeting.type.list', {
+            ...(total !== undefined ? { total } : {}),
+            types: rows,
+        });
+    },
+};
+export const meetingCatalogOperations = [meetingTypeList];