@xmanrui/dsh-im 4.11.0 → 4.13.0

package/src/channels/weixin/state-store.mjs

@@ -1,3 +1,5 @@
+import { deferredStateAccess, normalizeDeferredState } from '../shared/deferred-state.mjs';
+import { createHash } from 'node:crypto';
 import { mkdir, readFile, rename, unlink, writeFile } from 'node:fs/promises';
 import { dirname } from 'node:path';
 
@@ -15,6 +17,7 @@ export const WEIXIN_RECENT_OUTBOUND_LIMIT = 200;
 export const WEIXIN_RECENT_OUTBOUND_TTL_MS = 30 * 24 * 60 * 60 * 1_000;
 export const WEIXIN_RECENT_OUTBOUND_TEXT_LIMIT = 8_000;
 export const WEIXIN_RECENT_OUTBOUND_MATCH_TOLERANCE_MS = 15_000;
+const CONTEXT_TOKEN_LIMIT = 1_000;
 
 function nonEmptyString(value) {
   return typeof value === 'string' && value.trim() ? value.trim() : null;
@@ -25,6 +28,26 @@ function timestamp(value) {
   return Number.isFinite(number) && number >= 0 ? Math.trunc(number) : null;
 }
 
+function sequence(value) {
+  const text = typeof value === 'string' ? value : Number.isSafeInteger(value) ? String(value) : '';
+  return /^\d+$/.test(text) ? BigInt(text).toString() : null;
+}
+
+function normalizeContextTokens(value) {
+  if (!value || typeof value !== 'object' || !/^[a-f0-9]{64}$/.test(value.credentialHash ?? '')) return undefined;
+  const users = Object.create(null);
+  for (const [userId, entry] of Object.entries(value.users ?? {}).slice(-CONTEXT_TOKEN_LIMIT)) {
+    if (!nonEmptyString(userId) || !nonEmptyString(entry?.token)) continue;
+    users[userId] = {
+      token: entry.token,
+      seq: sequence(entry.seq),
+      messageTimeMs: timestamp(entry.messageTimeMs),
+      receivedAt: timestamp(entry.receivedAt),
+    };
+  }
+  return { credentialHash: value.credentialHash, users };
+}
+
 function providerMessageIds(value) {
   if (!Array.isArray(value)) return [];
   return [...new Set(value
@@ -72,14 +95,17 @@ function normalizeState(value) {
       }
     }
   }
+  const contextTokens = normalizeContextTokens(value.contextTokens);
   return {
     version: 1,
     sessions,
+    ...(value.deferred ? { deferred: normalizeDeferredState(value.deferred) } : {}),
     seenMessageIds: Array.isArray(value.seenMessageIds)
       ? value.seenMessageIds.filter((id) => typeof id === 'string').slice(-1_000)
       : [],
     getUpdatesBuf: typeof value.getUpdatesBuf === 'string' ? value.getUpdatesBuf : '',
     recentOutboundMessages: recentOutboundMessages(value.recentOutboundMessages),
+    ...(contextTokens ? { contextTokens } : {}),
   };
 }
 
@@ -87,6 +113,7 @@ export class WeixinStateStore {
   #path;
   #state = structuredClone(EMPTY_STATE);
   #writeQueue = Promise.resolve();
+  #deferred = deferredStateAccess(() => this.#state, () => this.#persist());
 
   constructor(path) {
     this.#path = path;
@@ -103,6 +130,41 @@ export class WeixinStateStore {
     return this;
   }
 
+  deferredEntries() { return this.#deferred.entries(); }
+  putDeferred(entry) { return this.#deferred.put(entry); }
+  patchDeferred(id, patch) { return this.#deferred.patch(id, patch); }
+  removeDeferred(id) { return this.#deferred.remove(id); }
+
+  // Context belongs to this bot login, not to a Harness session or workspace.
+  async bindContextTokens(token) {
+    const credentialHash = createHash('sha256').update(token).digest('hex');
+    if (this.#state.contextTokens?.credentialHash === credentialHash) return;
+    this.#state.contextTokens = { credentialHash, users: Object.create(null) };
+    await this.#persist();
+  }
+
+  contextTokenFor(userId) {
+    return this.#state.contextTokens?.users?.[userId]?.token ?? undefined;
+  }
+
+  async rememberContextToken({ userId, contextToken, seq, messageTimeMs }) {
+    if (!nonEmptyString(userId) || !nonEmptyString(contextToken) || !this.#state.contextTokens) return;
+    const users = this.#state.contextTokens.users;
+    const previous = users[userId];
+    const next = { token: contextToken, seq: sequence(seq), messageTimeMs: timestamp(messageTimeMs), receivedAt: Date.now() };
+    // Late/duplicate batches must not replace a newer conversation capability.
+    if (previous) {
+      if (previous.seq !== null && next.seq !== null && BigInt(next.seq) <= BigInt(previous.seq)) return;
+      if (previous.messageTimeMs !== null && next.messageTimeMs !== null
+        && next.messageTimeMs < previous.messageTimeMs) return;
+    }
+    delete users[userId];
+    users[userId] = next;
+    const keys = Object.keys(users);
+    if (keys.length > CONTEXT_TOKEN_LIMIT) delete users[keys[0]];
+    await this.#persist();
+  }
+
   sessionFor(key) {
     return this.#state.sessions[key] ?? null;
   }
@@ -201,7 +263,8 @@ export class WeixinStateStore {
   }
 
   snapshot() {
-    return structuredClone(this.#state);
+    const { contextTokens, ...state } = this.#state;
+    return structuredClone(state);
   }
 
   async remove() {

package/src/channels/weixin/weixin-bridge.mjs

@@ -1,3 +1,4 @@
+import { createDeferredDeliveryCoordinator, deferredOutcomeText } from '../shared/deferred-delivery-coordinator.mjs';
 import {
   DEFAULT_WEIXIN_MAX_MESSAGE_CHARS,
   extractWeixinFiles,
@@ -163,7 +164,7 @@ function createWeixinSendDiagnostic({
   ].join(' ');
 }
 
-function weixinSendError(error, details) {
+export function weixinSendError(error, details) {
   const diagnostic = createWeixinSendDiagnostic({ ...details, error });
   const wrapped = new Error(`Weixin text delivery failed (${diagnostic})`, { cause: error });
   const code = safeDiagnosticToken(error?.code);
@@ -176,7 +177,7 @@ function weixinSendError(error, details) {
   return wrapped;
 }
 
-function weixinSendFailureOptions(error) {
+export function weixinSendFailureOptions(error, { proactive = false } = {}) {
   let current = error;
   for (let depth = 0; current && depth < 5; depth += 1) {
     const diagnostic = current[WEIXIN_SEND_DIAGNOSTIC];
@@ -184,7 +185,12 @@ function weixinSendFailureOptions(error) {
       return {
         reason: 'weixin-send-failed',
         userMessage: [
-          t('回复已经生成，但微信发送失败，可能只收到部分内容。请将下面的诊断信息完整反馈给管理员。'),
+          proactive
+            ? t('微信主动消息发送失败。长轮询在线不代表消息可以发送。')
+            : t('回复已经生成，但微信发送失败，可能只收到部分内容。请将下面的诊断信息完整反馈给管理员。'),
+          ...(String(current.providerCode) === '-2' ? [
+            t('iLink 拒绝发送，可能涉及会话有效期、发送额度或消息内容。可让接收者发一条消息后重试；不要通过反复发送心跳尝试续期。'),
+          ] : []),
           t('微信发送诊断：{diagnostic}', { diagnostic }),
         ].join('\n'),
       };
@@ -289,6 +295,7 @@ export class WeixinHarnessBridge {
   #ownerUserId;
   #harness;
   #state;
+  #deferred;
   #contextEnhancement;
   #accessPolicy;
   #status;
@@ -351,6 +358,9 @@ export class WeixinHarnessBridge {
     this.#maxMessageChars = maxMessageChars;
     this.#typingKeepaliveMs = typingKeepaliveMs;
     this.#signal = signal;
+    this.#deferred = createDeferredDeliveryCoordinator({ harness, state, signal, logger,
+      deliver: (entry, outcome) => this.#deliverDeferredOutcome(entry, outcome),
+    });
     this.#approvals = new HarnessApprovalQueue({ label: 'weixin', logger });
   }
 
@@ -390,6 +400,12 @@ export class WeixinHarnessBridge {
     }
     const key = conversationKey(sender);
     const contextToken = nonEmptyString(message?.context_token) ?? undefined;
+    void this.#state.rememberContextToken?.({
+      userId: sender,
+      contextToken,
+      seq: message.seq,
+      messageTimeMs: message.create_time_ms ?? weixinMessageTimestampMs(messageId),
+    }).catch((error) => this.#logger.warn?.('[dsh-weixin] failed to persist conversation context:', error));
     const runId = nonEmptyString(message?.run_id) ?? undefined;
     const pending = this.#pendingInteractions.get(key);
     const batchCommand = isBatchInputCommand(commandText);
@@ -642,6 +658,11 @@ export class WeixinHarnessBridge {
     return task;
   }
 
+  async #deliverDeferredOutcome(entry, outcome) {
+    await this.#send(entry.target.toUserId, deferredOutcomeText(outcome), undefined, undefined, { stopTyping: false });
+    return true;
+  }
+
   async waitForIdle() {
     await Promise.allSettled([
       ...this.#queues.values(),
@@ -652,9 +673,11 @@ export class WeixinHarnessBridge {
       ...this.#commandTasks,
       this.#typingTail,
     ]);
+    await this.#deferred.whenIdle();
   }
 
   async close() {
+    this.#deferred.close();
     this.#typingClosed = true;
     await this.#stopTyping({ signal: AbortSignal.timeout(5_000) });
   }
@@ -682,6 +705,7 @@ export class WeixinHarnessBridge {
       pendingInteraction: this.#pendingInteractions.has(key)
         || this.#approvals.hasPending(key),
       control: { owner: this, key },
+      deferredDelivery: this.#deferred,
     });
     if (result?.stopped) {
       await Promise.allSettled([
@@ -794,6 +818,7 @@ export class WeixinHarnessBridge {
         await this.#state.markSeen(messageId);
         promptRecorded = true;
         ({ answer, artifacts = [] } = await askInWorkspaceSession({
+          deferredDelivery: () => ({ coordinator: this.#deferred, target: { toUserId: sender } }),
           harness: this.#harness,
           state: this.#state,
           key,
@@ -1225,8 +1250,9 @@ export class WeixinHarnessBridge {
     ).catch(() => undefined);
   }
 
-  async #send(toUserId, text, contextToken, runId) {
-    await this.#stopTyping();
+  async #send(toUserId, text, contextToken, runId, { stopTyping = true } = {}) {
+    if (stopTyping) await this.#stopTyping();
+    contextToken ??= this.#state.contextTokenFor?.(toUserId);
     const providerMessageIds = [];
     const chunks = splitWeixinText(text, this.#maxMessageChars);
     for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex += 1) {

package/src/channels/weixin/weixin-runtime.mjs

@@ -1,6 +1,11 @@
 import { DEFAULT_WEIXIN_MAX_MESSAGE_CHARS, WeixinApiError } from './weixin-api.mjs';
-import { createWeixinBridgeStatus, WeixinHarnessBridge } from './weixin-bridge.mjs';
+import {
+  createWeixinBridgeStatus, WeixinHarnessBridge, weixinSendError, weixinSendFailureOptions,
+} from './weixin-bridge.mjs';
 import { providerMessageIdsFor } from '../shared/semantic/delivery.mjs';
+import {
+  channelDeliveryFailure, clearLastMessageFailure, setLastMessageFailure,
+} from '../shared/message-failure.mjs';
 import {
   connectionTestTarget,
   connectionTestTargetUnavailable,
@@ -175,6 +180,7 @@ export class WeixinRuntime {
         throw harnessHealthError(error);
       }
       this.#status.harnessReachable = true;
+      await this.#state.bindContextTokens?.(this.#token);
       await this.#notifyStart();
       this.#abortController = new AbortController();
       const signal = this.#abortController.signal;
@@ -335,13 +341,32 @@ export class WeixinRuntime {
 
   async #sendTrackedText({ toUserId, text, signal }) {
     const sentAt = Date.now();
-    const result = await this.#api.sendText({
-      baseUrl: this.#config.baseUrl,
-      token: this.#token,
-      toUserId,
-      text,
-      signal,
-    });
+    const contextToken = this.#state.contextTokenFor?.(toUserId);
+    let result;
+    try {
+      result = await this.#api.sendText({
+        baseUrl: this.#config.baseUrl,
+        token: this.#token,
+        toUserId,
+        text,
+        contextToken,
+        signal,
+      });
+    } catch (cause) {
+      if (signal?.aborted) throw cause;
+      const error = weixinSendError(cause, {
+        baseUrl: this.#config.baseUrl, text, chunk: text, chunkIndex: 0, chunkCount: 1,
+        maxMessageChars: this.#maxMessageChars, contextToken,
+      });
+      const failure = setLastMessageFailure(this.#status,
+        channelDeliveryFailure(error, { uncertain: cause?.code !== 'send-rejected' }),
+        weixinSendFailureOptions(error, { proactive: true }));
+      this.#logger.warn?.(`[dsh-weixin] outbound delivery failed [${failure.referenceId}]: ${failure.message}`);
+      throw error;
+    }
+    if (this.#status.lastMessageError?.reason === 'WEIXIN_SEND_FAILED') {
+      clearLastMessageFailure(this.#status);
+    }
     try {
       await this.#state.rememberOutboundMessage?.({
         toUserId,

package/src/channels/whatsapp/whatsapp-runtime.mjs

@@ -7,7 +7,7 @@ import {
   normalizeMessageContent,
 } from '@whiskeysockets/baileys';
 
-import { splitMessageText } from '../shared/editable-message-stream.mjs';
+import { createEditableMessageStream, splitMessageText } from '../shared/editable-message-stream.mjs';
 import { t } from '../shared/i18n.mjs';
 import { ImagePromptError } from '../shared/image-prompt.mjs';
 import { trackOutboundArtifactProviderPromise } from '../shared/semantic/artifact.mjs';
@@ -21,6 +21,7 @@ const IMAGE_MEDIA_TYPES = new Set(['image/jpeg', 'image/png', 'image/webp', 'ima
 const DEFAULT_MAX_IMAGE_BYTES = 5 * 1024 * 1024;
 const IMAGE_DOWNLOAD_TIMEOUT_MS = 15_000;
 const WHATSAPP_MEDIA_UPLOAD_TIMEOUT_MS = 120_000;
+const WHATSAPP_TEXT_LIMIT = 4_000;
 const MESSAGE_WRAPPER_KEYS = [
   'ephemeralMessage',
   'viewOnceMessage',
@@ -441,49 +442,97 @@ export class WhatsappBotClient {
   #socket;
   #outboundIds;
   #signal;
+  #abortController = new AbortController();
   #mediaUploadTimeoutMs;
+  #logger;
   #typingTimers = new Map();
+  #streams = new Set();
 
   constructor(socket, outboundIds, {
     signal,
     mediaUploadTimeoutMs = WHATSAPP_MEDIA_UPLOAD_TIMEOUT_MS,
+    logger = console,
   } = {}) {
     this.#socket = socket;
     this.#outboundIds = outboundIds;
-    this.#signal = signal;
+    this.#signal = signal
+      ? AbortSignal.any([signal, this.#abortController.signal])
+      : this.#abortController.signal;
     this.#mediaUploadTimeoutMs = mediaUploadTimeoutMs;
+    this.#logger = logger;
   }
 
   async sendText(target, text) {
     await this.#stopTyping(target.jid);
     const providerMessageIds = [];
-    for (const [index, chunk] of splitMessageText(text, 4_000).entries()) {
-      const messageId = randomBytes(10).toString('hex').toUpperCase();
-      const options = {
-        ...(index === 0 && target.quoted ? { quoted: target.quoted } : {}),
-        messageId,
-      };
-      // Linked-account group messages are valid inbound prompts in open mode.
-      // Reserve our own id before dispatch so an early local echo cannot loop
-      // back through the bridge as another owner-authored group prompt.
-      if (typeof this.#outboundIds.reserve === 'function') {
-        this.#outboundIds.reserve(messageId);
-      } else {
-        this.#outboundIds.remember(messageId);
-      }
-      const result = await this.#socket.sendMessage(
-        target.jid,
-        { text: chunk },
-        options,
-      );
-      this.#outboundIds.remember(result?.key?.id);
-      if (typeof result?.key?.id === 'string' && result.key.id) {
-        providerMessageIds.push(result.key.id);
-      }
+    for (const [index, chunk] of splitMessageText(text, WHATSAPP_TEXT_LIMIT).entries()) {
+      const result = await this.#sendTextMessage(target, chunk, { quote: index === 0 });
+      providerMessageIds.push(result.key.id);
     }
     return { providerMessageIds };
   }
 
+  async #sendTextMessage(target, text, { edit, quote = true } = {}) {
+    this.#signal?.throwIfAborted();
+    const messageId = randomBytes(10).toString('hex').toUpperCase();
+    // Reserve both the outgoing envelope and the edited message before dispatch:
+    // linked-account group and self-chat echoes can arrive before send settles.
+    const reserve = (id) => {
+      if (typeof this.#outboundIds.reserve === 'function') this.#outboundIds.reserve(id);
+      else this.#outboundIds.remember(id);
+    };
+    reserve(messageId);
+    if (edit) reserve(edit.id);
+    const pending = this.#socket.sendMessage(
+      target.jid,
+      { text, ...(edit ? { edit } : {}) },
+      { ...(quote && !edit && target.quoted ? { quoted: target.quoted } : {}), messageId },
+    );
+    const result = await waitWithSignal(pending, this.#signal);
+    this.#outboundIds.remember(result?.key?.id);
+    return {
+      ...result,
+      key: { remoteJid: target.jid, fromMe: true, id: messageId, ...result?.key },
+    };
+  }
+
+  async openStream(target) {
+    let messageKey;
+    const stream = createEditableMessageStream({
+      limit: WHATSAPP_TEXT_LIMIT,
+      updateIntervalMs: 1_000,
+      create: async (text) => {
+        const message = await this.#sendTextMessage(target, text);
+        messageKey = message.key;
+        return messageKey.id;
+      },
+      // Baileys edits need the original full message key, not an edit envelope id.
+      edit: async (_messageId, text) => this.#sendTextMessage(target, text, { edit: messageKey }),
+      sendRemainder: (text) => this.#sendTextMessage(target, text, { quote: false }),
+      messageIdForResult: (message) => message?.key?.id,
+      logger: this.#logger,
+    });
+    const finish = stream.finish.bind(stream);
+    const cancel = stream.cancel.bind(stream);
+    stream.finish = async (text) => {
+      try {
+        return await finish(text);
+      } finally {
+        this.#streams.delete(stream);
+        await this.#stopTyping(target.jid);
+      }
+    };
+    stream.cancel = () => {
+      cancel();
+      this.#streams.delete(stream);
+      return this.#stopTyping(target.jid);
+    };
+    await stream.start();
+    this.#signal.throwIfAborted();
+    this.#streams.add(stream);
+    return stream;
+  }
+
   async sendFile(target, file) {
     return this.#sendArtifact(target, file, {
       document: file.bytes,
@@ -593,8 +642,10 @@ export class WhatsappBotClient {
   }
 
   async close() {
+    this.#abortController.abort();
+    const stoppingStreams = [...this.#streams].map((stream) => stream.cancel());
     const jids = [...this.#typingTimers.keys()];
-    await Promise.allSettled(jids.map((jid) => this.#stopTyping(jid)));
+    await Promise.allSettled([...stoppingStreams, ...jids.map((jid) => this.#stopTyping(jid))]);
   }
 
   async #stopTyping(jid, sendPaused = true) {
@@ -741,6 +792,7 @@ export class WhatsappRuntime {
       const client = new WhatsappBotClient(session.socket, outboundIds, {
         signal: controller.signal,
         mediaUploadTimeoutMs: this.#mediaUploadTimeoutMs,
+        logger: this.#logger,
       });
       this.#client = client;
       this.#bridge = new WhatsappHarnessBridge({