weaver-work-cli 0.1.2 → 0.1.5

package/dist/shortcuts/calendar/host.js

@@ -0,0 +1,148 @@
+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 { calendarAuthError, calendarNetworkError, CalendarCliError, calendarValidationError } from './errors.js';
+function inferProfile(ctx) {
+    const options = ctx.getGlobalOptions();
+    return options.profile || getActiveProfile();
+}
+/**
+ * 判断业务是否成功。日程模块三类响应契约：
+ * - datajson 结构（创建/查询详情/总数/更新/删除/类型/紧急程度）：`datajson.status === true`
+ * - ESB 流程触发结构（列表查询）：`resultCode === 200`
+ * - 版本检测 GET 接口（getAppIds / querySpAppVersionInfo / getObjsByTag）：无失败标志且有 `data` 字段
+ */
+export function isBusinessSuccess(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const datajson = value.datajson;
+    if (datajson && typeof datajson === 'object') {
+        return datajson.status === true;
+    }
+    if (value.resultCode !== undefined && value.resultCode !== null) {
+        return Number(value.resultCode) === 200;
+    }
+    // 普通 GET 接口：无明确失败标志时，有 data 字段即视为成功（空数组/空对象也返回，由调用方解读）
+    if ('data' in value)
+        return true;
+    return false;
+}
+export function businessMessage(value) {
+    if (!value || typeof value !== 'object')
+        return '泛微接口返回业务失败';
+    const candidates = [value.resultMsg, value.msg, value.message, value.datajson?.message];
+    for (const item of candidates) {
+        if (typeof item === 'string' && item.trim())
+            return item;
+    }
+    return '泛微接口返回业务失败';
+}
+function assertPath(requestPath) {
+    if (typeof requestPath !== 'string' || !requestPath.startsWith('/') || requestPath.startsWith('//')) {
+        throw calendarValidationError('path_invalid', '请求路径必须是相对绝对路径');
+    }
+    if (/^https?:/i.test(requestPath) || /[\r\n]/.test(requestPath) || requestPath.includes('/../')) {
+        throw calendarValidationError('path_invalid', '请求路径不允许跨域或路径逃逸');
+    }
+    if (!requestPath.startsWith('/api/')) {
+        throw calendarValidationError('path_not_allowed', '日程模块只能调用 /api/ 路径');
+    }
+}
+function omitEmptyQueryValues(query) {
+    if (!query)
+        return undefined;
+    return Object.fromEntries(Object.entries(query).filter(([, value]) => value !== '' && value !== undefined && value !== null));
+}
+function mapRuntimeNetworkError(error) {
+    if (error instanceof E10ApiError && error.type === 'network') {
+        throw calendarNetworkError(error.subtype, error.message, {
+            retryable: error.retryable,
+            details: error.details,
+        });
+    }
+    throw error;
+}
+export function createCalendarHost(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, timeoutMs = 30_000 } = request;
+        assertPath(path);
+        const resolvedMethod = method || 'POST';
+        let response;
+        try {
+            response = await (await runtime()).requestJson({
+                module: 'calendar',
+                operation,
+                method: resolvedMethod,
+                path,
+                query: omitEmptyQueryValues(query),
+                body,
+                headers: { 'X-Requested-With': 'XMLHttpRequest' },
+                timeoutMs,
+            });
+        }
+        catch (error) {
+            mapRuntimeNetworkError(error);
+        }
+        if (response.status === 401 || response.status === 302) {
+            throw calendarAuthError('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 CalendarCliError('api', 'http_error', `泛微接口 HTTP ${response.status}`, {
+                    code: response.status,
+                    details: { status: response.status },
+                    exitCode: 1,
+                });
+            }
+            throw calendarNetworkError('protocol', `接口返回不是合法 JSON（HTTP ${response.status}）`, { retryable: false });
+        }
+        if (response.status < 200 || response.status >= 300) {
+            throw new CalendarCliError('api', 'http_error', `泛微接口 HTTP ${response.status}`, {
+                code: response.status,
+                details: { status: response.status, message: businessMessage(response.value) },
+                exitCode: 1,
+            });
+        }
+        // HTTP 404：源资料判定为「日程应用未安装」，需给出明确提示而非当作普通失败。
+        if (response.status === 404) {
+            throw new CalendarCliError('api', 'app_not_installed', '接口返回 404，当前环境可能未安装「日程」应用，请先安装/部署应用后再试', {
+                code: response.status,
+                exitCode: 1,
+            });
+        }
+        if (!isBusinessSuccess(response.value)) {
+            throw new CalendarCliError('api', 'business_error', businessMessage(response.value), {
+                details: { message: businessMessage(response.value) },
+                exitCode: 1,
+            });
+        }
+        return response.value;
+    }
+    return { request, getSession };
+}

