@xmanrui/dsh-im 0.16.0 → 0.17.1

package/src/channels/feishu/feishu-cards.mjs

@@ -4,10 +4,14 @@
  * `im.message.create` API expects as `content` for `msg_type: interactive`
  * (card schema 2.0; callback buttons live inside a column_set/column layout).
  *
- * Buttons carry a small `{ action }` callback behavior that
- * `card.action.trigger` events echo back (when the app subscribes that
- * callback); every button also carries a numeric label so the number-reply
- * fallback stays usable without button callbacks.
+ * The session list lays each row out as a `column_set` (fixed-width ⭐
+ * watch-toggle column + weighted session-button column), which is how V2
+ * expresses a row of buttons.
+ *
+ * Buttons carry a small `{ action }` value object that `card.action.trigger`
+ * events echo back (when the app subscribes that event); every numbered
+ * button also has a numeric label so the number-reply fallback stays usable
+ * without button callbacks.
  */
 
 export const MENU_PAGE_SIZE = 10;
@@ -39,6 +43,17 @@ function button(content, actionValue) {
   };
 }
 
+/** The raw button element (without the full-width column_set wrapper). */
+function buttonElement(content, actionValue) {
+  return {
+    tag: 'button',
+    text: plainText(content),
+    type: 'default',
+    width: 'fill',
+    behaviors: [{ type: 'callback', value: { action: actionValue } }],
+  };
+}
+
 function safeTitle(value) {
   const title = String(value ?? '').replace(/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]+/gu, ' ').replace(/\s+/gu, ' ').trim();
   return title || '暂无标题';
@@ -65,6 +80,7 @@ export function menuCard() {
     // have card.action.trigger yet, so rendering it as a callback button would
     // send the user straight back to Feishu's broken callback setup popup.
     { tag: 'div', text: markdown('**6 · 修复卡片按钮**（请直接回复数字 **6**）') },
+    button('7 · 关注列表', 'watchlist'),
   ]);
 }
 
@@ -101,23 +117,43 @@ export function cardActionProbeCard(nonce) {
 }
 
 /**
- * One page of the workspace's sessions. Each row is a bind button; the
- * number label equals the reply-number for the same action (fallback).
+ * One page of the workspace's sessions. Each row is a `column_set` pair:
+ * the fixed-width ⭐ watch toggle (`⭐关注` / `⭐取关` for already-watched
+ * sessions) followed by the session button that carries the page-local
+ * number label (reply-number fallback = bind). Archived sessions are marked
+ * in the label. `watchedSessionIds` is a Set-like of ids this conversation
+ * already watches.
  */
