@xmanrui/dsh-im 0.16.0 → 0.17.0

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/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.0',
   };
 }