weaver-work-cli 0.1.39 → 0.1.42

package/dist/internal/e10/auth-recovery.js

@@ -1,6 +1,6 @@
 import { isXiaoERuntimeAgent } from '../../core/runtime-agent.js';
 import { getActiveProfile, readProfileConfig } from './auth/session.js';
-import { hasXiaoEEnv, resolveXiaoEPreferredBaseUrl, tryXiaoEUnifiedLogin } from './auth/xiaoe.js';
+import { hasXiaoEEnv, resolveXiaoEPreferredBaseUrl, tryXiaoEUnifiedLogin, } from './auth/xiaoe.js';
 const AUTH_REQUIRED_CODES = new Set(['-2', '401']);
 const AUTH_REQUIRED_MARKERS = [
     '未登录',
@@ -224,6 +224,24 @@ export function canAutomaticallyRecoverXiaoE(ctx, currentSession) {
         || currentSession?.loginSource === 'xiaoe-unified'
         || isXiaoERuntimeAgent(currentSession?.agentType);
 }
+/**
+ * 透明恢复默认必须零输出：中间登录步骤绝不能漏进 Agent 的 stdout 或 JSON。
+ * 只有显式 `--verbose`（且非 `--json`/`--quiet`）时才把每一步的真实失败原因
+ * 经 debug 通道送到 stderr，供人排查。宿主 logger 若没有 debug（测试替身、
+ * 旧嵌入方）则继续完全静默。
+ */
+function recoveryLogger(ctx) {
+    const options = globalOptions(ctx);
+    if (options.json || options.quiet || options.verbose !== true)
+        return undefined;
+    const adapter = ctx.logger;
+    if (!adapter || typeof adapter.debug !== 'function')
+        return undefined;
+    return {
+        info: (message) => adapter.debug(message),
+        warn: (message) => adapter.debug(message),
+    };
+}
 /**
  * Silently recover a stale or missing XiaoE session. Without a local session,
  * current runtime evidence is required before obtaining credentials.
@@ -232,8 +250,20 @@ export function canAutomaticallyRecoverXiaoE(ctx, currentSession) {
  * does not start a burst of login attempts.
  */
 export async function recoverXiaoEAuthSession(ctx, currentSession) {
+    return (await recoverXiaoEAuthSessionWithDiagnostics(ctx, currentSession)).session;
+}
+/**
+ * `recoverXiaoEAuthSession` 的诊断版：失败时返回本次尝试评估过哪些凭证来源、
+ * 最后一条真实原因，供调用方挂到结构化错误上。并发恢复共享同一份诊断
+ * （同一个 in-flight Promise），因此每个等待者看到的原因一致。
+ */
+export async function recoverXiaoEAuthSessionWithDiagnostics(ctx, currentSession) {
+    const emptyOutcome = () => ({
+        session: null,
+        diagnostics: { attemptedSteps: [] },
+    });
     if (!canAutomaticallyRecoverXiaoE(ctx, currentSession))
-        return null;
+        return emptyOutcome();
     const options = globalOptions(ctx);
     const profile = options.profile || getActiveProfile();
     const config = readProfileConfig(profile);
@@ -246,6 +276,7 @@ export async function recoverXiaoEAuthSession(ctx, currentSession) {
     const existing = recoveryInFlight.get(key);
     if (existing)
         return existing;
+    const diagnostics = { attemptedSteps: [] };
     const recovery = (async () => {
         const login = await tryXiaoEUnifiedLogin({
             env: ctx.env,
@@ -255,10 +286,10 @@ export async function recoverXiaoEAuthSession(ctx, currentSession) {
             allowTokenScript: true,
             tenantKeyFallback: currentSession?.tenantKey || config.tenantKey,
             profileHint: profile,
-            // Intentionally no logger: transparent recovery must not leak an
-            // intermediate "login" step into agent stdout/stderr or JSON output.
+            diagnostics,
+            logger: recoveryLogger(ctx),
         });
-        return login?.session || null;
+        return { session: login?.session || null, diagnostics };
     })();
     recoveryInFlight.set(key, recovery);
     try {

package/dist/internal/e10/client.js

@@ -1,4 +1,5 @@
 import { isE10AuthenticationRequired, isE10LoginRedirect, isE10RedirectStatus, sameE10SessionIdentity, } from './auth-recovery.js';
+import { E10_XIAOE_RECOVERY_FAILED_MESSAGE } from './auth/messages.js';
 class E10AuthenticationContextChangedError extends Error {
 }
 export class E10ApiClient {
@@ -62,6 +63,18 @@ export class E10ApiClient {
     async requestRaw(url, init) {
         let lastError = null;
         let authenticationRecoveryAttempted = false;
+        if (this.auth.isExpired?.()) {
+            authenticationRecoveryAttempted = true;
+            const recovered = await this.recoverAuthentication?.(this.auth) || null;
+            if (!recovered || recovered.isExpired?.()) {
+                throw new Error(E10_XIAOE_RECOVERY_FAILED_MESSAGE);
+            }
+            if (!sameE10SessionIdentity(this.auth, recovered)) {
+                throw new E10AuthenticationContextChangedError('XiaoE automatic authentication recovery changed the E10 login context');
+            }
+            this.auth.replaceWith(recovered);
+            refreshAuthenticationHeaders(init, this.auth);
+        }
         for (let attempt = 1; attempt <= this.retries; attempt++) {
             try {
                 const resp = await fetch(url, { ...init, redirect: 'manual' });

package/dist/internal/e10/context.js

@@ -1,25 +1,77 @@
 import { CliError, ExitCode } from '../../core/errors.js';
-import { E10_AUTH_REQUIRED_MESSAGE, E10_XIAOE_RECOVERY_FAILED_MESSAGE } from './auth/messages.js';
+import { E10_AUTH_REQUIRED_MESSAGE, E10_XIAOE_HOST_CREDENTIAL_MISSING_MESSAGE, E10_XIAOE_NETWORK_UNAVAILABLE_MESSAGE, E10_XIAOE_RECOVERY_FAILED_MESSAGE, } from './auth/messages.js';
+import { lastXiaoEFailure, summarizeXiaoEFailureKind, } from './auth/xiaoe.js';
 import { E10AuthSession } from './auth/session.js';
 import { E10ApiClient } from './client.js';
-import { canAutomaticallyRecoverXiaoE, recoverXiaoEAuthSession } from './auth-recovery.js';
+import { canAutomaticallyRecoverXiaoE, recoverXiaoEAuthSession, recoverXiaoEAuthSessionWithDiagnostics, } from './auth-recovery.js';
+/**
+ * 把一次失败的静默恢复转成可定位的结构化错误。文案按归因分流：只有网络层
+ * 完全没打通时才提示「稍后重试」（此时登录态根本没被验证过，让人去重新登录
+ * 是误导）；其余情况沿用原文案。诊断放进 `details`：`attemptedSteps` 说明
+ * 评估过哪些凭证通道及各自结果，`failures` 保留每一次失败的阶段、类别和
+ * `error.cause.code`，`lastError` 是最后一条真实原因（已脱敏截断），
+ * `resultSessionExpired` 表示票其实换到了、但被判为已过期。
+ */
+function xiaoERecoveryFailedError(diagnostics, resultSessionExpired = false) {
+    const failureKind = summarizeXiaoEFailureKind(diagnostics);
+    const lastFailure = lastXiaoEFailure(diagnostics);
+    const networkUnavailable = failureKind === 'network';
+    // Web sandboxes only have the platform credential channel. If the runtime
+    // marker survived but the host credential pair did not, asking the user to
+    // log in again is misleading: the sandbox launcher dropped the injection.
+    const hostCredentialMissing = diagnostics?.clientType === 'cloud'
+        && diagnostics.platformCredentialDetected === false
+        && diagnostics.attemptedSteps.includes('platform_token:missing')
+        && diagnostics.attemptedSteps.includes('environment_map:empty');
+    const details = diagnostics
+        ? {
+            ...(diagnostics.baseUrl ? { baseUrl: diagnostics.baseUrl } : {}),
+            ...(diagnostics.clientType ? { clientType: diagnostics.clientType } : {}),
+            ...(diagnostics.platformCredentialDetected === undefined
+                ? {}
+                : { platformCredentialDetected: diagnostics.platformCredentialDetected }),
+            attemptedSteps: diagnostics.attemptedSteps,
+            ...(diagnostics.lastError ? { lastError: diagnostics.lastError } : {}),
+            ...(failureKind ? { errorKind: failureKind } : {}),
+            ...(lastFailure ? { failureStage: lastFailure.stage } : {}),
+            ...(diagnostics.failures?.length ? { failures: diagnostics.failures } : {}),
+            ...(hostCredentialMissing ? { reason: 'host_credential_not_injected' } : {}),
+            ...(resultSessionExpired ? { resultSessionExpired: true } : {}),
+        }
+        : undefined;
+    return Object.assign(new CliError(networkUnavailable
+        ? E10_XIAOE_NETWORK_UNAVAILABLE_MESSAGE
+        : hostCredentialMissing
+            ? E10_XIAOE_HOST_CREDENTIAL_MISSING_MESSAGE
+            : E10_XIAOE_RECOVERY_FAILED_MESSAGE, ExitCode.AuthError), {
+        type: 'authentication',
+        subtype: networkUnavailable ? 'xiaoe_network_unavailable' : 'xiaoe_credential_unavailable',
+        // 网络错误是可重试的；凭证缺失/被拒重试也一样失败，不能让调用方空转。
+        retryable: networkUnavailable,
+        stage: lastFailure?.stage || 'xiaoe_unified_login',
+        ...(details ? { details } : {}),
+    });
+}
 export async function getE10Session(ctx, load = {}) {
     const options = ctx.getGlobalOptions();
     return E10AuthSession.fromOptions(options, ctx.cwd, load);
 }
 export async function requireE10Session(ctx, load = {}) {
     let session = await getE10Session(ctx, load);
+    if (session?.isExpired() && canAutomaticallyRecoverXiaoE(ctx, session)) {
+        const outcome = await recoverXiaoEAuthSessionWithDiagnostics(ctx, session).catch(() => null);
+        session = outcome?.session || null;
+        if (!session || session.isExpired()) {
+            throw xiaoERecoveryFailedError(outcome?.diagnostics, session?.isExpired() === true);
+        }
+    }
     if (!session && canAutomaticallyRecoverXiaoE(ctx)) {
         // Read-only probes use getE10Session; only a command requiring a session
         // may establish one from the current XiaoE host's credentials.
-        session = await recoverXiaoEAuthSession(ctx).catch(() => null);
+        const outcome = await recoverXiaoEAuthSessionWithDiagnostics(ctx).catch(() => null);
+        session = outcome?.session || null;
         if (!session) {
-            throw Object.assign(new CliError(E10_XIAOE_RECOVERY_FAILED_MESSAGE, ExitCode.AuthError), {
-                type: 'authentication',
-                subtype: 'xiaoe_credential_unavailable',
-                retryable: false,
-                stage: 'xiaoe_unified_login',
-            });
+            throw xiaoERecoveryFailedError(outcome?.diagnostics);
         }
     }
     if (!session) {

package/dist/internal/e10/index.js

@@ -1,4 +1,4 @@
 export { E10ApiClient } from './client.js';
 export { getE10Client, getE10Session, requireE10Client, requireE10Session } from './context.js';
 export { E10ApiError, E10RequestRuntime, createE10RequestRuntime } from './request-runtime.js';
-export { canAutomaticallyRecoverXiaoE, isE10AuthenticationRequired, recoverXiaoEAuthSession, } from './auth-recovery.js';
+export { canAutomaticallyRecoverXiaoE, isE10AuthenticationRequired, recoverXiaoEAuthSession, recoverXiaoEAuthSessionWithDiagnostics, } from './auth-recovery.js';

package/dist/internal/e10/network-error.js

@@ -0,0 +1,93 @@
+/**
+ * 网络错误的统一识别。
+ *
+ * Node/undici 的 `fetch` 只抛 `TypeError: fetch failed`，真实原因（拒绝连接、
+ * DNS 失败、TLS 失败、连接/响应超时）放在 `error.cause.code` 上。丢掉这条 code，
+ * 「连不上 E10」就会被误报成「登录态不可用」，把用户引导去重新登录。
+ */
+/** 明确属于「网络层没打通」的系统错误码（Node 常见 errno + undici 内部码）。 */
+const NETWORK_ERROR_CODES = new Set([
+    'ECONNREFUSED',
+    'ECONNRESET',
+    'ECONNABORTED',
+    'EHOSTUNREACH',
+    'EHOSTDOWN',
+    'ENETUNREACH',
+    'ENETDOWN',
+    'ENETRESET',
+    'ENOTFOUND',
+    'EAI_AGAIN',
+    'EPIPE',
+    'ETIMEDOUT',
+    'ESOCKETTIMEDOUT',
+    'ERR_SOCKET_CONNECTION_TIMEOUT',
+    'UND_ERR_CONNECT_TIMEOUT',
+    'UND_ERR_HEADERS_TIMEOUT',
+    'UND_ERR_BODY_TIMEOUT',
+    'UND_ERR_SOCKET',
+    'UND_ERR_CLOSED',
+    'UND_ERR_ABORTED',
+    'CERT_HAS_EXPIRED',
+    'DEPTH_ZERO_SELF_SIGNED_CERT',
+    'SELF_SIGNED_CERT_IN_CHAIN',
+    'UNABLE_TO_VERIFY_LEAF_SIGNATURE',
+    'ERR_TLS_CERT_ALTNAME_INVALID',
+    'ERR_SSL_WRONG_VERSION_NUMBER',
+]);
+/** `AbortController.abort()` 抛出的 DOMException 没有 errno，统一用这个码表示「超时」。 */
+export const ABORT_ERROR_CODE = 'ABORT_ERR';
+function asRecord(value) {
+    return value && typeof value === 'object' ? value : null;
+}
+/**
+ * 取错误链上最内层的系统错误码（`error.cause.code`）；`AbortError` 归一化成
+ * `ABORT_ERR`。用 `seen` 防环：Node 的 cause 链偶尔会指回上层。
+ */
+export function readErrorCauseCode(error, maxDepth = 5) {
+    let current = error;
+    const seen = new Set();
+    for (let depth = 0; depth < maxDepth; depth += 1) {
+        if (current === undefined || current === null || seen.has(current))
+            return undefined;
+        seen.add(current);
+        if (current instanceof Error && current.name === 'AbortError')
+            return ABORT_ERROR_CODE;
+        const record = asRecord(current);
+        if (!record)
+            return undefined;
+        if (record.name === 'AbortError')
+            return ABORT_ERROR_CODE;
+        const code = record.code;
+        if (typeof code === 'string' && code)
+            return code;
+        const errno = record.errno;
+        if (typeof errno === 'string' && errno)
+            return errno;
+        if (typeof errno === 'number')
+            return String(errno);
+        current = record.cause;
+    }
+    return undefined;
+}
+export function isAbortError(error) {
+    if (error instanceof Error && error.name === 'AbortError')
+        return true;
+    return asRecord(error)?.name === 'AbortError';
+}
+export function isNetworkErrorCode(code) {
+    return typeof code === 'string' && NETWORK_ERROR_CODES.has(code.toUpperCase());
+}
+/** undici 把底层原因藏起来时只剩这句话，但语义已经很明确了。 */
+const TRANSPORT_MESSAGE_PATTERN = /fetch failed|socket hang up|other side closed|network|connection (?:refused|reset|closed)|timed? ?out|timeout|certificate|getaddrinfo|dns lookup/i;
+export function looksLikeTransportMessage(message) {
+    return TRANSPORT_MESSAGE_PATTERN.test(message);
+}
+/**
+ * 给一次 fetch（含读响应体）套上超时。调用方必须在 `finally` 里 `clear()`，
+ * 否则进程会被这一个定时器拖住。
+ */
+export function createTimeoutSignal(timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    return { signal: controller.signal, clear: () => clearTimeout(timer) };
+}

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

@@ -1,6 +1,8 @@
 import { CliError, ExitCode } from '../../core/errors.js';
 import { classifyE10Redirect, isE10AuthenticationRequired, recoverXiaoEAuthSession, sameE10SessionIdentity, } from './auth-recovery.js';
 import { startFetchTiming } from './fetch-timing.js';
+import { readErrorCauseCode } from './network-error.js';
+import { E10_XIAOE_RECOVERY_FAILED_MESSAGE } from './auth/messages.js';
 const DEFAULT_TIMEOUT_MS = 30_000;
 const DEFAULT_BIG_INT_STRINGS = true;
 /** 下载直传最多跟几跳：E10 -> 对象存储通常 1 跳，留一点余量但不允许成环。 */
@@ -53,6 +55,12 @@ export class E10RequestRuntime {
         return this.request({ ...request, responseType: 'binary' });
     }
     async request(request) {
+        if (this.session.isExpired?.()) {
+            const recovered = await this.recoverExpiredSession(this.session.eteamsId);
+            if (!recovered || this.session.isExpired?.()) {
+                throw new E10ApiError('authentication', 'session_expired', E10_XIAOE_RECOVERY_FAILED_MESSAGE, { exitCode: ExitCode.AuthError, retryable: false });
+            }
+        }
         const mutable = this.prepareRequest(request);
         try {
             await this.runBeforeRequest(mutable, this.sessionContext());
@@ -171,6 +179,8 @@ export class E10RequestRuntime {
         }
         if (!recovered)
             return false;
+        if (recovered.isExpired?.())
+            return false;
         if (!sameE10SessionIdentity(this.session, recovered)) {
             throw new E10ApiError('authentication', 'session_context_changed', 'XiaoE 自动恢复后的登录身份或 E10 环境发生变化，本次请求未重试', { exitCode: ExitCode.AuthError, retryable: false });
         }
@@ -305,12 +315,17 @@ export class E10RequestRuntime {
                 throw new E10ApiError('network', 'timeout', `请求超时（${timeoutMs}ms）`, {
                     retryable: false,
                     exitCode: ExitCode.NetworkError,
+                    details: { timeoutMs },
                 });
             }
             const message = error instanceof Error ? error.message : String(error);
+            // Node 的 `fetch failed` 不带原因，真正的 errno（ECONNREFUSED/ENOTFOUND…）
+            // 在 `error.cause.code` 上：保留下来才能区分「断网」与「服务端报错」。
+            const causeCode = readErrorCauseCode(error);
             throw new E10ApiError('network', 'transport', `请求失败：${message}`, {
                 retryable: true,
                 exitCode: ExitCode.NetworkError,
+                ...(causeCode ? { details: { causeCode } } : {}),
             });
         }
         finally {

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

@@ -184,6 +184,36 @@ function firstId(value) {
         return String(value);
     return undefined;
 }
+/**
+ * 取「日程」应用 appId 与日程表单 formId（用于详情卡片页链接）。
+ * 偶发空返回时 getObjsByTag 原样重试最多 3 次。任一获取失败返回 null。
+ * 创建日程后需用 formId 拼卡片页链接，故抽为可复用函数。
+ */
+export async function fetchAgendaAppAndForm(host) {
+    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);
+    let formId;
+    if (appId) {
+        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));
+            }
+        }
+    }
+    return { appId: appId ?? null, formId: formId ?? null };
+}
 const calendarAppCheck = {
     name: 'calendar.app.check',
     resource: 'calendar',
@@ -194,14 +224,7 @@ const calendarAppCheck = {
     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);
+        const { appId, formId } = await fetchAgendaAppAndForm(host);
         if (!appId) {
             return calendarSuccess('calendar.app.check', {
                 installed: false,
@@ -217,20 +240,6 @@ const calendarAppCheck = {
             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;

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

@@ -2,6 +2,7 @@ import { createHash } from 'node:crypto';
 import { calendarConfirmationError, calendarPartialError, calendarValidationError, CalendarCliError } from '../errors.js';
 import { calendarSuccess, schemaOf, SCHEMA_ID, SCHEMA_DATETIME_MINUTE, SCHEMA_SWITCH, SCHEMA_DATE } from './types.js';
 import { assertDateTimeMinute, defaultEndTime, optionId, participantIds, pickDefined, } from './shared.js';
+import { fetchAgendaAppAndForm } from './read.js';
 const CONTINUATION_TTL_SECONDS = 600;
 // 日程 mainTable 可选业务字段（创建/更新共用）
 const OPTIONAL_FIELDS = [
@@ -81,6 +82,37 @@ async function verifyLease(args, action, env) {
 function isNetworkError(error) {
     return error instanceof CalendarCliError && error.type === 'network';
 }
+/**
+ * 从 saveFormData/createAgenda 返回体提取新建日程 ID。
+ * 兼容两种后端形态：
+ * - 顶层 `datajson.dataIds`（字符串数组）
+ * - `datajson.datas[].mainTable.dataIds` / `datajson.datas[].mainTable.id`
+ */
+function extractCreatedIds(response) {
+    const datajson = response?.datajson;
+    if (!datajson || typeof datajson !== 'object')
+        return [];
+    if (Array.isArray(datajson.dataIds)) {
+        return datajson.dataIds.map((v) => String(v)).filter(Boolean);
+    }
+    const datas = Array.isArray(datajson.datas) ? datajson.datas : [];
+    const ids = [];
+    for (const d of datas) {
+        const mt = d?.mainTable;
+        if (!mt)
+            continue;
+        if (Array.isArray(mt.dataIds))
+            ids.push(...mt.dataIds.map((v) => String(v)));
+        else if (mt.id !== undefined && mt.id !== null && mt.id !== '')
+            ids.push(String(mt.id));
+    }
+    return ids;
+}
+/** 拼日程详情卡片页链接（baseUrl 可能带协议头，统一归一成 https://host/...）。 */
+function buildCardUrl(baseUrl, formId, id) {
+    const hostPart = String(baseUrl || '').replace(/^https?:\/\//i, '').replace(/\/+$/, '');
+    return `https://${hostPart}/sp/ebdfpage/card/0/${formId}/${id}`;
+}
 /** 构造写入接口 datajson 请求体（datas[].mainTable 结构）。 */
 async function buildWriteDatajson(host, mainTableList) {
     const session = await host.getSession();
@@ -195,9 +227,21 @@ const calendarCreateApply = {
             }
             throw error;
         }
+        const createdIds = extractCreatedIds(response);
+        const createdId = createdIds[0];
+        const session = await env.host.getSession();
+        let accessUrl = null;
+        if (createdId) {
+            const { formId } = await fetchAgendaAppAndForm(env.host);
+            if (formId) {
+                accessUrl = buildCardUrl(session.baseUrl, formId, createdId);
+            }
+        }
         return calendarSuccess('calendar.create.apply', {
             status: 'COMPLETE',
-            result: response,
+            createdId: createdId ?? null,
+            createdIds,
+            accessUrl,
         });
     },
 };

package/dist/shortcuts/cowork/operations/discuss-write.js

@@ -1,6 +1,6 @@
 import { CoworkCliError, coworkNotFoundError, coworkPartialError, coworkValidationError } from '../errors.js';
 import { READ_BEFORE_WRITE, WRITE, SCHEMA_ID, coworkSuccess, schemaOf, } from './types.js';
-import { assertEnum, assertString, compact, normalizeList, requireConfirm, toBase64Html, toId, toPositiveInt, unwrapData, verifyLease, } from './shared.js';
+import { assertEnum, assertString, compact, coworkViewUrl, normalizeList, requireConfirm, toBase64Html, toId, toPositiveInt, unwrapData, verifyLease, } from './shared.js';
 function isNetworkError(error) {
     return error instanceof CoworkCliError && error.type === 'network';
 }
@@ -132,6 +132,8 @@ const discussPublishApply = {
             coworkId,
             sectionId,
             status: data.status ?? root?.status ?? null,
+            viewUrl: coworkViewUrl(lease.baseUrl, coworkId),
+            mobileViewUrl: coworkViewUrl(lease.baseUrl, coworkId, true),
         });
     },
 };
@@ -266,6 +268,8 @@ const discussActionApply = {
             coworkId,
             discussId,
             result: unwrapData(response) ?? null,
+            viewUrl: coworkViewUrl(lease.baseUrl, coworkId),
+            mobileViewUrl: coworkViewUrl(lease.baseUrl, coworkId, true),
         });
     },
 };

package/dist/shortcuts/cowork/operations/item-write.js

@@ -1,6 +1,6 @@
 import { CoworkCliError, coworkNotFoundError, coworkPartialError, coworkValidationError } from '../errors.js';
 import { READ_BEFORE_WRITE, WRITE, SCHEMA_ID, SCHEMA_DATETIME, coworkSuccess, schemaOf, } from './types.js';
-import { assertEnum, assertString, requireConfirm, toBase64Html, toId, unwrapData, verifyLease, } from './shared.js';
+import { assertEnum, assertString, coworkViewUrl, requireConfirm, toBase64Html, toId, unwrapData, verifyLease, } from './shared.js';
 function isNetworkError(error) {
     return error instanceof CoworkCliError && error.type === 'network';
 }
@@ -203,6 +203,8 @@ const itemCreateApply = {
             sectionId,
             principal,
             endTime,
+            viewUrl: coworkViewUrl(lease.baseUrl, data.id),
+            mobileViewUrl: coworkViewUrl(lease.baseUrl, data.id, true),
         });
     },
 };
@@ -295,7 +297,7 @@ const itemActionApply = {
             }
             throw error;
         }
-        return coworkSuccess('cowork.item.action.apply', { action, id, result: unwrapData(response) ?? null });
+        return coworkSuccess('cowork.item.action.apply', { action, id, result: unwrapData(response) ?? null, viewUrl: coworkViewUrl(lease.baseUrl, id) });
     },
 };
 const ITEM_FLAGS = ['hide', 'vote'];
@@ -367,7 +369,7 @@ const itemFlagApply = {
             form,
             operation: 'cowork.item.flag.apply',
         });
-        return coworkSuccess('cowork.item.flag.apply', { action, id, result: unwrapData(response) ?? null });
+        return coworkSuccess('cowork.item.flag.apply', { action, id, result: unwrapData(response) ?? null, viewUrl: coworkViewUrl(lease.baseUrl, id) });
     },
 };
 export const coworkItemWriteOperations = [

package/dist/shortcuts/cowork/operations/member-write.js

@@ -1,6 +1,6 @@
 import { CoworkCliError, coworkNotFoundError, coworkPartialError, coworkValidationError } from '../errors.js';
 import { READ_BEFORE_WRITE, WRITE, SCHEMA_ID, coworkSuccess, schemaOf, } from './types.js';
-import { assertEnum, compact, normalizeList, requireConfirm, toId, toIdList, toPositiveInt, unwrapData, verifyLease, } from './shared.js';
+import { assertEnum, compact, coworkViewUrl, normalizeList, requireConfirm, toId, toIdList, toPositiveInt, unwrapData, verifyLease, } from './shared.js';
 function isNetworkError(error) {
     return error instanceof CoworkCliError && error.type === 'network';
 }
@@ -153,6 +153,8 @@ const memberActionApply = {
             coworkId,
             userIds: action === 'join' ? undefined : String(form.ids).split(','),
             result: unwrapData(response) ?? null,
+            viewUrl: coworkViewUrl(lease.baseUrl, coworkId),
+            mobileViewUrl: coworkViewUrl(lease.baseUrl, coworkId, true),
         });
     },
 };