-export function sessionListCard(workspace, sessions, page, total) {
+export function sessionListCard(workspace, sessions, page, total, watchedSessionIds = new Set()) {
   const start = page * MENU_PAGE_SIZE;
   const slice = sessions.slice(start, start + MENU_PAGE_SIZE);
   const pageCount = Math.max(1, Math.ceil(total / MENU_PAGE_SIZE));
+  const watched = (id) => typeof watchedSessionIds?.has === 'function' && watchedSessionIds.has(id);
+  /** One row: fixed 90px watch toggle + the session button filling the rest. */
+  const row = (watchButton, sessionButton) => ({
+    tag: 'column_set',
+    flex_mode: 'none',
+    horizontal_spacing: 'default',
+    columns: [
+      { tag: 'column', width: '90px', vertical_align: 'center', elements: [watchButton] },
+      { tag: 'column', width: 'weighted', weight: 1, vertical_align: 'center', elements: [sessionButton] },
+    ],
+  });
   const elements = [
     { tag: 'div', text: markdown(`**工作区**：\`${workspace}\`\n共 **${total}** 个会话${total > MENU_PAGE_SIZE ? `（第 ${page + 1}/${pageCount} 页）` : ''}`) },
-    ...slice.map((session, offset) => button(
-      `${offset + 1}. ${safeTitle(session.title)}`,
-      `use:${session.sessionId}`,
-    )),
+    ...slice.map((session, offset) => {
+      // Page-local numbering: number replies resolve against this page.
+      const label = `${offset + 1}. ${safeTitle(session.title)}${session.archived === true ? '（已归档）' : ''}`;
+      const watching = watched(session.sessionId);
+      return row(
+        buttonElement(watching ? '⭐取关' : '⭐关注', watching ? `unwatch:${session.sessionId}` : `watch:${session.sessionId}`),
+        buttonElement(label, `use:${session.sessionId}`),
+      );
+    }),
   ];
   if (page > 0) elements.push(button('◀ 上一页', `sessions:${page - 1}`));
   if (page + 1 < pageCount) elements.push(button('下一页 ▶', `sessions:${page + 1}`));
-  elements.push({ tag: 'div', text: markdown('回复数字（1~N）同样可以绑定本页会话。') });
+  elements.push({ tag: 'div', text: markdown('回复数字（1~N）绑定本页会话。') });
   return cardWith('📂 会话列表', elements);
 }
 
@@ -146,10 +182,49 @@ export function menuHelpText() {
     '4 · /status  连接状态',
     '5 · /help  本帮助',
     '6 · /repair  修复卡片按钮（请回复数字 6）',
+    '7 · /watchlist  关注列表',
     '',
     '直接发送文字/图片即继续当前会话。',
     '/session ID 或序号  绑定已有会话',
+    '/watch ID 或序号  关注会话（完成后推送）',
     '/compact  压缩上下文',
     '/workspace 绝对路径  切换工作区',
   ].join('\n');
 }
+
+/** The watch list for one conversation (unwatch buttons + reply fallback). */
+export function watchListCard(entries) {
+  const elements = entries.length === 0
+    ? [{ tag: 'div', text: markdown('当前没有关注的会话。\n`/watch <ID|序号>` 关注后，任务完成会自动推送。') }]
+    : [
+        { tag: 'div', text: markdown('任务完成会自动推送，回复数字或点按钮取消关注：') },
+        ...entries.map((entry, index) => button(
+          `${index + 1}. ${safeTitle(entry.title)}`,
+          `unwatch:${entry.sessionId}`,
+        )),
+      ];
+  return cardWith('👁 关注列表', elements);
+}
+
+/**
+ * The completion push card. `title` is the session title, `reason` the
+ * turn-end kind (completed / stopped / aborted).
+ */
+export function completionCard(sessionId, title, reason) {
+  const reasonText = reason === 'completed'
+    ? '已完成'
+    : reason === 'stopped'
+      ? '已停止'
+      : reason === 'aborted'
+        ? '已中止'
+        : reason === 'cancelled'
+          ? '已取消'
+          : '已结束';
+  return cardWith('✅ 任务完成', [
+    { tag: 'div', text: markdown(`**${safeTitle(title)}**\n\`${sessionId}\``) },
+    { tag: 'div', text: markdown(`**状态**：${reasonText}`) },
+    button('打开会话列表', 'sessions'),
+    button('工作区', 'workspaces'),
+    { tag: 'div', text: markdown('绑定该会话后可继续追问，输入文字即可。') },
+  ]);
+}

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

@@ -1,7 +1,24 @@
 import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
 import { dirname } from 'node:path';
 
