weaver-work-cli 0.1.6 → 0.1.7

package/dist/shortcuts/okr/operations.js

@@ -0,0 +1,8 @@
+import { getOkrOperation } from './operations/registry.js';
+import { assertNoForbiddenKeys, asObject } from './operations/shared.js';
+export async function executeOkrOperation(operation, rawInput, context) {
+    const definition = getOkrOperation(operation);
+    const input = asObject(rawInput);
+    assertNoForbiddenKeys(input);
+    return definition.handler(input, context);
+}

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

package/dist/shortcuts/project/errors.js

@@ -0,0 +1,53 @@
+import { CliError, ExitCode } from '../../core/errors.js';
+export class ProjectCliError extends CliError {
+    type;
+    subtype;
+    code;
+    retryable;
+    stage;
+    details;
+    partialData;
+    constructor(type, subtype, message, options = {}) {
+        super(message, options.exitCode ?? ExitCode.InternalError);
+        this.name = 'ProjectCliError';
+        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 projectValidationError(subtype, message, details) {
+    return new ProjectCliError('validation', subtype, message, {
+        details,
+        exitCode: ExitCode.UsageError,
+    });
+}
+export function projectAuthError(subtype, message, details) {
+    return new ProjectCliError('authentication', subtype, message, {
+        details,
+        exitCode: ExitCode.AuthError,
+    });
+}
+export function projectNetworkError(subtype, message, options = {}) {
+    return new ProjectCliError('network', subtype, message, {
+        ...options,
+        retryable: options.retryable ?? true,
+        exitCode: ExitCode.NetworkError,
+    });
+}
+export function projectApiError(subtype, message, details) {
+    return new ProjectCliError('api', subtype, message, {
+        details,
+        exitCode: ExitCode.GeneralError,
+    });
+}
+export function projectPartialError(message, partialData, details) {
+    return new ProjectCliError('partial', 'write_uncertain', message, {
+        details,
+        partialData,
+        exitCode: ExitCode.Partial,
+    });
+}

package/dist/shortcuts/project/host.js

@@ -0,0 +1,160 @@
+import { getActiveProfile } from '../../internal/e10/auth/session.js';
+import { requireE10Session } from '../../internal/e10/context.js';
+import { E10ApiError, createE10RequestRuntime } from '../../internal/e10/request-runtime.js';
+import { ProjectCliError, projectApiError, projectAuthError, projectNetworkError, projectValidationError, } from './errors.js';
+const PROJECT_PATH_PREFIXES = [
+    '/api/ebuilder/form/formdata/v2/',
+    '/api/ebuilder/form/dataset/v2/',
+    '/api/ebuilder/common/ds/',
+    '/api/ebproject/backendConsole/',
+    '/api/bs/ebuilder/app/tags/',
+    '/api/hrm/common/browser/',
+    '/api/installer/public/',
+];
+function inferProfile(ctx) {
+    const options = ctx.getGlobalOptions();
+    return options.profile || getActiveProfile();
+}
+export function businessMessage(value) {
+    if (!value || typeof value !== 'object')
+        return '泛微接口返回业务失败';
+    const candidates = [
+        value.msg,
+        value.message,
+        value.resultMsg,
+        value.datajson?.message,
+        value.datajson?.msg,
+        value.data?.message,
+    ];
+    for (const item of candidates) {
+        if (typeof item === 'string' && item.trim())
+            return item;
+    }
+    return '泛微接口返回业务失败';
+}
+export function isDatajsonSuccess(value) {
+    const status = value?.datajson?.status;
+    return status === true || status === 'true';
+}
+export function isWeaverSuccess(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    return Number(value.code) === 200 && value.fail !== true && value.status !== false && value.status !== 'false';
+}
+export function assertDatajsonSuccess(value, operation) {
+    if (!isDatajsonSuccess(value)) {
+        throw projectApiError('business_failed', businessMessage(value), { operation, response: value });
+    }
+}
+export function assertWeaverSuccess(value, operation) {
+    if (!isWeaverSuccess(value)) {
+        throw projectApiError('business_failed', businessMessage(value), { operation, response: value });
+    }
+}
+function assertPath(requestPath) {
+    if (typeof requestPath !== 'string' || !requestPath.startsWith('/') || requestPath.startsWith('//')) {
+        throw projectValidationError('path_invalid', '请求路径必须是相对绝对路径');
+    }
+    if (/^https?:/i.test(requestPath) || /[\r\n]/.test(requestPath) || requestPath.includes('/../')) {
+        throw projectValidationError('path_invalid', '请求路径不允许跨域或路径逃逸');
+    }
+    if (!PROJECT_PATH_PREFIXES.some((prefix) => requestPath.startsWith(prefix))) {
+        throw projectValidationError('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 projectNetworkError(error.subtype, error.message, {
+            retryable: error.retryable,
+            details: error.details,
+        });
+    }
+    throw error;
+}
+export function createProjectHost(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, formData, operation, timeoutMs = 30_000 } = request;
+        assertPath(path);
+        let effectiveBody = body;
+        let effectiveFormData;
+        if (formData) {
+            effectiveFormData = new FormData();
+            for (const [key, value] of Object.entries(formData)) {
+                if (value !== undefined)
+                    effectiveFormData.append(key, String(value));
+            }
+        }
+        let response;
+        try {
+            response = await (await runtime()).requestJson({
+                module: 'project',
+                operation,
+                method: (method || 'POST').toUpperCase(),
+                path,
+                query: omitEmptyQueryValues(query),
+                body: effectiveBody,
+                formData: effectiveFormData,
+                headers: { 'X-Requested-With': 'XMLHttpRequest' },
+                timeoutMs,
+            });
+        }
+        catch (error) {
+            mapRuntimeNetworkError(error);
+        }
+        if (response.status === 401 || response.status === 302) {
+            throw projectAuthError('session_expired', 'E10 登录态已失效，请先完成登录或重新登录', {
+                httpStatus: response.status,
+            });
+        }
+        if (response.parseError) {
+            throw projectNetworkError('protocol', `接口返回不是合法 JSON（HTTP ${response.status}）`, { retryable: false });
+        }
+        if (response.status === 404) {
+            throw new ProjectCliError('api', 'endpoint_not_found', `接口返回 404，当前环境可能未安装事井然项目应用或接口不存在（${path}）`, {
+                code: response.status,
+                details: { path },
+                exitCode: 1,
+            });
+        }
+        if (response.status < 200 || response.status >= 300) {
+            throw new ProjectCliError('api', 'http_error', `泛微接口 HTTP ${response.status}`, {
+                code: response.status,
+                details: { status: response.status, message: businessMessage(response.value) },
+                exitCode: 1,
+            });
+        }
+        return response.value;
+    }
+    return { request, getSession };
+}