package/dist/shortcuts/calendar/index.js

@@ -0,0 +1,125 @@
+import { readFile } from 'node:fs/promises';
+import { ExitCode, isCliError, toErrorEnvelope } from '../../core/errors.js';
+import { createCalendarContinuationSigner } from './continuation.js';
+import { createCalendarHost } from './host.js';
+import { calendarManifest } from './manifest.js';
+import { executeCalendarOperation } from './operations.js';
+import { calendarValidationError } 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');
+}
+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 calendarValidationError('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 calendarValidationError('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 calendarValidationError('input_invalid', `${label} 不是合法 JSON 对象`);
+    }
+}
+export function successEnvelope(operation, result) {
+    return {
+        schemaVersion: 1,
+        ok: true,
+        operation,
+        data: result.data === undefined ? null : result.data,
+        ...(result.meta ? { meta: result.meta } : {}),
+        warnings: [],
+    };
+}
+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 executeCalendarOperation(operation, input, {
+            ctx,
+            host: createCalendarHost(ctx),
+            continuation: createCalendarContinuationSigner(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 calendarShortcut = {
+    name: 'calendar',
+    description: '泛微E10日程管理 CLI（创建/查询/更新/删除/字典）',
+    category: 'shortcut',
+    register({ program, action }) {
+        const calendar = program.command('calendar').description('泛微E10日程管理（创建/查询列表/详情/总数/更新/删除/类型/紧急程度）');
+        calendar.command('schema')
+            .description('Print calendar operation manifest for agents')
+            .action(action((ctx) => {
+            ctx.output.write(calendarManifest, { json: true });
+        }));
+        calendar.command('run')
+            .description('Run a calendar operation with JSON input')
+            .argument('<operation>', 'operation name, e.g. calendar.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));
+        }));
+        // 高频便捷命令
+        calendar.command('get')
+            .description('查询单条日程详情（calendar.get 薄包装）')
+            .option('--input <path>', 'JSON input file, or - for stdin')
+            .option('--input-json <json>', 'inline JSON input object')
+            .option('--id <id>', '日程数据 ID')
+            .action(action(async (ctx, options) => {
+            const opts = asOptions(options);
+            await executeAndPrint(ctx, 'calendar.get', await inputFrom(options, { id: opts.id }));
+        }));
+        calendar.command('count')
+            .description('查询日程总数（calendar.count 薄包装）')
+            .action(action(async (ctx) => {
+            await executeAndPrint(ctx, 'calendar.count', {});
+        }));
+    },
+};

package/dist/shortcuts/calendar/manifest.js

@@ -0,0 +1,26 @@
+import { calendarOperationDefinitions } from './operations/registry.js';
+/** 禁用边界：日程模块暂无暂缓能力，所有源资料能力均已实现。 */
+const WITHHELD = [];
+function buildOperations() {
+    return calendarOperationDefinitions().map((definition) => ({
+        name: definition.name,
+        resource: definition.resource,
+        summary: definition.summary,
+        ...(definition.capability ? { capability: definition.capability } : {}),
+        risk: definition.risk,
+        ...(definition.requiresConfirmation ? { requiresConfirmation: true } : {}),
+        inputSchema: definition.inputSchema,
+    }));
+}
+export const calendarManifest = {
+    schemaVersion: 1,
+    name: 'calendar',
+    title: '泛微E10日程管理（创建/查询/更新/删除/字典）',
+    version: '0.1.0',
+    host: 'e10-calendar',
+    status: 'builtin',
+    sourceSkill: 'weaver-e10-calendar',
+    capabilities: ['calendar'],
+    operations: buildOperations(),
+    withheldOperations: WITHHELD,
+};

package/dist/shortcuts/calendar/operations/read.js

@@ -0,0 +1,259 @@
+import { calendarSuccess, schemaOf, SCHEMA_ID } from './types.js';
+// ESB 日程列表查询流程唯一标识（来自源资料 catalog.md）
+const LIST_UNIQUE_INDENT = 'E49255BD213B480CB13DFB8E1B4159ED';
+const AGENDA_APP_TAG = 'weaver-calendar-eb';
+const AGENDA_FORM_TAG = 'uf_agn_agenda';
+const MIN_APP_VERSION = '4.1.4';
+/** 构造 datajson 结构请求体并自动填充 header.operator。 */
+async function buildDatajson(host, mainTable, extra = {}) {
+    const session = await host.getSession();
+    const datajson = {
+        mainTable,
+        header: { operator: session.userId },
+        ...extra,
+    };
+    return { datajson };
+}
+/** 分页参数：源资料 pageInfo.pageNo/pageSize 为字符串类型。 */
+function pageInfo(args) {
+    const pageNo = args.pageNo !== undefined ? String(args.pageNo) : undefined;
+    const pageSize = args.pageSize !== undefined ? String(args.pageSize) : undefined;
+    if (pageNo === undefined && pageSize === undefined)
+        return undefined;
+    return {
+        pageNo: pageNo ?? '1',
+        pageSize: pageSize ?? '10',
+    };
+}
+// ---------------------------------------------------------------------------
+// 查询日程列表（ESB 流程触发）
+// ---------------------------------------------------------------------------
+const calendarList = {
+    name: 'calendar.list',
+    resource: 'calendar',
+    method: 'list',
+    action: 'calendar.list',
+    summary: '分页查询日程列表，支持按时间范围和关键字筛选；也用于更新/删除前按名称获取日程 ID',
+    capability: 'calendar',
+    risk: 'read',
+    inputSchema: schemaOf({
+        start_time: { type: 'string', pattern: '^\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}$', description: '开始时间筛选（yyyy-MM-dd HH:mm）' },
+        end_time: { type: 'string', pattern: '^\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}$', description: '结束时间筛选（yyyy-MM-dd HH:mm）' },
+        keywork: { type: 'string', description: '关键字检索（按日程名称模糊匹配，字段名拼写为 keywork）' },
+        page_no: { type: 'integer', minimum: 1, default: 1, description: '页码' },
+        page_size: { type: 'integer', minimum: 1, maximum: 100, default: 10, description: '每页条数' },
+    }),
+    handler: async (args, { host }) => {
+        const mainTable = {};
+        if (args.start_time !== undefined)
+            mainTable.start_time = args.start_time;
+        if (args.end_time !== undefined)
+            mainTable.end_time = args.end_time;
+        if (args.keywork !== undefined)
+            mainTable.keywork = args.keywork;
+        if (args.page_no !== undefined)
+            mainTable.page_no = args.page_no;
+        if (args.page_size !== undefined)
+            mainTable.page_size = args.page_size;
+        const response = await host.request({
+            method: 'POST',
+            path: '/api/esb/server/event/triggerActionFlow',
+            operation: 'calendar.list',
+            body: {
+                customParams: { mainTable },
+                moduleSource: '',
+                uniqueIndent: LIST_UNIQUE_INDENT,
+            },
+        });
+        return calendarSuccess('calendar.list', response);
+    },
+};
+// ---------------------------------------------------------------------------
+// 查询日程详情
+// ---------------------------------------------------------------------------
+const calendarGet = {
+    name: 'calendar.get',
+    resource: 'calendar',
+    method: 'get',
+    action: 'calendar.get',
+    summary: '按日程数据 ID 查询单条日程完整信息；也作为更新、删除前的辅助查询',
+    capability: 'calendar',
+    risk: 'read',
+    inputSchema: schemaOf({ id: SCHEMA_ID }, { required: ['id'] }),
+    handler: async (args, { host }) => {
+        const id = String(args.id);
+        const body = await buildDatajson(host, { id });
+        const response = await host.request({
+            method: 'POST',
+            path: '/api/ebuilder/form/formdata/v2/getFormDataByPk/queryAgenda',
+            operation: 'calendar.get',
+            body,
+        });
+        return calendarSuccess('calendar.get', response);
+    },
+};
+// ---------------------------------------------------------------------------
+// 查询日程总数
+// ---------------------------------------------------------------------------
+const calendarCount = {
+    name: 'calendar.count',
+    resource: 'calendar',
+    method: 'count',
+    action: 'calendar.count',
+    summary: '查询日程数据总数量',
+    capability: 'calendar',
+    risk: 'read',
+    inputSchema: schemaOf({}),
+    handler: async (_args, { host }) => {
+        const body = await buildDatajson(host, {});
+        const response = await host.request({
+            method: 'POST',
+            path: '/api/ebuilder/form/formdata/v2/getFormDataCount/queryAgendaCount',
+            operation: 'calendar.count',
+            body,
+        });
+        return calendarSuccess('calendar.count', response);
+    },
+};
+// ---------------------------------------------------------------------------
+// 查询日程紧急程度 / 查询日程类型（两个字典接口结构一致）
+// ---------------------------------------------------------------------------
+function dictOperation(name, method, summary, path, filterField) {
+    return {
+        name,
+        resource: 'calendar',
+        method,
+        action: name,
+        summary,
+        capability: 'calendar',
+        risk: 'read',
+        inputSchema: schemaOf({
+            ...(filterField
+                ? { [filterField]: { type: 'string', description: '按名称筛选；不传则查询全部（注意不可传空字符串）' } }
+                : {}),
+            pageNo: { type: 'integer', minimum: 1, default: 1 },
+            pageSize: { type: 'integer', minimum: 1, maximum: 100, default: 10 },
+        }),
+        handler: async (args, { host }) => {
+            const mainTable = {};
+            if (filterField && args[filterField] !== undefined) {
+                mainTable[filterField] = args[filterField];
+            }
+            const page = pageInfo(args);
+            const body = await buildDatajson(host, mainTable, page ? { pageInfo: page } : {});
+            const response = await host.request({
+                method: 'POST',
+                path,
+                operation: name,
+                body,
+            });
+            return calendarSuccess(name, response);
+        },
+    };
+}
+const calendarPriorityList = dictOperation('calendar.priority.list', 'priority.list', '查询日程紧急程度选项列表（priority 字段可选值）', '/api/ebuilder/form/formdata/v2/getFormDataList/queryAgendaPriority', 'priority_name');
+const calendarTypeList = dictOperation('calendar.type.list', 'type.list', '查询日程类型选项列表（agn_type 字段可选值）', '/api/ebuilder/form/formdata/v2/getFormDataList/queryAgendaType', 'type_name');
+// ---------------------------------------------------------------------------
+// 版本检测（三步 GET）
+// ---------------------------------------------------------------------------
+function compareVersion(a, b) {
+    const pa = a.split('.').map((part) => Number(part) || 0);
+    const pb = b.split('.').map((part) => Number(part) || 0);
+    const length = Math.max(pa.length, pb.length);
+    for (let i = 0; i < length; i++) {
+        const x = pa[i] ?? 0;
+        const y = pb[i] ?? 0;
+        if (x !== y)
+            return x > y ? 1 : -1;
+    }
+    return 0;
+}
+function firstId(value) {
+    if (Array.isArray(value) && value.length > 0) {
+        const first = value[0];
+        if (typeof first === 'string' || typeof first === 'number')
+            return String(first);
+        if (first && typeof first === 'object') {
+            const record = first;
+            const id = record.id ?? record.appId ?? record.app_id;
+            if (id !== undefined && id !== null && id !== '')
+                return String(id);
+        }
+    }
+    if (typeof value === 'string' || typeof value === 'number')
+        return String(value);
+    return undefined;
+}
+const calendarAppCheck = {
+    name: 'calendar.app.check',
+    resource: 'calendar',
+    method: 'app.check',
+    action: 'calendar.app.check',
+    summary: '检测「日程」应用是否安装及版本（要求 >= 4.1.4），并返回日程表单 ID（用于详情卡片页链接）',
+    capability: 'calendar',
+    risk: 'read',
+    inputSchema: schemaOf({}),
+    handler: async (_args, { host }) => {
+        // 1. getAppIds 取当前环境 appId
+        const appIdsResponse = await host.request({
+            method: 'GET',
+            path: '/api/bs/ebuilder/app/tags/getAppIds',
+            operation: 'calendar.app.check',
+            query: { tag: AGENDA_APP_TAG },
+        }).catch(() => undefined);
+        const appId = firstId(appIdsResponse?.data);
+        if (!appId) {
+            return calendarSuccess('calendar.app.check', {
+                installed: false,
+                reason: 'app_not_found',
+                message: '未检测到「日程」应用（getAppIds 未返回 appId），请先安装应用',
+            });
+        }
+        // 2. 查询版本信息
+        const versionResponse = await host.request({
+            method: 'GET',
+            path: '/api/installer/public/querySpAppVersionInfo',
+            operation: 'calendar.app.check',
+            query: { appId },
+        }).catch(() => undefined);
+        const commitVersion = versionResponse?.data?.commitVersion ?? versionResponse?.commitVersion;
+        // 3. 查询日程表单 ID（偶发空返回，参数原样重试最多 3 次）
+        let formId;
+        for (let attempt = 0; attempt < 3 && !formId; attempt++) {
+            const formResponse = await host.request({
+                method: 'GET',
+                path: '/api/ebuilder/form/obj/getObjsByTag',
+                operation: 'calendar.app.check',
+                query: { tag: AGENDA_FORM_TAG, appId },
+            }).catch(() => undefined);
+            formId = firstId(formResponse?.data);
+            if (!formId && attempt < 2) {
+                await new Promise((resolve) => setTimeout(resolve, 800));
+            }
+        }
+        const hasVersion = typeof commitVersion === 'string' && commitVersion.trim() !== '';
+        const installed = hasVersion && commitVersion !== null && commitVersion !== undefined;
+        const versionOk = installed && compareVersion(commitVersion, MIN_APP_VERSION) >= 0;
+        return calendarSuccess('calendar.app.check', {
+            installed,
+            appId,
+            commitVersion: installed ? commitVersion : null,
+            versionOk,
+            minRequiredVersion: MIN_APP_VERSION,
+            formId: formId ?? null,
+            status: !installed
+                ? 'NOT_INSTALLED'
+                : versionOk
+                    ? 'OK'
+                    : 'VERSION_TOO_LOW',
+        });
+    },
+};
+export const calendarReadOperations = [
+    calendarList,
+    calendarGet,
+    calendarCount,
+    calendarPriorityList,
+    calendarTypeList,
+    calendarAppCheck,
+];

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

@@ -0,0 +1,31 @@
+import { calendarValidationError } from '../errors.js';
+import { calendarReadOperations } from './read.js';
+import { calendarWriteOperations } from './write.js';
+function buildRegistry() {
+    const registry = new Map();
+    const definitions = [
+        ...calendarReadOperations,
+        ...calendarWriteOperations,
+    ];
+    for (const definition of definitions) {
+        if (registry.has(definition.name)) {
+            throw new Error(`duplicate calendar operation: ${definition.name}`);
+        }
+        registry.set(definition.name, definition);
+    }
+    return registry;
+}
+const calendarOperationRegistry = buildRegistry();
+export function calendarOperationDefinitions() {
+    return [...calendarOperationRegistry.values()];
+}
+export function getCalendarOperation(operation) {
+    const definition = calendarOperationRegistry.get(operation);
+    if (!definition) {
+        throw calendarValidationError('operation_unknown', `日程模块不支持操作：${operation}`);
+    }
+    return definition;
+}
+export function hasCalendarOperation(operation) {
+    return calendarOperationRegistry.has(operation);
+}