-const EMPTY_STATE = Object.freeze({ version: 1, sessions: {}, seenMessageIds: [] });
+const EMPTY_STATE = Object.freeze({
+  version: 1,
+  sessions: {},
+  seenMessageIds: [],
+  watches: {},
+  includeArchivedSessions: false,
+});
+
+/** One conversation key may watch at most this many sessions. */
+export const MAX_WATCHES_PER_KEY = 20;
+
+/** A persisted watch entry: the watched session plus its delivery target. */
+function validWatchEntry(value) {
+  return value
+    && typeof value === 'object'
+    && typeof value.sessionId === 'string' && value.sessionId.length > 0
+    && typeof value.chatId === 'string' && value.chatId.length > 0;
+}
 
 export class StateStore {
   #path;
@@ -19,6 +36,10 @@ export class StateStore {
         version: 1,
         sessions: parsed.sessions && typeof parsed.sessions === 'object' ? parsed.sessions : {},
         seenMessageIds: Array.isArray(parsed.seenMessageIds) ? parsed.seenMessageIds.slice(-1000) : [],
+        watches: parsed.watches && typeof parsed.watches === 'object' ? parsed.watches : {},
+        includeArchivedSessions: typeof parsed.includeArchivedSessions === 'boolean'
+          ? parsed.includeArchivedSessions
+          : false,
       };
     } catch (error) {
       if (error?.code !== 'ENOENT') throw error;
@@ -63,6 +84,69 @@ export class StateStore {
     return structuredClone(this.#state);
   }
 
+  // ── Watches (persisted: surviving restarts) ─────────────────────────────
+
+  watchEntries(key) {
+    const list = this.#state.watches[key];
+    return Array.isArray(list) ? list.filter(validWatchEntry) : [];
+  }
+
+  watchEntry(key, sessionId) {
+    return this.watchEntries(key).find((entry) => entry.sessionId === sessionId) ?? null;
+  }
+
+  async setWatch(key, entry) {
+    const list = this.#state.watches[key] ?? [];
+    const index = list.findIndex((existing) => existing.sessionId === entry.sessionId);
+    if (index === -1) {
+      if (list.length >= MAX_WATCHES_PER_KEY) list.shift();
+      list.push(entry);
+    } else {
+      list[index] = entry;
+    }
+    this.#state.watches[key] = list;
+    await this.#persist();
+  }
+
+  async removeWatch(key, sessionId) {
+    const list = this.#state.watches[key] ?? [];
+    this.#state.watches[key] = list.filter((entry) => entry.sessionId !== sessionId);
+    await this.#persist();
+  }
+
+  async clearWatches(key) {
+    delete this.#state.watches[key];
+    await this.#persist();
+  }
+
+  /** Every conversation key currently watching the given session. */
+  keysWatching(sessionId) {
+    return Object.entries(this.#state.watches)
+      .filter(([, list]) => Array.isArray(list) && list.some((entry) => validWatchEntry(entry) && entry.sessionId === sessionId))
+      .map(([key]) => key);
+  }
+
+  /** Unique watched session ids across all keys (restart compensation). */
+  watchedSessionIds() {
+    const ids = new Set();
+    for (const list of Object.values(this.#state.watches)) {
+      if (!Array.isArray(list)) continue;
+      for (const entry of list) if (validWatchEntry(entry)) ids.add(entry.sessionId);
+    }
+    return [...ids];
+  }
+
+  // ── Session-list archived policy (per bot) ───────────────────
+
+  includesArchivedSessions() {
+    return this.#state.includeArchivedSessions === true;
+  }
+
+  async setIncludeArchivedSessions(include) {
+    this.#state.includeArchivedSessions = include === true;
+    await this.#persist();
+  }
+
   async #persist() {
     const snapshot = JSON.stringify(this.#state, null, 2) + '\n';
     this.#writeQueue = this.#writeQueue.then(async () => {

package/src/channels/shared/harness-client.mjs

@@ -1223,6 +1223,125 @@ export class HarnessClient {
     });
   }
 
+  /**
+   * Watch the global Harness event mux (all sessions) until `signal`
+   * aborts, reconnecting on drop. The Desktop host serves the mux as a
+   * WebSocket downlink; frames are `server-request` envelopes whose payload
+   * is a `session/event` — only those are forwarded. `onReconnect` (when
+   * provided) fires after every (re)connection so callers can compensate
+   * for events missed while offline.
+   */
+  async watchHarnessEvents({ signal, onSessionEvent, onReconnect } = {}) {
+    if (typeof onSessionEvent !== 'function') {
+      throw new TypeError('watchHarnessEvents requires onSessionEvent');
+    }
+    if (!signal || typeof signal.addEventListener !== 'function') {
+      throw new TypeError('watchHarnessEvents requires an AbortSignal');
+    }
+    if (onReconnect !== undefined && typeof onReconnect !== 'function') {
+      throw new TypeError('onReconnect must be a function');
+    }
+    const url = new URL('/api/events.mux', this.#baseUrl);
+    url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
+    while (!signal.aborted) {
+      try {
+        await this.#watchHarnessEventSocket(url.toString(), {
+          signal,
+          onSessionEvent,
+          onReconnect,
+        });
+      } catch (error) {
+        if (signal.aborted) return;
+        console.warn(`[${this.#logPrefix}] Harness event mux disconnected:`, error.message);
+      }
+      if (signal.aborted) return;
+      try {
+        await sleep(this.#interactionReconnectDelayMs, signal);
+      } catch {
+        if (signal.aborted) return;
+        throw new Error('Harness event mux reconnect wait failed');
+      }
+    }
+  }
+
+  #watchHarnessEventSocket(url, { signal, onSessionEvent, onReconnect }) {
+    return new Promise((resolve, reject) => {
+      let socket;
+      try {
+        socket = this.#createWebSocket(url);
+      } catch (error) {
+        reject(error);
+        return;
+      }
+      let opened = false;
+      let finished = false;
+      const close = () => {
+        try {
+          socket.close();
+        } catch {
+          // Already closed.
+        }
+      };
+      const finish = (error) => {
+        if (finished) return;
+        finished = true;
+        socket.removeEventListener('open', handleOpen);
+        socket.removeEventListener('message', handleMessage);
+        socket.removeEventListener('close', handleClose);
+        socket.removeEventListener('error', handleError);
+        signal.removeEventListener('abort', handleAbort);
+        if (error) reject(error);
+        else resolve();
+      };
+      const handleOpen = () => {
+        opened = true;
+        try {
+          onReconnect?.();
+        } catch (error) {
+          console.warn(`[${this.#logPrefix}] mux reconnect hook failed:`, error.message);
+        }
+      };
+      const handleMessage = (event) => {
+        try {
+          if (typeof event.data !== 'string') return;
+          const envelope = JSON.parse(event.data);
+          const payload = envelope?.payload;
+          if (envelope?.type !== 'server-request'
+            || !payload
+            || typeof payload !== 'object'
+            || envelope.method !== payload.type
+            || payload.type !== 'session/event'
+            || typeof payload.sessionId !== 'string'
+            || !payload.event
+            || typeof payload.event !== 'object') return;
+          onSessionEvent({ sessionId: payload.sessionId, event: payload.event });
+        } catch (error) {
+          console.warn(`[${this.#logPrefix}] ignored a malformed global mux frame:`, error.message);
+        }
+      };
+      const handleClose = () => finish(opened ? null : new Error(
+        'Harness event mux WebSocket closed before opening',
+      ));
+      const handleError = () => {
+        finish(new Error(opened
+          ? 'Harness event mux WebSocket failed'
+          : 'Harness event mux WebSocket failed before opening'));
+        close();
+      };
+      const handleAbort = () => {
+        close();
+        finish();
+      };
+
+      socket.addEventListener('open', handleOpen);
+      socket.addEventListener('message', handleMessage);
+      socket.addEventListener('close', handleClose, { once: true });
+      socket.addEventListener('error', handleError, { once: true });
+      signal.addEventListener('abort', handleAbort, { once: true });
+      if (signal.aborted) handleAbort();
+    });
+  }
+
   stopManagedProcess() {
     if (this.#managedProcess?.exitCode === null) this.#managedProcess.kill('SIGTERM');
   }

package/src/channels/shared/image-prompt.mjs

@@ -13,6 +13,18 @@ export class ImagePromptError extends Error {
   }
 }
 
+const HOST_ATTACHMENT_USER_MESSAGES = Object.freeze({
+  MODEL_DOES_NOT_SUPPORT_IMAGES:
+    '当前模型不支持图片，请用 /models 查看可用模型，再用 /model <序号> 切换后重发。',
+  IMAGE_TOO_LARGE: '图片超过宿主允许的大小，请压缩后重试。',
+  IMAGE_TOO_MANY_PIXELS: '图片分辨率过高，请压缩后重试。',
+  INVALID_IMAGE: '图片内容无效或格式不受支持，请重新发送。',
+  INVALID_IMAGE_BASE64: '未能读取图片内容，请重新发送。',
+  IMAGE_TYPE_MISMATCH: '图片格式与实际内容不一致，请重新发送。',
+  TOO_MANY_IMAGES: '一次发送的图片数量超过宿主限制，请减少后重试。',
+  IMAGES_TOO_LARGE: '图片总大小超过宿主限制，请减少图片或压缩后重试。',
+});
+
 function requestSignal(signal, timeoutMs) {
   const timeout = AbortSignal.timeout(timeoutMs);
   return signal ? AbortSignal.any([signal, timeout]) : timeout;
@@ -263,6 +275,25 @@ export async function promptContentForMessage(message, {
   return content;
 }
 
+/** Return only allowlisted, user-safe image failure details. */
+export function imagePromptDiagnostic(error) {
+  if (error instanceof ImagePromptError) {
+    return {
+      code: 'image-prompt-error',
+      reason: error.code,
+      userMessage: error.userMessage,
+    };
+  }
+  if (error?.code !== 'attachment-error' || typeof error?.details?.reason !== 'string') {
+    return null;
+  }
+  const reason = error.details.reason;
+  const userMessage = Object.hasOwn(HOST_ATTACHMENT_USER_MESSAGES, reason)
+    ? HOST_ATTACHMENT_USER_MESSAGES[reason]
+    : null;
+  return userMessage ? { code: 'attachment-error', reason, userMessage } : null;
+}
+
 export function imagePromptUserMessage(error) {
-  return error instanceof ImagePromptError ? error.userMessage : null;
+  return imagePromptDiagnostic(error)?.userMessage ?? null;
 }

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

@@ -184,7 +184,7 @@ function authenticatedHeaders(token) {
 function baseInfo() {
   return {
     channel_version: WEIXIN_PROTOCOL_VERSION,
-    bot_agent: 'DeepSeekHarness/0.16.0',
+    bot_agent: 'DeepSeekHarness/0.17.1',
   };
 }
 

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

@@ -23,12 +23,14 @@ import { runWorkspaceCommand } from '../shared/workspace-command.mjs';
 import { askInWorkspaceSession } from '../shared/workspace-session.mjs';
 import {
   hasInboundImages,
+  imagePromptDiagnostic,
   imagePromptUserMessage,
   promptContentForMessage,
 } from '../shared/image-prompt.mjs';
 import { rememberConnectionTestTarget } from '../shared/connection-test.mjs';
 
 const INTERACTION_RESOLVED_TEXT = '这个问题已在其他客户端处理，无需再次回答。';
+const GENERIC_PROCESSING_ERROR = '消息处理失败，请稍后重试。';
 
 const HELP_TEXT = [
   '微信已连接 DeepSeek Harness。',
@@ -69,6 +71,16 @@ function canClaimInteractionReply(message, pending) {
     && nonEmptyString(extractWeixinText(message));
 }
 
+function safeMessageError(error, userMessage = GENERIC_PROCESSING_ERROR) {
+  const diagnostic = imagePromptDiagnostic(error);
+  return {
+    code: diagnostic?.code ?? 'message-processing-failed',
+    reason: diagnostic?.reason ?? 'UNKNOWN',
+    message: diagnostic?.userMessage ?? userMessage,
+    at: Date.now(),
+  };
+}
+
 export function createWeixinBridgeStatus() {
   return {
     messagesReceived: 0,
@@ -78,6 +90,7 @@ export function createWeixinBridgeStatus() {
     lastReplyAt: null,
     lastRejectedAt: null,
     lastError: null,
+    lastMessageError: null,
   };
 }
 
@@ -168,8 +181,9 @@ export class WeixinHarnessBridge {
       ).catch((error) => {
         if (error?.code === 'turn-stopped' || this.#signal?.aborted) return;
         this.#status.lastError = error?.message ?? String(error);
+        this.#status.lastMessageError = safeMessageError(error);
         this.#logger.error?.('[dsh-weixin] failed to process a command:', error);
-        return this.#send(sender, '消息处理失败，请稍后重试。', contextToken, runId)
+        return this.#send(sender, GENERIC_PROCESSING_ERROR, contextToken, runId)
           .catch(() => undefined);
       }).finally(() => {
         this.#acceptedMessageIds.delete(messageId);
@@ -289,6 +303,7 @@ export class WeixinHarnessBridge {
       if (reply) await this.#send(sender, reply, contextToken, runId);
     }
     this.#status.lastError = null;
+    this.#status.lastMessageError = null;
   }
 
   async #process(message, key, { alreadyRecorded = false } = {}) {
@@ -401,6 +416,7 @@ export class WeixinHarnessBridge {
       this.#status.messagesReplied += 1;
       this.#status.lastReplyAt = new Date().toISOString();
       this.#status.lastError = null;
+      this.#status.lastMessageError = null;
     } catch (error) {
       if (error?.code === 'turn-stopped') {
         await this.#state.markSeen(messageId);
@@ -408,11 +424,13 @@ export class WeixinHarnessBridge {
       }
       if (this.#signal?.aborted) return;
       this.#status.lastError = error?.message ?? String(error);
+      const userMessage = imagePromptUserMessage(error) ?? GENERIC_PROCESSING_ERROR;
+      this.#status.lastMessageError = safeMessageError(error, userMessage);
       this.#logger.error?.('[dsh-weixin] failed to process an inbound message:', error);
       try {
         await this.#send(
           sender,
-          imagePromptUserMessage(error) ?? '消息处理失败，请稍后重试。',
+          userMessage,
           contextToken,
           runId,
         );
@@ -526,6 +544,7 @@ export class WeixinHarnessBridge {
       });
       this.#clearPendingInteraction(key, pending.interactionId);
       this.#status.lastError = null;
+      this.#status.lastMessageError = null;
     } catch (error) {
       if (this.#signal?.aborted) return;
       if (error?.code === 'interaction-not-pending') {
@@ -719,13 +738,14 @@ export class WeixinHarnessBridge {
   async #handleInteractionFailure(message, messageId, error) {
     if (this.#signal?.aborted) return;
     this.#status.lastError = error?.message ?? String(error);
+    this.#status.lastMessageError = safeMessageError(error);
     this.#logger.error?.('[dsh-weixin] failed to process an interaction reply:', error);
     if (!this.#state.hasSeen(messageId)) {
       await this.#state.markSeen(messageId).catch(() => undefined);
     }
     await this.#send(
       nonEmptyString(message?.from_user_id),
-      '消息处理失败，请稍后重试。',
+      GENERIC_PROCESSING_ERROR,
       nonEmptyString(message?.context_token) ?? undefined,
       nonEmptyString(message?.run_id) ?? undefined,
     ).catch(() => undefined);

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

@@ -62,6 +62,20 @@ function safeAccountError(code, message) {
   return Object.freeze({ code, message });
 }
 
+function publicMessageError(value) {
+  if (!value || typeof value !== 'object'
+    || typeof value.code !== 'string' || !value.code
+    || typeof value.reason !== 'string' || !value.reason
+    || typeof value.message !== 'string' || !value.message
+    || !Number.isFinite(value.at)) return null;
+  return {
+    code: value.code.slice(0, 64),
+    reason: value.reason.slice(0, 128),
+    message: value.message.slice(0, 500),
+    at: value.at,
+  };
+}
+
 function activationStageError(code, cause) {
   const error = new Error(`Weixin activation failed during ${code}`, { cause });
   error.name = 'WeixinActivationStageError';
@@ -351,6 +365,7 @@ export class WeixinController {
           messagesReceived: runtimeStatus?.messagesReceived ?? 0,
           messagesReplied: runtimeStatus?.messagesReplied ?? 0,
         },
+        lastMessageError: publicMessageError(runtimeStatus?.lastMessageError),
         error: error ? structuredClone(error) : null,
       };
     });