weaver-work-cli 0.1.24 → 0.1.26

package/dist/internal/e10/auth/xiaoe.js

@@ -4,6 +4,7 @@ import { homedir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { CliError, ExitCode } from '../../../core/errors.js';
+import { isXiaoERuntime, isXiaoERuntimeAgent } from '../../../core/runtime-agent.js';
 import { buildE10CookieHeader, E10AuthSession, extractRawSetCookie, extractSessionTicket, profileNameFromUrl, readTeamsCheckUserInfo, saveAuthFile, saveProfileConfig, setActiveProfile, } from './session.js';
 export const DEFAULT_E10_BASE_URL = 'https://www.e-cology.com.cn';
 export const XIAOE_AGENT_TYPE = 'XiaoE';
@@ -47,6 +48,11 @@ const XIAOE_TOKEN_SCRIPT_LEGACY_ENV_KEY = 'XIAOE_TOKEN_SCRIPT_PATH';
 const XIAOE_TOKEN_SCRIPT_PYTHON_LEGACY_ENV_KEY = 'XIAOE_TOKEN_SCRIPT_PYTHON';
 const XIAOE_TOKEN_SCRIPT_TIMEOUT_MS = 15_000;
 const XIAOE_CLIENT_TOKEN_TIMEOUT_MS = 15_000;
+const XIAOE_USER_SETTINGS_PATH_ENV_KEY = 'XIAOE_USER_SETTINGS_PATH';
+const XIAOE_CLIENT_SETTINGS_ROOT_ENV_KEYS = [
+    'XIAOE_ROBOT_DATA_ROOT',
+    'XIAOE_ROBOT_ROOT',
+];
 export const XIAOE_SKILL_ETEAMID_API_PATH = '/spec-apps/api/app/rpachat/skill/extend/eteamId';
 export const XIAOE_CLIENT_SETTINGS_SOURCE = 'XiaoE/Robots/user_settings.json';
 export const XIAOE_USER_TOKEN_SOURCE = 'XIAOE_USER_TOKEN';
@@ -59,22 +65,29 @@ function envString(env, ...keys) {
     }
     return '';
 }