package/dist/shortcuts/cowork/operations/permission-write.js

@@ -1,6 +1,6 @@
 import { CoworkCliError, coworkNotFoundError, coworkPartialError, coworkValidationError } from '../errors.js';
 import { READ_BEFORE_WRITE, WRITE, SCHEMA_ID, coworkSuccess, schemaOf, } from './types.js';
-import { normalizeList, requireConfirm, toId, unwrapData, verifyLease, } from './shared.js';
+import { coworkViewUrl, normalizeList, requireConfirm, toId, unwrapData, verifyLease, } from './shared.js';
 function isNetworkError(error) {
     return error instanceof CoworkCliError && error.type === 'network';
 }
@@ -163,6 +163,8 @@ const permAddApply = {
             userId,
             userName,
             result: unwrapData(response) ?? null,
+            viewUrl: coworkViewUrl(lease.baseUrl, coworkId),
+            mobileViewUrl: coworkViewUrl(lease.baseUrl, coworkId, true),
         });
     },
 };
@@ -275,6 +277,8 @@ const permRemoveApply = {
             removed: stillThere === false ? true : undefined,
             verified: stillThere !== null,
             result: unwrapData(response) ?? null,
+            viewUrl: coworkViewUrl(lease.baseUrl, coworkId),
+            mobileViewUrl: coworkViewUrl(lease.baseUrl, coworkId, true),
         });
     },
 };

