@seamnet/client 0.13.0 → 0.13.2

package/lib/plugins/im/index.cjs

@@ -136,17 +136,41 @@ function createImPlugin() {
 
   // ===== Supervisor 状态（SDK 僵尸时自动重建 chat 实例）=====
   let credentialsRef = null;
-  let rebuildInProgress = false;
-  let lastRebuildAt = 0;
+  // 状态机：scheduled（待启动）/ rebuilding（进行中）；期间又来信号标记 requestedAgain
+  let rebuildScheduled = false;
+  let rebuilding = false;
+  let rebuildRequestedAgain = false;
+  let lastRebuildSuccessAt = 0;
+  let chatGeneration = 0;  // chat 实例代数，每次 create 递增；listener 校验代数，老代事件忽略
   let keepaliveTimer = null;
   let processRejectionHandler = null;
+  // 重建失败后自驱重试：指数退避 + jitter；成功后重置
+  let rebuildRetryAttempt = 0;
+  let rebuildRetryTimer = null;
   const REBUILD_COOLDOWN_MS = 10_000;
   const REBUILD_DEBOUNCE_MS = 3_000;
+  const REBUILD_WATCHDOG_MS = 30_000;      // 整个重建最多 30s，超时强制失败
+  const SDK_CALL_TIMEOUT_MS = 10_000;      // 单个 SDK 调用超时
+  const LOGOUT_TIMEOUT_MS = 5_000;
+  const LOGIN_TIMEOUT_MS = 15_000;
+  const SDK_READY_TIMEOUT_MS = 10_000;     // 等 SDK_READY 最长 10s，超时 reject
   const KEEPALIVE_INTERVAL_MS = 3 * 60 * 1000;
   const KEEPALIVE_TIMEOUT_MS = 10_000;
+  // 重建失败退避表（最后一档持续）
+  const REBUILD_RETRY_BACKOFF_MS = [3_000, 10_000, 30_000, 60_000];
   // SDK 错误 code 需要触发 rebuild（2801=PING 超时，WebSocket 应用层僵尸）
   const SDK_REBUILD_ERROR_CODES = new Set([2801]);
 
+  function withTimeout(promise, ms, name) {
+    let tid = null;
+    const timeoutP = new Promise((_, reject) => {
+      tid = setTimeout(() => reject(new Error(`${name} timeout ${ms}ms`)), ms);
+    });
+    return Promise.race([promise, timeoutP]).finally(() => {
+      if (tid) clearTimeout(tid);
+    });
+  }
+
   async function prefetchDisplayName(userId) {
     if (!chat || !userId || displayNameCache.has(userId)) return;
     displayNameCache.set(userId, null);
@@ -339,50 +363,62 @@ function createImPlugin() {
     return { ok: true };
   }
 
-  // ===== 事件 handler（独立函数，便于 rebuild 时重新注册）=====
+  // ===== 事件 handler 工厂（每次 attachListenersTo 时绑定当前 generation）=====
+  // handler 校验 generation，老实例晚到的事件直接忽略，避免污染新状态
 
-  function onSdkReady() {
-    sdkReady = true;
-    log.info('sdk_ready', { userId: myUserId });
-  }
-
-  function onSdkNotReady() {
-    sdkReady = false;
-    log.warn('sdk_not_ready');
-  }
-
-  function onSdkError(event) {
-    const err = event?.data || event;
-    const code = err?.code;
-    log.warn('sdk_error', {
-      code,
-      message: err?.message || String(err).slice(0, 200),
-    });
-    if (SDK_REBUILD_ERROR_CODES.has(code)) {
-      scheduleRebuild(`sdk_error:${code}`);
-    }
-  }
-
-  function onKickedOut(event) {
-    log.warn('sdk_kicked_out', {
-      type: event?.data?.type,
-      message: event?.data?.message,
-    });
-    sdkReady = false;
-    scheduleRebuild('kicked_out');
-  }
-
-  function onNetStateChange(event) {
-    log.info('sdk_net_state', { state: event?.data?.state });
-  }
-
-  function onFriendListUpdated() {
-    refreshContactsFromFriendList().catch((err) => {
-      log.warn('refresh_contacts_on_update_failed', { message: err.message });
-    });
+  function makeHandlers(gen) {
+    return {
+      onSdkReady: () => {
+        if (gen !== chatGeneration) return;
+        // sdkReady 的置 true 统一在 rebuildChat/init 成功 swap 后做，handler 只记录
+        log.info('sdk_ready', { userId: myUserId, gen });
+      },
+      onSdkNotReady: () => {
+        if (gen !== chatGeneration) return;
+        sdkReady = false;
+        log.warn('sdk_not_ready', { gen });
+      },
+      onSdkError: (event) => {
+        if (gen !== chatGeneration) return;
+        const err = event?.data || event;
+        const code = err?.code;
+        log.warn('sdk_error', {
+          code,
+          message: err?.message || String(err).slice(0, 200),
+          gen,
+        });
+        if (SDK_REBUILD_ERROR_CODES.has(code)) {
+          scheduleRebuild(`sdk_error:${code}`);
+        }
+      },
+      onKickedOut: (event) => {
+        if (gen !== chatGeneration) return;
+        log.warn('sdk_kicked_out', {
+          type: event?.data?.type,
+          message: event?.data?.message,
+          gen,
+        });
+        sdkReady = false;
+        scheduleRebuild('kicked_out');
+      },
+      onNetStateChange: (event) => {
+        if (gen !== chatGeneration) return;
+        log.info('sdk_net_state', { state: event?.data?.state, gen });
+      },
+      onFriendListUpdated: () => {
+        if (gen !== chatGeneration) return;
+        refreshContactsFromFriendList().catch((err) => {
+          log.warn('refresh_contacts_on_update_failed', { message: err.message });
+        });
+      },
+      onMessageReceived: (event) => {
+        if (gen !== chatGeneration) return;
+        handleMessageEvent(event);
+      },
+    };
   }
 
-  function onMessageReceived(event) {
+  function handleMessageEvent(event) {
     for (const msg of event.data) {
       if (msg.from === myUserId) continue;
 
@@ -499,88 +535,166 @@ function createImPlugin() {
     }
   }
 
-  function setupAllListeners() {
-    chat.on(TencentCloudChat.EVENT.SDK_READY, onSdkReady);
-    chat.on(TencentCloudChat.EVENT.SDK_NOT_READY, onSdkNotReady);
-    chat.on(TencentCloudChat.EVENT.ERROR, onSdkError);
-    chat.on(TencentCloudChat.EVENT.KICKED_OUT, onKickedOut);
-    chat.on(TencentCloudChat.EVENT.NET_STATE_CHANGE, onNetStateChange);
-    chat.on(TencentCloudChat.EVENT.MESSAGE_RECEIVED, onMessageReceived);
+  function attachListenersTo(chatInstance, gen) {
+    const h = makeHandlers(gen);
+    chatInstance.on(TencentCloudChat.EVENT.SDK_READY, h.onSdkReady);
+    chatInstance.on(TencentCloudChat.EVENT.SDK_NOT_READY, h.onSdkNotReady);
+    chatInstance.on(TencentCloudChat.EVENT.ERROR, h.onSdkError);
+    chatInstance.on(TencentCloudChat.EVENT.KICKED_OUT, h.onKickedOut);
+    chatInstance.on(TencentCloudChat.EVENT.NET_STATE_CHANGE, h.onNetStateChange);
+    chatInstance.on(TencentCloudChat.EVENT.MESSAGE_RECEIVED, h.onMessageReceived);
     try {
-      chat.on(TencentCloudChat.EVENT.FRIEND_LIST_UPDATED, onFriendListUpdated);
+      chatInstance.on(TencentCloudChat.EVENT.FRIEND_LIST_UPDATED, h.onFriendListUpdated);
     } catch (err) {
       log.warn('friend_list_listener_register_failed', { message: err.message });
     }
   }
 
-  // ===== 重建 chat 实例（SDK 僵尸时用）=====
+  function waitForSdkReadyStrict(chatInstance, ms) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(
+        () => reject(new Error(`SDK_READY timeout ${ms}ms`)),
+        ms
+      );
+      chatInstance.on(TencentCloudChat.EVENT.SDK_READY, () => {
+        clearTimeout(timer);
+        resolve();
+      });
+    });
+  }
 
-  async function createAndLoginChat() {
+  // ===== 候选模式构建新 chat（失败则隔离销毁，不污染 active chat）=====
+  async function buildChatCandidate() {
+    const myGen = ++chatGeneration;
+    // 清 globals，让 setupSdkGlobals 重新铺 window 等
     delete global.window;
-    chat = TencentCloudChat.create({ SDKAppID: Number(credentialsRef.sdkAppId) });
+    global._imSdkGlobalsSet = false;
+    const nextChat = TencentCloudChat.create({ SDKAppID: Number(credentialsRef.sdkAppId) });
     setupSdkGlobals();
     try {
       const TIMUploadPlugin = require('tim-upload-plugin');
-      chat.registerPlugin({ 'tim-upload-plugin': TIMUploadPlugin });
+      nextChat.registerPlugin({ 'tim-upload-plugin': TIMUploadPlugin });
     } catch {}
-    chat.setLogLevel(4);
-    setupAllListeners();
-    await chat.login({
-      userID: myUserId,
-      userSig: credentialsRef.userSig,
-    });
-    // 等 SDK_READY（最多 10s）
-    await new Promise((resolve) => {
-      if (sdkReady) return resolve();
-      const timer = setTimeout(() => resolve(), 10000);
-      const once = () => { clearTimeout(timer); resolve(); };
-      chat.on(TencentCloudChat.EVENT.SDK_READY, once);
-    });
+    nextChat.setLogLevel(4);
+    attachListenersTo(nextChat, myGen);
+    try {
+      await withTimeout(
+        nextChat.login({ userID: myUserId, userSig: credentialsRef.userSig }),
+        LOGIN_TIMEOUT_MS,
+        'chat.login'
+      );
+      // 严格等 SDK_READY：超时 reject，不再假成功
+      await waitForSdkReadyStrict(nextChat, SDK_READY_TIMEOUT_MS);
+    } catch (err) {
+      // 失败的 candidate 必须隔离销毁，避免 late event 污染新状态
+      try {
+        await withTimeout(
+          (nextChat.logout && nextChat.logout().catch(() => {})) || Promise.resolve(),
+          LOGOUT_TIMEOUT_MS,
+          'cand_logout'
+        );
+      } catch {}
+      try { nextChat.destroy && nextChat.destroy(); } catch {}
+      throw err;
+    }
+    return { nextChat, gen: myGen };
   }
 
+  // ===== 重建 chat 实例（SDK 僵尸时用）=====
   async function rebuildChat(reason) {
-    log.warn('chat_rebuild_start', { reason });
+    log.warn('chat_rebuild_start', { reason, prevGen: chatGeneration });
     sdkReady = false;
-    try { await chat.logout(); } catch {}
-    try { chat.destroy && chat.destroy(); } catch {}
+    const oldChat = chat;
+
+    // 候选模式：先把新 chat 完整拉起来（login + SDK_READY），失败则 throw，老 chat 保持不变
+    const { nextChat, gen: newGen } = await buildChatCandidate();
+
+    // 成功：swap 到新 chat；sdkReady 只在 swap 完成后置 true
+    chat = nextChat;
+    sdkReady = true;
+    log.info('chat_rebuild_done', { reason, newGen });
+
+    // 老 chat 后台销毁，不阻塞新 chat 服务
+    (async () => {
+      try {
+        if (oldChat && oldChat.logout) {
+          await withTimeout(oldChat.logout().catch(() => {}), LOGOUT_TIMEOUT_MS, 'old_logout');
+        }
+      } catch (e) {
+        log.warn('old_logout_timeout', { message: e.message });
+      }
+      try { oldChat && oldChat.destroy && oldChat.destroy(); } catch {}
+    })();
+
     try {
-      await createAndLoginChat();
-      try { await refreshContactsFromFriendList(); } catch {}
-      log.info('chat_rebuild_done', { reason });
+      await withTimeout(refreshContactsFromFriendList(), SDK_CALL_TIMEOUT_MS, 'refresh_contacts');
     } catch (e) {
-      log.error('chat_rebuild_failed', e, { reason });
+      log.warn('refresh_contacts_after_rebuild_timeout', { message: e.message });
+    }
+  }
+
+  function scheduleRebuildRetry(reason, delayMs) {
+    if (rebuildRetryTimer) clearTimeout(rebuildRetryTimer);
+    rebuildRetryTimer = setTimeout(() => {
+      rebuildRetryTimer = null;
+      scheduleRebuild(reason);
+    }, delayMs);
+  }
+
+  async function doRebuild(reason) {
+    rebuildScheduled = false;
+    rebuilding = true;
+    try {
+      await withTimeout(rebuildChat(reason), REBUILD_WATCHDOG_MS, 'rebuild_watchdog');
+      lastRebuildSuccessAt = Date.now();
+      rebuildRetryAttempt = 0;
+      if (rebuildRetryTimer) { clearTimeout(rebuildRetryTimer); rebuildRetryTimer = null; }
+    } catch (e) {
+      log.error('chat_rebuild_failed', e, { reason, message: e.message, attempt: rebuildRetryAttempt });
+      // 自驱重试：指数退避 + jitter；不依赖外部信号
+      const idx = Math.min(rebuildRetryAttempt, REBUILD_RETRY_BACKOFF_MS.length - 1);
+      const base = REBUILD_RETRY_BACKOFF_MS[idx];
+      const jitter = Math.floor(Math.random() * 1000);
+      const delay = base + jitter;
+      rebuildRetryAttempt += 1;
+      log.info('chat_rebuild_retry_scheduled', { attempt: rebuildRetryAttempt, delayMs: delay });
+      scheduleRebuildRetry(`auto_retry:${reason}`, delay);
+    } finally {
+      rebuilding = false;
+      if (rebuildRequestedAgain) {
+        rebuildRequestedAgain = false;
+        scheduleRebuild('trailing');
+      }
     }
   }
 
   function scheduleRebuild(reason) {
-    if (rebuildInProgress) return;
+    // 已在重建中：标记 trailing，结束后再跑一轮
+    if (rebuilding) {
+      rebuildRequestedAgain = true;
+      log.info('chat_rebuild_queued_trailing', { reason });
+      return;
+    }
+    // 已在等待启动：合并（debounce）
+    if (rebuildScheduled) return;
+    // Cooldown 只针对上次"成功"的重建——失败后允许立即重试
     const now = Date.now();
-    if (now - lastRebuildAt < REBUILD_COOLDOWN_MS) {
+    if (now - lastRebuildSuccessAt < REBUILD_COOLDOWN_MS) {
       log.info('chat_rebuild_skipped_cooldown', { reason });
       return;
     }
-    rebuildInProgress = true;
-    setTimeout(async () => {
-      try {
-        await rebuildChat(reason);
-        lastRebuildAt = Date.now();
-      } finally {
-        rebuildInProgress = false;
-      }
-    }, REBUILD_DEBOUNCE_MS);
+    // 立即降级：阻止发送路径继续用坏 chat
+    sdkReady = false;
+    rebuildScheduled = true;
+    setTimeout(() => { doRebuild(reason).catch(() => {}); }, REBUILD_DEBOUNCE_MS);
   }
 
   function startKeepalive() {
     if (keepaliveTimer) return;
     keepaliveTimer = setInterval(async () => {
-      if (!sdkReady || rebuildInProgress) return;
+      if (!sdkReady || rebuilding || rebuildScheduled) return;
       try {
-        await Promise.race([
-          chat.getMyProfile(),
-          new Promise((_, reject) =>
-            setTimeout(() => reject(new Error('keepalive timeout')), KEEPALIVE_TIMEOUT_MS)
-          ),
-        ]);
+        await withTimeout(chat.getMyProfile(), KEEPALIVE_TIMEOUT_MS, 'keepalive');
       } catch (e) {
         log.warn('keepalive_failed', { message: e.message });
         scheduleRebuild(`keepalive:${e.message}`);
@@ -609,54 +723,26 @@ function createImPlugin() {
     myUserId = credentials.userId;
     credentialsRef = credentials;
 
-    // 先 delete window 让 SDK 走 node 路径
-    delete global.window;
     TencentCloudChat = require('@tencentcloud/chat');
-    chat = TencentCloudChat.create({ SDKAppID: Number(credentials.sdkAppId) });
-
-    // 然后补上 SDK 运行所需的 window/document 等全局
-    setupSdkGlobals();
 
+    // 首次走 candidate 模式：严格 login + SDK_READY，失败直接 throw
     try {
-      const TIMUploadPlugin = require('tim-upload-plugin');
-      chat.registerPlugin({ 'tim-upload-plugin': TIMUploadPlugin });
+      const built = await buildChatCandidate();
+      chat = built.nextChat;
+      sdkReady = true;
+      log.info('login_ok', { userId: myUserId, gen: built.gen });
       log.info('upload_plugin_registered');
-    } catch (e) {
-      log.warn('upload_plugin_unavailable', { message: e.message });
-    }
-
-    chat.setLogLevel(4);
-
-    // 所有事件监听通过 setupAllListeners 统一注册（便于 rebuild 时重注册）
-    setupAllListeners();
-
-    try {
-      await chat.login({ userID: myUserId, userSig: credentials.userSig });
-      log.info('login_ok', { userId: myUserId });
     } catch (err) {
       log.error('login_failed', err);
       throw wrap(err, {
         code: 'IM_LOGIN_FAILED',
-        hint: '检查 userSig 是否过期、sdkAppId 是否正确',
+        hint: '检查 userSig 是否过期、sdkAppId 是否正确、网络到 my-imcloud.com',
         docs: 'docs/maintainer-guide.md#IM_LOGIN_FAILED',
       });
     }
 
-    // 等 SDK_READY（最多 10s）
-    await new Promise((resolve) => {
-      if (sdkReady) return resolve();
-      const timer = setTimeout(() => {
-        log.warn('sdk_ready_wait_timeout');
-        resolve();
-      }, 10000);
-      chat.on(TencentCloudChat.EVENT.SDK_READY, () => {
-        clearTimeout(timer);
-        resolve();
-      });
-    });
-
     // 拉一次好友列表建立关系表 contacts.json
-    // FRIEND_LIST_UPDATED 监听已在 setupAllListeners 里注册
+    // FRIEND_LIST_UPDATED 监听已在 buildChatCandidate 里注册
     seedDisplayNameFromContacts();
     await refreshContactsFromFriendList();
 
@@ -730,17 +816,23 @@ function createImPlugin() {
       clearInterval(keepaliveTimer);
       keepaliveTimer = null;
     }
+    if (rebuildRetryTimer) {
+      clearTimeout(rebuildRetryTimer);
+      rebuildRetryTimer = null;
+    }
     if (processRejectionHandler) {
       try { process.off('unhandledRejection', processRejectionHandler); } catch {}
       processRejectionHandler = null;
     }
     if (chat) {
       try {
-        await chat.logout();
+        await withTimeout(chat.logout().catch(() => {}), LOGOUT_TIMEOUT_MS, 'destroy_logout');
         if (log) log.info('logged_out');
       } catch (e) {
         if (log) log.warn('logout_failed', { message: e.message });
       }
+      try { chat.destroy && chat.destroy(); } catch {}
+      chat = null;
     }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seamnet/client",
-  "version": "0.13.0",
+  "version": "0.13.2",
   "description": "One command to join Seam — the network where people and AI stay in sync.",
   "bin": {
     "seam-client": "bin/cli.js",