-export function hasXiaoEEnv(env = process.env) {
-    // Current-host markers win over WEAVER_AGENT_TYPE, which can be inherited
-    // from a previously saved E10 profile by `weaver-work-cli run`.
+/**
+ * Identifies the XiaoE runtime without inspecting credential artifacts:
+ * desktop callers may pass --runtime-agent, and any injected XIAOE_* variable
+ * is treated as XiaoE host evidence.
+ */
+export function hasXiaoEEnv(env = process.env, options = {}) {
+    if (isXiaoERuntime(options))
+        return true;
+    // XiaoE reserves this prefix for host-injected runtime variables. Presence
+    // of any matching key is sufficient; the value may legitimately be empty.
+    if (Object.keys(env).some((key) => key.startsWith('XIAOE_')))
+        return true;
+    // An explicitly named host remains authoritative over credential signals.
+    const explicitHostAgentType = envString(env, 'WORKBUDDY_AGENT_TYPE', 'CODEX_AGENT_TYPE');
+    if (explicitHostAgentType)
+        return isXiaoERuntimeAgent(explicitHostAgentType);
+    // Generic framework markers can coexist with stale profile metadata, so they
+    // take precedence over WEAVER_AGENT_TYPE when no XIAOE_* variable is present.
     if (Object.keys(env).some((key) => key.startsWith('WORKBUDDY_') || key.startsWith('CODEX_'))) {
         return false;
     }
-    const explicitAgentType = envString(env, 'WORKBUDDY_AGENT_TYPE', 'CODEX_AGENT_TYPE', 'WEAVER_AGENT_TYPE');
-    if (explicitAgentType) {
-        const normalized = explicitAgentType.toLowerCase().replace(/[^a-z0-9\p{Script=Han}]+/gu, '');
-        return ['xiaoe', 'xiaoeclient', '小e', '智能小e'].includes(normalized);
-    }
-    // XiaoE injects this pair into the command process for the current run. A
-    // tokens.py path, client installation, XIAOE_SKILL_* variable, or
-    // WEAVER_XIAOE_* configuration alone is credential availability, not proof
-    // that the current agent is XiaoE.
-    return hasXiaoEPlatformCredential(env);
+    const explicitAgentType = envString(env, 'WEAVER_AGENT_TYPE');
+    return explicitAgentType ? isXiaoERuntimeAgent(explicitAgentType) : false;
 }
 export function describeXiaoECredentialSource(source) {
     // Step 1 is the platform-injected credential (XIAOE_USER_TOKEN + XIAOE_DOMAIN):
@@ -286,7 +299,7 @@ export function resolveXiaoEDefaultBaseUrl(env = process.env) {
     const configured = resolveXiaoEConfiguredBaseUrl(env);
     if (configured)
         return configured;
-    return hasXiaoEEnv(env) ? DEFAULT_E10_BASE_URL : '';
+    return DEFAULT_E10_BASE_URL;
 }
 function uniqueStrings(values) {
     const seen = new Set();
@@ -325,10 +338,12 @@ export function xiaoEBundledEnvScriptPath() {
     const scriptPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../../../scripts/xiaoe_env.py');
     return existsSync(scriptPath) ? scriptPath : '';
 }
-export function hasXiaoETokenScript(env = process.env) {
+export function hasXiaoETokenScript(env = process.env, allowLocalDiscovery = true) {
     const explicit = envString(env, XIAOE_TOKEN_SCRIPT_ENV_KEY, XIAOE_TOKEN_SCRIPT_LEGACY_ENV_KEY);
     if (explicit)
         return existsSync(explicit);
+    if (!allowLocalDiscovery)
+        return false;
     const scriptPath = xiaoETokenScriptPath(env);
     return Boolean(scriptPath && existsSync(scriptPath));
 }
@@ -537,30 +552,80 @@ export function xiaoEClientRobotsRoot(env = process.env) {
     const home = envString(env, 'HOME') || homedir();
     return home ? join(home, 'Library', 'Application Support', 'XiaoE', 'Robots') : '';
 }
-export function findXiaoEClientSettingsFile(env = process.env) {
-    const root = xiaoEClientRobotsRoot(env);
-    if (!root || !existsSync(root))
-        return '';
-    let entries = [];
+function isFile(path) {
+    if (!path || !existsSync(path))
+        return false;
     try {
-        entries = readdirSync(root);
+        return statSync(path).isFile();
     }
     catch {
-        return '';
+        return false;
+    }
+}
+function isDirectory(path) {
+    if (!path || !existsSync(path))
+        return false;
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
     }
-    const files = entries
-        .map((name) => join(root, name, 'user_settings.json'))
-        .filter((path) => {
+}
+function listXiaoEClientSettingsFiles(root) {
+    if (!root)
+        return [];
+    if (isFile(root))
+        return [root];
+    if (!isDirectory(root))
+        return [];
+    const candidates = [];
+    const addCandidate = (path) => {
+        if (isFile(path))
+            candidates.push(path);
+    };
+    const addChildSettings = (directory) => {
+        if (!isDirectory(directory))
+            return;
         try {
-            return statSync(path).isFile();
+            for (const entry of readdirSync(directory, { withFileTypes: true })) {
+                if (entry.isDirectory())
+                    addCandidate(join(directory, entry.name, 'user_settings.json'));
+            }
         }
         catch {
-            return false;
+            // Treat an unreadable host directory as an unavailable credential source.
         }
-    });
-    if (files.length === 0)
-        return '';
-    return files.sort((left, right) => statSync(right).mtimeMs - statSync(left).mtimeMs)[0];
+    };
+    addCandidate(join(root, 'user_settings.json'));
+    addChildSettings(root);
+    // Some desktop hosts inject the XiaoE data root rather than the Robots
+    // directory itself. Keep discovery shallow and limited to the known layout.
+    const robotsRoot = join(root, 'Robots');
+    addCandidate(join(robotsRoot, 'user_settings.json'));
+    addChildSettings(robotsRoot);
+    return uniqueStrings(candidates);
+}
+function sortedXiaoEClientSettingsFiles(root) {
+    const files = listXiaoEClientSettingsFiles(root);
+    return files.sort((left, right) => statSync(right).mtimeMs - statSync(left).mtimeMs);
+}
+function xiaoEClientSettingsCandidateFiles(env, allowLocalDiscovery = true) {
+    const candidates = [];
+    const explicitSettingsPath = envString(env, XIAOE_USER_SETTINGS_PATH_ENV_KEY);
+    if (isFile(explicitSettingsPath))
+        candidates.push(explicitSettingsPath);
+    for (const key of XIAOE_CLIENT_SETTINGS_ROOT_ENV_KEYS) {
+        const injectedRoot = envString(env, key);
+        candidates.push(...sortedXiaoEClientSettingsFiles(injectedRoot));
+    }
+    if (allowLocalDiscovery) {
+        candidates.push(...sortedXiaoEClientSettingsFiles(xiaoEClientRobotsRoot(env)));
+    }
+    return uniqueStrings(candidates);
+}
+export function findXiaoEClientSettingsFile(env = process.env) {
+    return xiaoEClientSettingsCandidateFiles(env)[0] || '';
 }
 /**
  * Platform-injected credential: XIAOE_USER_TOKEN (+ the XiaoE service address).
@@ -587,23 +652,52 @@ export function hasXiaoEPlatformCredential(env = process.env) {
  * Kept for local desktop hosts only; sandboxes must rely on the platform credential.
  */
 export function readXiaoEClientCredential(env = process.env) {
-    const settingsFile = findXiaoEClientSettingsFile(env);
-    if (!settingsFile)
-        return null;
-    try {
-        const parsed = JSON.parse(readFileSync(settingsFile, 'utf8'));
-        const authToken = readString(parsed, 'session_id', 'sessionId');
-        const erpaUrl = normalizeUrl(readString(parsed, 'erpa', 'erpa_url', 'erpaUrl'));
-        if (!authToken || !erpaUrl)
-            return null;
-        return { authToken, erpaUrl, source: XIAOE_CLIENT_SETTINGS_SOURCE };
-    }
-    catch {
-        return null;
+    for (const settingsFile of xiaoEClientSettingsCandidateFiles(env)) {
+        try {
+            const parsed = JSON.parse(readFileSync(settingsFile, 'utf8'));
+            const authToken = readString(parsed, 'session_id', 'sessionId');
+            const erpaUrl = normalizeUrl(readString(parsed, 'erpa', 'erpa_url', 'erpaUrl'));
+            if (authToken && erpaUrl)
+                return { authToken, erpaUrl, source: XIAOE_CLIENT_SETTINGS_SOURCE };
+        }
+        catch {
+            // Continue to the next injected or default client settings candidate.
+        }
     }
+    return null;
+}
+export function hasXiaoEClientCredential(env = process.env, allowLocalDiscovery = true) {
+    return Boolean(xiaoEClientSettingsCandidateFiles(env, allowLocalDiscovery)[0]);
+}
+/**
+ * Reports usable unified-login credential sources independently from host
+ * identity. Installing the XiaoE client is not proof that the current process
+ * was launched by XiaoE, but an explicit `auth xiaoe` command may still consume
+ * any credential source that is available.
+ */
+export function inspectXiaoEUnifiedLoginSources(options = {}) {
+    const env = options.env || process.env;
+    const baseUrl = resolveXiaoEPreferredBaseUrl({
+        explicitBaseUrl: options.baseUrl,
+        profileBaseUrl: options.profileBaseUrl,
+        env,
+    });
+    const platformCredential = hasXiaoEPlatformCredential(env);
+    const allowLocalDiscovery = options.allowLocalDiscovery !== false;
+    const tokenScript = options.allowTokenScript !== false
+        && hasXiaoETokenScript(env, allowLocalDiscovery);
+    const clientCredential = hasXiaoEClientCredential(env, allowLocalDiscovery);
+    const environmentCredential = Boolean(baseUrl && resolveXiaoEUnifiedLoginCredential(baseUrl, env));
+    return {
+        platformCredential,
+        tokenScript,
+        clientCredential,
+        environmentCredential,
+        any: platformCredential || tokenScript || clientCredential || environmentCredential,
+    };
 }
-export function hasXiaoEClientCredential(env = process.env) {
-    return Boolean(findXiaoEClientSettingsFile(env));
+export function hasXiaoEUnifiedLoginSource(options = {}) {
+    return inspectXiaoEUnifiedLoginSources(options).any;
 }
 async function fetchXiaoEClientEteamId(credential, domain) {
     const controller = new AbortController();
@@ -697,22 +791,19 @@ export function resolveXiaoEPreferredBaseUrl(options) {
     const profileBaseUrl = normalizeUrl(options.profileBaseUrl || '');
     if (profileBaseUrl)
         return profileBaseUrl;
-    return hasXiaoEEnv(env) ? DEFAULT_E10_BASE_URL : '';
-}
-export function shouldUseXiaoEBrowserFallback(platform = process.platform) {
-    return platform === 'darwin' || platform === 'win32';
+    return DEFAULT_E10_BASE_URL;
 }
 export function createXiaoEUnifiedLoginUnavailableError(baseUrl = '') {
     const target = normalizeUrl(baseUrl);
     const message = [
         'XiaoE unified login did not return a usable E10 session.',
         target ? `Resolved E10 baseUrl: ${target}.` : 'No E10 baseUrl could be resolved.',
-        'This web/Linux host cannot complete a localhost browser OAuth callback.',
+        'The auth xiaoe command never falls back to browser OAuth.',
         'Refresh the XiaoE web session or restore host credential injection before retrying.',
     ].join(' ');
     return Object.assign(new CliError(message, ExitCode.AuthError), {
         type: 'authentication',
-        subtype: 'xiaoe_web_credential_unavailable',
+        subtype: 'xiaoe_credential_unavailable',
         retryable: false,
         stage: 'xiaoe_unified_login',
     });
@@ -793,7 +884,7 @@ export async function tryXiaoEUnifiedLogin(options = {}) {
         profileBaseUrl: options.profileBaseUrl,
         env,
     });
-    const mayUseTokenScript = options.allowTokenScript || hasXiaoEEnv(env);
+    const mayUseTokenScript = options.allowTokenScript === true;
     if (!baseUrl && !mayUseTokenScript)
         return null;
     let credential = null;
@@ -859,6 +950,7 @@ export async function tryXiaoEUnifiedLogin(options = {}) {
         // client session and exchanges it for an eteamId, so Python availability
         // no longer blocks unified login.
         if (!credential && hasXiaoEClientCredential(env)) {
+            options.logger?.info('Trying built-in XiaoE client session credential...');
             try {
                 credential = await resolveXiaoEClientCredential(baseUrl || DEFAULT_E10_BASE_URL, env);
             }

package/dist/internal/e10/context.js

@@ -1,41 +1,19 @@
 import { CliError, ExitCode } from '../../core/errors.js';
-import { E10AuthSession, getActiveProfile, readProfileConfig } from './auth/session.js';
-import { createXiaoEUnifiedLoginUnavailableError, hasXiaoEEnv, resolveXiaoEPreferredBaseUrl, shouldUseXiaoEBrowserFallback, tryXiaoEUnifiedLogin, } from './auth/xiaoe.js';
+import { E10AuthSession } from './auth/session.js';
+import { hasXiaoEEnv } from './auth/xiaoe.js';
 import { E10ApiClient } from './client.js';
-function shouldPreferXiaoEUnifiedLogin(options, env) {
-    return !options.auth && !options.profile && hasXiaoEEnv(env);
-}
 export async function getE10Session(ctx, load = {}) {
     const options = ctx.getGlobalOptions();
-    if (shouldPreferXiaoEUnifiedLogin(options, ctx.env)) {
-        const profileBaseUrl = readProfileConfig(getActiveProfile()).baseUrl;
-        const xiaoELogin = await tryXiaoEUnifiedLogin({
-            env: ctx.env,
-            baseUrl: options.baseUrl,
-            profileBaseUrl,
-            allowBundledEnvScript: true,
-            allowTokenScript: true,
-            logger: ctx.logger,
-        });
-        if (xiaoELogin)
-            return xiaoELogin.session;
-        return null;
-    }
     return E10AuthSession.fromOptions(options, ctx.cwd, load);
 }
 export async function requireE10Session(ctx, load = {}) {
     const session = await getE10Session(ctx, load);
     if (!session) {
         const options = ctx.getGlobalOptions();
-        if (hasXiaoEEnv(ctx.env) && !shouldUseXiaoEBrowserFallback()) {
-            const baseUrl = resolveXiaoEPreferredBaseUrl({
-                explicitBaseUrl: options.baseUrl,
-                profileBaseUrl: readProfileConfig(getActiveProfile()).baseUrl,
-                env: ctx.env,
-            });
-            throw createXiaoEUnifiedLoginUnavailableError(baseUrl);
+        if (hasXiaoEEnv(ctx.env, options)) {
+            throw new CliError('E10 auth not found. The current runtime is XiaoE; run weaver-work-cli auth xiaoe first.', ExitCode.AuthError);
         }
-        throw new CliError('E10 auth not found. In XiaoE, run weaver-work-cli auth xiaoe first; if unified login is unavailable, ask the user for the E10 login domain (base URL), then run: weaver-work-cli auth login --base-url <url> --agent_type <agent_type>.', ExitCode.AuthError);
+        throw new CliError('E10 auth not found. Ask the user for the E10 login domain (base URL), then run: weaver-work-cli auth login --base-url <url> --agent_type <agent_type>.', ExitCode.AuthError);
     }
     return session;
 }

package/dist/shortcuts/archive-oa/constants.js

@@ -0,0 +1,66 @@
+/**
+ * archive-oa 固定业务参数。
+ *
+ * 泛微商务合同与契约锁协作采纳是两套独立的应用/列表，参数值不同，禁止交叉混用。
+ * 来源：`source/weaver-e10-archive-oa.zip` 内 10 篇接口文档（catalog.md 登记）。
+ */
+/** 加入借阅车 / 发起借阅的单次条数上限（接口侧限制）。 */
+export const MAX_BORROW_ITEMS = 6;
+/** 发起借阅流程创建页的流程 ID（前端 `flowpage/fullCreate/<flowId>`）。 */
+export const BORROW_FLOW_ID = '100003460000002090';
+/** 借阅车记录 `fb` 即界面「分部」列：0 = 泛微、1 = 契约锁。 */
+export const FLOW_FB_LABELS = {
+    '0': '泛微',
+    '1': '契约锁',
+};
+/** 档案系统：按合同号定位档案的自定义接口标识。 */
+export const ARCHIVE_LOCATE_INTERFACE_PK = 'getArcIdByContractNo';
+export const ARCHIVE_LOCATE_PATH = `/api/ebuilder/form/formdata/v2/getFormDataList/${ARCHIVE_LOCATE_INTERFACE_PK}`;
+/** 泛微商务合同（案例台账）。 */
+export const WEAVER_CONTRACT = {
+    source: 'weaver',
+    passId: '850741972510941185',
+    listId: '850741985437786120',
+    filterListId: '850741985437786120',
+    cusMenuId: '5408862605522555751',
+    urlPageTitle: '5rOb5b6u5qGI5L6L',
+};
+export const WEAVER_BORROW_CAR = {
+    source: 'weaver',
+    passId: '882393476189437952',
+    listId: '882393480417296390',
+    cusMenuId: '5408862605522555751',
+    urlPageTitle: '5rOb5b6u5qGI5L6L',
+};
+export const WEAVER_ESB_ADD = {
+    source: 'weaver',
+    esbActionIds: '882395911377174530',
+    objId: '850741972510941185',
+    listId: '850741985437786120',
+    successText: '【加入借阅车】执行成功！',
+};
+/** 契约锁协作采纳（用户常称「案例」）。 */
+export const QYS_CONTRACT = {
+    source: 'qys',
+    passId: '850742853046345728',
+    listId: '1190611964371984450',
+    cusMenuId: '5408862605522555752',
+    urlPageTitle: '5aWR57qm6ZSB5qGI5L6L',
+};
+export const QYS_BORROW_CAR = {
+    source: 'qys',
+    passId: '882393476189437952',
+    listId: '883819516961857839',
+    cusMenuId: '5408862605522555752',
+    urlPageTitle: '5aWR57qm6ZSB5qGI5L6L',
+};
+export const QYS_ESB_ADD = {
+    source: 'qys',
+    esbActionIds: '892706856573648911',
+    objId: '850742853046345728',
+    listId: '1190611964371984450',
+    successText: '【契约锁加入借阅车】执行成功！',
+};
+/** 契约锁默认过滤「处理进度 = 已归档」。 */
+export const QYS_DEFAULT_ARCHIVED_FIELD = 'cljd';
+export const QYS_DEFAULT_ARCHIVED_VALUE = '已归档';

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

package/dist/shortcuts/archive-oa/errors.js

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