@xmanrui/dsh-im 0.15.0 → 0.17.0

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/workspace-command.mjs

@@ -85,7 +85,7 @@ async function selectedWorkspacePath(value) {
   }
 }
 
-async function workspacePathSnapshot(harness) {
+export async function workspacePathSnapshot(harness) {
   const listed = await harness.listWorkspaces();
   const currentValue = typeof harness?.currentWorkspace === 'function'
     ? harness.currentWorkspace()
@@ -148,7 +148,7 @@ async function runWorkspaceListCommand(match, harness) {
   }
 }
 
-async function resolveSessionListWorkspace(selector, harness) {
+export async function resolveSessionListWorkspace(selector, harness) {
   if (!selector) {
     if (typeof harness?.currentWorkspace !== 'function') {
       return { error: '当前机器人没有可用的工作区。' };

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.15.0',
+    bot_agent: 'DeepSeekHarness/0.17.0',
   };
 }