package/dist/shortcuts/project/index.js

@@ -0,0 +1,106 @@
+import { readFile } from 'node:fs/promises';
+import { ExitCode, isCliError, toErrorEnvelope } from '../../core/errors.js';
+import { createProjectContinuationSigner } from './continuation.js';
+import { createProjectHost } from './host.js';
+import { projectManifest } from './manifest.js';
+import { executeProjectOperation } from './operations.js';
+import { projectValidationError } 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+/u, '');
+}
+export async function inputFrom(options) {
+    const opts = asOptions(options);
+    let input = {};
+    if (opts.input && opts.inputJson) {
+        throw projectValidationError('input_conflict', '不能同时传 --input 和 --input-json');
+    }
+    if (opts.inputJson) {
+        input = parseJsonInput(String(opts.inputJson), '--input-json');
+    }
+    if (opts.input) {
+        let raw;
+        try {
+            raw = opts.input === '-' ? await readStdin() : await readFile(String(opts.input), 'utf8');
+        }
+        catch {
+            throw projectValidationError('input_unreadable', `无法读取 --input：${String(opts.input)}`);
+        }
+        input = parseJsonInput(raw, '--input');
+    }
+    return input;
+}
+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 projectValidationError('input_invalid', `${label} 不是合法 JSON 对象`);
+    }
+}
+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 executeProjectOperation(operation, input, {
+            host: createProjectHost(ctx),
+            continuation: createProjectContinuationSigner(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 projectShortcut = {
+    name: 'project',
+    description: '泛微E10事井然项目管理 CLI（项目/任务查询与确认写入）',
+    category: 'shortcut',
+    register({ program, action }) {
+        const project = program.command('project').description('泛微E10事井然项目管理（项目/任务查询与确认写入）');
+        project.command('schema')
+            .description('Print project operation manifest for agents')
+            .action(action((ctx) => {
+            ctx.output.write(projectManifest, { json: true });
+        }));
+        project.command('run')
+            .description('Run a project operation with JSON input')
+            .argument('<operation>', 'operation name, e.g. project.task.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));
+        }));
+    },
+};

package/dist/shortcuts/project/manifest.js

@@ -0,0 +1,36 @@
+import { projectOperationDefinitions } from './operations/registry.js';
+function buildOperations() {
+    return projectOperationDefinitions().map((definition) => ({
+        name: definition.name,
+        resource: definition.resource,
+        summary: definition.summary,
+        risk: definition.risk,
+        ...(definition.requiresConfirmation ? { requiresConfirmation: true } : {}),
+        inputSchema: definition.inputSchema,
+    }));
+}
+export const projectManifest = {
+    schemaVersion: 1,
+    name: 'project',
+    title: '泛微E10事井然项目管理',
+    version: '0.1.0',
+    host: 'e10-project',
+    status: 'builtin',
+    sourceSkill: 'weaver-e10-shijingran',
+    capabilities: ['project', 'task'],
+    fixed: {
+        appTag: 'weaver-project-eb',
+        minimumAppVersion: '20.6.11',
+    },
+    operations: buildOperations(),
+    withheldOperations: [
+        {
+            name: 'project.attachment.upload',
+            reason: '源资料仅说明 attachment 字段接受已上传文件 ID，未提供事井然模块自己的上传接口与文件安全确认链。',
+        },
+        {
+            name: 'project.field.auto-resolve',
+            reason: '源资料要求按字段类型组合多个接口解析名称到 ID；当前 CLI 暴露分步解析 operation，由 Agent 按字段类型显式编排，避免替用户猜测关联对象。',
+        },
+    ],
+};