weaver-work-cli 0.1.31 → 0.1.33

package/dist/shortcuts/cowork/errors.js

@@ -0,0 +1,59 @@
+import { CliError, ExitCode } from '../../core/errors.js';
+export class CoworkCliError extends CliError {
+    type;
+    subtype;
+    code;
+    retryable;
+    stage;
+    details;
+    partialData;
+    constructor(type, subtype, message, options = {}) {
+        super(message, options.exitCode ?? ExitCode.InternalError);
+        this.name = 'CoworkCliError';
+        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 coworkValidationError(subtype, message, details) {
+    return new CoworkCliError('validation', subtype, message, {
+        details,
+        exitCode: ExitCode.UsageError,
+    });
+}
+export function coworkAuthError(subtype, message, details) {
+    return new CoworkCliError('authentication', subtype, message, {
+        details,
+        exitCode: ExitCode.AuthError,
+    });
+}
+export function coworkNetworkError(subtype, message, options = {}) {
+    return new CoworkCliError('network', subtype, message, {
+        ...options,
+        retryable: options.retryable ?? true,
+        exitCode: ExitCode.NetworkError,
+    });
+}
+export function coworkConfirmationError(action, details) {
+    return new CoworkCliError('confirmation', 'required', '该操作需要明确确认', {
+        details: { action, ...details },
+        exitCode: ExitCode.ConfirmationRequired,
+    });
+}
+export function coworkPartialError(message, partialData, details) {
+    return new CoworkCliError('partial', 'write_uncertain', message, {
+        details,
+        partialData,
+        exitCode: ExitCode.Partial,
+    });
+}
+export function coworkNotFoundError(subtype, message, details) {
+    return new CoworkCliError('not_found', subtype, message, {
+        details,
+        exitCode: ExitCode.UsageError,
+    });
+}

package/dist/shortcuts/cowork/host.js

@@ -0,0 +1,172 @@
+import { E10_SESSION_EXPIRED_MESSAGE } from '../../internal/e10/auth/messages.js';
+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 { CoworkCliError, coworkAuthError, coworkNetworkError, coworkValidationError } from './errors.js';
+function inferProfile(ctx) {
+    const options = ctx.getGlobalOptions();
+    return options.profile || getActiveProfile();
+}
+/**
+ * 协作接口成功判定（口径取自技能侧 cowork-write.mjs 的 `opOk`，真机实测）。
+ *
+ * 协作各子系统的响应形状不统一：
+ * - 主流程写操作：`{ status: true, id }` / `data: "SUCCESS"` / `data: 1`
+ * - 查询/列表：`{ code: 200, status: true, msg, data: {...} }`
+ * - 行为/审批：`data: "SUCCESS"`，data 也可能直接是 `true`
+ * 因此按「根 status / code 200 / data 的 SUCCESS|1|true / data.status」四路判定。
+ */
+export function isCoworkSuccess(value) {
+    if (value === 'SUCCESS' || value === 1 || value === true)
+        return true;
+    if (!value || typeof value !== 'object')
+        return false;
+    if (value.fail === true)
+        return false;
+    if (value.status === true)
+        return true;
+    if (value.code !== undefined && value.code !== null && Number(value.code) === 200)
+        return true;
+    const data = value.data;
+    if (data === 'SUCCESS' || data === 1 || data === true)
+        return true;
+    if (data && typeof data === 'object' && data.status === true)
+        return true;
+    return false;
+}
+export function coworkBusinessMessage(value) {
+    if (!value || typeof value !== 'object')
+        return '协作接口返回业务失败';
+    const candidates = [value.msg, value.message, value.data?.msg, value.data?.message, value.error];
+    for (const item of candidates) {
+        if (typeof item === 'string' && item.trim())
+            return item;
+    }
+    return '协作接口返回业务失败';
+}
+function coworkBusinessCode(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 assertPath(requestPath) {
+    if (typeof requestPath !== 'string' || !requestPath.startsWith('/') || requestPath.startsWith('//')) {
+        throw coworkValidationError('path_invalid', '请求路径必须是相对绝对路径');
+    }
+    if (/^https?:/i.test(requestPath) || /[\r\n]/.test(requestPath) || requestPath.includes('/../')) {
+        throw coworkValidationError('path_invalid', '请求路径不允许跨域或路径逃逸');
+    }
+    if (!requestPath.startsWith('/api/cowork/')) {
+        throw coworkValidationError('path_not_allowed', '协作模块只能调用 /api/cowork/ 路径');
+    }
+}
+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 : String(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 coworkNetworkError(error.subtype, error.message, {
+            retryable: error.retryable,
+            details: error.details,
+        });
+    }
+    throw error;
+}
+export function createCoworkHost(ctx, dependencies = {}) {
+    let e10Session = null;
+    let sessionContext = null;
+    // 与 workflow 模块同口径（2026-10-29 实测）：auth 文件里已有登录时落盘的 userId，
+    // 业务命令不需要 teamsCheck 的登录人信息富化 ⇒ 跳过它，省掉每次调用一次串行 HTTPS 往返（实测约 150~250ms）。
+    const requireSession = dependencies.requireSession
+        || ((innerCtx) => requireE10Session(innerCtx, { skipProfileEnrichment: true }));
+    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, form, operation, headers: extraHeaders = {}, timeoutMs = 30_000, } = request;
+        assertPath(path);
+        const resolvedMethod = method || (body === undefined && form === undefined ? 'GET' : 'POST');
+        let response;
+        try {
+            response = await (await runtime()).requestJson({
+                module: 'cowork',
+                operation,
+                method: resolvedMethod,
+                path,
+                query: omitEmptyQueryValues(query),
+                body: form === undefined ? body : undefined,
+                form: form === undefined ? undefined : formBody(form),
+                headers: { 'X-Requested-With': 'XMLHttpRequest', ...extraHeaders },
+                timeoutMs,
+            });
+        }
+        catch (error) {
+            mapRuntimeNetworkError(error);
+        }
+        if (response.status === 401 || response.status === 302) {
+            throw coworkAuthError('session_expired', E10_SESSION_EXPIRED_MESSAGE, { httpStatus: response.status });
+        }
+        if (response.parseError) {
+            if (response.status < 200 || response.status >= 300) {
+                throw new CoworkCliError('api', 'http_error', `协作接口 HTTP ${response.status}`, {
+                    code: response.status,
+                    details: { status: response.status },
+                    exitCode: 1,
+                });
+            }
+            throw coworkNetworkError('protocol', `接口返回不是合法 JSON（HTTP ${response.status}）`, { retryable: false });
+        }
+        if (response.status < 200 || response.status >= 300) {
+            throw new CoworkCliError('api', 'http_error', `协作接口 HTTP ${response.status}`, {
+                code: response.status,
+                details: { status: response.status, message: coworkBusinessMessage(response.value) },
+                exitCode: 1,
+            });
+        }
+        if (!isCoworkSuccess(response.value)) {
+            throw new CoworkCliError('api', 'business_error', coworkBusinessMessage(response.value), {
+                code: coworkBusinessCode(response.value),
+                details: { code: coworkBusinessCode(response.value), message: coworkBusinessMessage(response.value) },
+                exitCode: 1,
+            });
+        }
+        return response.value;
+    }
+    return { request, getSession };
+}

