@unicitylabs/openclaw-unicity 0.5.3 → 0.5.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unicitylabs/openclaw-unicity",
-  "version": "0.5.3",
+  "version": "0.5.5",
   "description": "Unicity wallet identity and encrypted DMs for OpenClaw agents — powered by Sphere SDK",
   "type": "module",
   "main": "src/index.ts",
@@ -44,7 +44,7 @@
   "dependencies": {
     "@clack/prompts": "^0.10.0",
     "@sinclair/typebox": "^0.34.48",
-    "@unicitylabs/sphere-sdk": "^0.5.4"
+    "@unicitylabs/sphere-sdk": "^0.6.7"
   },
   "peerDependencies": {
     "openclaw": "*"

package/src/channel.ts

@@ -244,38 +244,39 @@ export const unicityChannelPlugin = {
 
       // Track DM start time and seen IDs to skip historical replays from the relay.
       // The SDK fires onDirectMessage for every cached/replayed DM on connect.
-      const dmStartTime = Math.floor(Date.now() / 1000);
+      // msg.timestamp is milliseconds, so dmStartTime must be ms too.
+      const dmStartTime = Date.now();
       const seenDmIds = new Set<string>();
       const DM_SEEN_MAX = 1000;
 
       // Collect all known representations of "self" so we can detect echoed-back
-      // messages.  The SDK's built-in self-check compares transport pubkey against
-      // chainPubkey, but those may differ in format (33-byte compressed vs 32-byte
-      // x-only Nostr key), letting self-messages slip through.
+      // messages.  We must track BOTH the 33-byte compressed chainPubkey (02/03…)
+      // and the 32-byte x-only Nostr transport key (chainPubkey without prefix).
+      // The SDK's own self-check in CommunicationsModule has a bug where it
+      // compares transport pubkey (32-byte) against chainPubkey (33-byte), which
+      // never matches — so self-messages can leak through to dmHandlers.
       const selfPubkeys = new Set<string>();
-      if (sphere.identity?.chainPubkey) selfPubkeys.add(sphere.identity.chainPubkey);
+      if (sphere.identity?.chainPubkey) {
+        const cpk = sphere.identity.chainPubkey;
+        selfPubkeys.add(cpk);
+        // x-only transport key = compressed pubkey without the 02/03 prefix
+        if (cpk.length === 66 && (cpk.startsWith("02") || cpk.startsWith("03"))) {
+          selfPubkeys.add(cpk.slice(2));
+        }
+      }
+      // Also add the groupChat key (same value but grabbed independently for safety)
       const myNostrPubkey = sphere.groupChat?.getMyPublicKey?.() ?? null;
       if (myNostrPubkey) selfPubkeys.add(myNostrPubkey);
 
-      const unsub = sphere.communications.onDirectMessage((msg) => {
-        // Skip messages from self (own DMs echoed back by the relay)
-        if (selfPubkeys.has(msg.senderPubkey)) return;
+      // Per-sender queue: while a reply is being generated for a sender, hold
+      // the latest incoming message so it gets processed after the current reply
+      // finishes.  Prevents duplicate replies while not dropping follow-ups.
+      type DmMsg = { id: string; senderPubkey: string; senderNametag?: string; recipientPubkey: string; content: string; timestamp: number; isRead: boolean };
+      const sendersInFlight = new Set<string>();
+      const pendingPerSender = new Map<string, DmMsg>();
 
-        // Deduplicate: skip already-processed messages (relays may deliver dupes)
-        if (msg.id && seenDmIds.has(msg.id)) return;
-        if (msg.id) {
-          seenDmIds.add(msg.id);
-          if (seenDmIds.size > DM_SEEN_MAX) {
-            const first = seenDmIds.values().next().value!;
-            seenDmIds.delete(first);
-          }
-        }
-
-        // Skip historical messages replayed on connect
-        if (msg.timestamp && msg.timestamp < dmStartTime) {
-          ctx.log?.debug(`[${ctx.account.accountId}] Skipping historical DM (ts=${msg.timestamp} < start=${dmStartTime})`);
-          return;
-        }
+      function dispatchDm(msg: DmMsg): void {
+        sendersInFlight.add(msg.senderPubkey);
 
         // Immediately signal that we're composing a reply
         sphere.communications.sendComposingIndicator(msg.senderPubkey)
@@ -354,7 +355,47 @@ export const unicityChannelPlugin = {
           })
           .catch((err: unknown) => {
             ctx.log?.error(`[${ctx.account.accountId}] Reply dispatch error: ${err}`);
+          })
+          .finally(() => {
+            sendersInFlight.delete(msg.senderPubkey);
+            // If a follow-up message arrived while we were replying, process it now
+            const pending = pendingPerSender.get(msg.senderPubkey);
+            if (pending) {
+              pendingPerSender.delete(msg.senderPubkey);
+              ctx.log?.info(`[${ctx.account.accountId}] Processing queued DM from ${peerId}`);
+              dispatchDm(pending);
+            }
           });
+      }
+
+      const unsub = sphere.communications.onDirectMessage((msg) => {
+        // Skip messages from self (own DMs echoed back by the relay)
+        if (selfPubkeys.has(msg.senderPubkey)) return;
+
+        // Deduplicate: skip already-processed messages (relays may deliver dupes)
+        if (msg.id && seenDmIds.has(msg.id)) return;
+        if (msg.id) {
+          seenDmIds.add(msg.id);
+          if (seenDmIds.size > DM_SEEN_MAX) {
+            const first = seenDmIds.values().next().value!;
+            seenDmIds.delete(first);
+          }
+        }
+
+        // Skip historical messages replayed on connect
+        if (msg.timestamp && msg.timestamp < dmStartTime) {
+          ctx.log?.debug(`[${ctx.account.accountId}] Skipping historical DM (ts=${msg.timestamp} < start=${dmStartTime})`);
+          return;
+        }
+
+        // Per-sender lock: queue if we're already generating a reply for this sender
+        if (sendersInFlight.has(msg.senderPubkey)) {
+          ctx.log?.debug(`[${ctx.account.accountId}] Queuing DM from ${msg.senderPubkey.slice(0, 16)}… — reply in flight`);
+          pendingPerSender.set(msg.senderPubkey, msg);
+          return;
+        }
+
+        dispatchDm(msg);
       });
 
       ctx.log?.info(`[${ctx.account.accountId}] Unicity DM listener active`);