package/dist/shortcuts/cowork/operations/shared.js

@@ -88,6 +88,13 @@ export function unwrapData(response) {
         return response;
     return response.data;
 }
+/** 协作查看页地址：PC `/sp/cowork/view/{id}`、移动端 `/mobile/cowork/view/{id}`（真实环境取证形态，禁止改拼）。 */
+export function coworkViewUrl(baseUrl, id, mobile = false) {
+    if (!id)
+        return null;
+    const base = String(baseUrl || '').replace(/\/+$/, '');
+    return `${base}/${mobile ? 'mobile' : 'sp'}/cowork/view/${id}`;
+}
 /** 协作列表的 data 形如 { pageSize, total, current, pageUid, columns[], data[] }。 */
 export function normalizePaged(response) {
     const data = unwrapData(response);

package/dist/shortcuts/ehr/operations/attend-write.js

@@ -1,7 +1,7 @@
 import { createHash } from 'node:crypto';
 import { ehrConfirmationError, ehrPartialError, ehrValidationError, EhrCliError } from '../errors.js';
 import { READ, SCHEMA_DATE, SCHEMA_ID, ehrSuccess, schemaOf, WRITE, } from './types.js';
-import { assertEnum, assertEnumArray, compact, pickDefined, toIdList } from './shared.js';
+import { assertEnum, assertEnumArray, compact, pickDefined, toIdList, EHR_PAGES, ehrPageUrl, addDays } from './shared.js';
 const CONTINUATION_TTL_SECONDS = 600;
 const CARD_TYPES = ['CHECKIN', 'CHECKOUT', 'LEAVE', 'RETURN', 'CHECKIN_AND_RETURN', 'CHECKOUT_AND_LEAVE'];
 const APPEAL_TYPES = [
@@ -316,9 +316,51 @@ const ehrAttendAppealSaveApply = {
             }
             throw error;
         }
+        // 回执（按 references/attend-appeal-save.md 契约，2026-11-04）：
+        // ① 回查申诉列表定位本次新建记录（日期前后各放宽 1 天，防跨天/时区边界漏查）；
+        // ② 返回 appealListUrl（考勤异常/申诉页面，已取证路由）。
+        // 回查失败不阻塞提交结果（提交已成功），以 locateWarning 如实提示。
+        const session = await env.host.getSession();
+        const appealListUrl = ehrPageUrl(session.baseUrl, EHR_PAGES.attendAbnormal);
+        let appeal = null;
+        let locateWarning;
+        try {
+            const listResp = await env.host.request({
+                method: 'POST',
+                path: '/api/attend/web/appeal/getAppealList',
+                body: {
+                    beginDate: addDays(String(args.attendDay), -1),
+                    endDate: addDays(String(args.attendDay), 1),
+                    current: 1,
+                    pageSize: 50,
+                },
+            });
+            const payload = listResp?.data;
+            const rows = Array.isArray(payload?.data) ? payload.data
+                : Array.isArray(payload?.rows) ? payload.rows
+                    : Array.isArray(payload) ? payload
+                        : [];
+            const day = String(args.attendDay);
+            const desc = String(args.appealDesc ?? '');
+            const pick = rows.find((r) => String(r?.attendDay ?? r?.attend_date ?? r?.attendDate ?? '').startsWith(day))
+                || (desc ? rows.find((r) => String(r?.appealDesc ?? r?.appeal_desc ?? '').includes(desc)) : null)
+                || null;
+            if (pick)
+                appeal = pick;
+            else
+                locateWarning = '未在申诉列表中定位到本次记录（可能刚提交尚在同步），请稍后用 ehr.attend.appeal.list 复核';
+        }
+        catch (e) {
+            locateWarning = '申诉列表回查失败：' + (e?.message || '未知原因') + '；请稍后用 ehr.attend.appeal.list 复核';
+        }
         return ehrSuccess('ehr.attend.appeal.save.apply', {
             status: 'COMPLETE',
             result: response?.data,
+            /** 定位到的新建申诉记录（含申诉 ID 等，处理申诉时用其 id） */
+            appeal,
+            /** 考勤异常/申诉页面地址（已取证路由，禁止改拼） */
+            appealListUrl,
+            ...(locateWarning ? { locateWarning } : {}),
             verifyHint: '可通过 ehr.attend.appeal.list 回查申诉是否已生成',
         });
     },