package/dist/shortcuts/cowork/index.js

@@ -0,0 +1,166 @@
+import { readFile } from 'node:fs/promises';
+import { ExitCode, isCliError, toErrorEnvelope } from '../../core/errors.js';
+import { createCoworkContinuationSigner } from './continuation.js';
+import { createCoworkHost } from './host.js';
+import { coworkManifest } from './manifest.js';
+import { executeCoworkOperation } from './operations.js';
+import { coworkValidationError } 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+/, '');
+}
+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 coworkValidationError('input_invalid', `${label} 不是合法 JSON 对象`);
+    }
+}
+export async function inputFrom(options, extra = {}) {
+    const opts = asOptions(options);
+    let input = {};
+    if (opts.input && opts.inputJson) {
+        throw coworkValidationError('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 coworkValidationError('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: [],
+    };
+}
+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 executeCoworkOperation(operation, input, {
+            ctx,
+            host: createCoworkHost(ctx),
+            continuation: createCoworkContinuationSigner(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 coworkShortcut = {
+    name: 'cowork',
+    description: '泛微E10协作区（协作事项/讨论/审批/共享权限）CLI',
+    category: 'shortcut',
+    register({ program, action }) {
+        const cowork = program.command('cowork').description('泛微E10协作区（协作事项/讨论/审批/共享权限）');
+        cowork.command('schema')
+            .description('Print cowork operation manifest for agents')
+            .action(action((ctx) => {
+            ctx.output.write(coworkManifest, { json: true });
+        }));
+        cowork.command('run')
+            .description('Run a cowork operation with JSON input')
+            .argument('<operation>', 'operation name, e.g. cowork.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));
+        }));
+        // ---- 高频便捷命令 ----
+        cowork.command('list')
+            .description('协作列表（默认进行中）')
+            .option('--input <path>', 'JSON input file, or - for stdin')
+            .option('--scope <scope>', 'main/attention/collect/mineDiscuss/mineItem/related/apply/approve/log/quit/itemApprove/discussApprove')
+            .option('--keyword <text>', '协作主题关键字')
+            .option('--page <n>', 'page number')
+            .option('--size <n>', 'page size')
+            .action(action(async (ctx, options) => {
+            const opts = asOptions(options);
+            await executeAndPrint(ctx, 'cowork.list', await inputFrom(options, {
+                scope: opts.scope || 'main',
+                itemName: opts.keyword,
+                itemNameCondition: opts.keyword ? 'bl' : undefined,
+                current: opts.page ? Number(opts.page) : undefined,
+                pageSize: opts.size ? Number(opts.size) : undefined,
+            }));
+        }));
+        cowork.command('view')
+            .description('协作详情')
+            .option('--input <path>', 'JSON input file, or - for stdin')
+            .option('--id <id>', 'cowork id')
+            .action(action(async (ctx, options) => {
+            const opts = asOptions(options);
+            await executeAndPrint(ctx, 'cowork.view', await inputFrom(options, { id: opts.id }));
+        }));
+        cowork.command('discussions')
+            .description('协作讨论记录')
+            .option('--input <path>', 'JSON input file, or - for stdin')
+            .option('--id <id>', 'cowork id')
+            .option('--page <n>', 'page number')
+            .action(action(async (ctx, options) => {
+            const opts = asOptions(options);
+            await executeAndPrint(ctx, 'cowork.discuss.list', await inputFrom(options, {
+                coworkId: opts.id,
+                current: opts.page ? Number(opts.page) : undefined,
+            }));
+        }));
+        cowork.command('sections')
+            .description('新建协作可选版块（从新建表单解析）')
+            .action(action(async (ctx) => {
+            await executeAndPrint(ctx, 'cowork.form', await inputFrom({}));
+        }));
+        cowork.command('reply')
+            .description('发布/回复讨论（prepare，确认后 apply）')
+            .option('--input <path>', 'JSON input file, or - for stdin')
+            .option('--id <id>', 'cowork id')
+            .option('--content <text>', 'discussion content')
+            .action(action(async (ctx, options) => {
+            const opts = asOptions(options);
+            await executeAndPrint(ctx, 'cowork.discuss.publish.prepare', await inputFrom(options, {
+                coworkId: opts.id,
+                content: opts.content,
+            }));
+        }));
+    },
+};

package/dist/shortcuts/cowork/manifest.js

@@ -0,0 +1,65 @@
+import { coworkOperationDefinitions } from './operations/registry.js';
+/**
+ * 浏览选择类（common/browser）32 个接口 + 点赞组件（upvoteComponent）3 个接口：
+ * 源资料只给出 `POST /api/cowork/common/browser/<action>/<object>` 的 path 清单，
+ * 明确声明「不展开请求/响应结构」。缺少请求体字段表就无法给出逐字段 inputSchema，
+ * 按「不补推测能力」原则不实现；需要时先补抓一次页面请求体再落地。
+ */
+const BROWSER_WITHHELD = [
+    'cowork.browser.associate',
+    'cowork.browser.complete',
+    'cowork.browser.condition',
+    'cowork.browser.data',
+    'cowork.browser.destData',
+    'cowork.browser.history',
+    'cowork.browser.leftData',
+    'cowork.browser.prop',
+    'cowork.upvote.vote',
+    'cowork.upvote.cancel',
+    'cowork.upvote.voters',
+];
+/** 权限单元高级配置：`table/info`、`table/update` 是前端表单联动的内部结构（级联规则、多维数组），无稳定契约。 */
+const PERMISSION_TABLE_WITHHELD = [
+    'cowork.permission.table.info',
+    'cowork.permission.table.update',
+];
+/** 搜索组件的 UI 元数据与行为记录（公共条件/默认快照/历史/个人匹配词/快照名/加历史），无业务语义。 */
+const SEARCH_WITHHELD = [
+    'cowork.search.meta',
+    'cowork.search.history',
+];
+function buildOperations() {
+    return coworkOperationDefinitions().map((definition) => ({
+        name: definition.name,
+        resource: definition.resource,
+        summary: definition.summary,
+        risk: definition.risk,
+        ...(definition.requiresConfirmation ? { requiresConfirmation: true } : {}),
+        inputSchema: definition.inputSchema,
+    }));
+}
+export const coworkManifest = {
+    schemaVersion: 1,
+    name: 'cowork',
+    title: '泛微E10协作区（协作事项/讨论/审批/共享权限）',
+    version: '0.1.0',
+    host: 'e10-cowork',
+    status: 'builtin',
+    sourceSkill: 'weaver-e10-cowork',
+    capabilities: ['cowork'],
+    operations: buildOperations(),
+    withheldOperations: [
+        ...BROWSER_WITHHELD.map((name) => ({
+            name,
+            reason: '浏览选择/点赞组件接口：源资料只提供 path 清单，未给出请求体字段表，无法逐字段建模。选人/选部门请改用 ehr 模块的人员与组织查询能力取 id；补齐方式：抓一次页面请求体后再实现。不得凭猜测构造请求体。',
+        })),
+        ...PERMISSION_TABLE_WITHHELD.map((name) => ({
+            name,
+            reason: '共享权限单元的高级配置（对象类型/安全级别/级联规则）是前端表单内部结构，无稳定入参契约；常规授权/取消授权请用 cowork.permission.add / cowork.permission.remove。',
+        })),
+        ...SEARCH_WITHHELD.map((name) => ({
+            name,
+            reason: '搜索组件的 UI 元数据与搜索历史记录，属前端交互行为，对 Agent 无业务语义；列表筛选请直接用 cowork.list 的条件字段（字段集合以 cowork.conditions 返回为准）。',
+        })),
+    ],
+};