mercury-agent 0.16.0 → 0.16.1

package/container/Dockerfile

@@ -95,7 +95,12 @@ RUN bun install --production
 # but before the volatile /app source COPYs below — so this expensive `chown -R`
 # (it walks the whole Chromium + .bun tree) lands in a stable cached layer.
 # Editing source files no longer invalidates it or forces the huge layer re-export.
-RUN chown -R mercury:mercury /home/mercury
+# `mkdir` here rather than leaving it to Docker: the host mounts the global dir
+# into PI_CODING_AGENT_DIR entry by entry, so Docker would create this dir as
+# the mount parent and own it as root — and pi 0.84's credential store writes
+# an empty auth.json on its first *read*, which then fails EACCES and takes
+# every model leg down with it. Folded into the chown so it shares the layer.
+RUN mkdir -p /home/mercury/.pi/agent && chown -R mercury:mercury /home/mercury
 
 COPY src/agent/container-entry.ts /app/src/agent/container-entry.ts
 COPY src/agent/model-capabilities-core.ts /app/src/agent/model-capabilities-core.ts

package/container/Dockerfile.base

@@ -94,7 +94,12 @@ RUN echo '#!/bin/sh\nbun run /app/src/cli/mrctl.ts "$@"' > /usr/local/bin/mrctl
     chmod +x /usr/local/bin/mrctl
 
 # Fix ownership of all mercury home dir artifacts before switching user
-RUN chown -R mercury:mercury /home/mercury
+# `mkdir` here rather than leaving it to Docker: the host mounts the global dir
+# into PI_CODING_AGENT_DIR entry by entry, so Docker would create this dir as
+# the mount parent and own it as root — and pi 0.84's credential store writes
+# an empty auth.json on its first *read*, which then fails EACCES and takes
+# every model leg down with it. Folded into the chown so it shares the layer.
+RUN mkdir -p /home/mercury/.pi/agent && chown -R mercury:mercury /home/mercury
 
 USER mercury
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mercury-agent",
-  "version": "0.16.0",
+  "version": "0.16.1",
   "description": "Personal AI assistant for chat platforms (WhatsApp, Slack, Discord, Telegram)",
   "license": "MIT",
   "author": "Avishai Tsabari",

package/src/adapters/whatsapp.ts

@@ -421,18 +421,28 @@ export class WhatsAppBaileysAdapter
     }
 
     if (!this.connected || !this.sock) {
-      this.outgoingQueue.push({ jid: chatJid, text });
-      logger.warn("WhatsApp queued outbound", {
-        chatJid,
-        queueSize: this.outgoingQueue.length,
-      });
-      return { id: `queued-${Date.now()}`, threadId, raw: {} };
+      return this.queueOutbound(threadId, chatJid, text, "not connected");
     }
 
     logger.info("WhatsApp outbound", { chatJid, preview: text.slice(0, 120) });
-    const sent = await this.sock.sendMessage(chatJid, {
-      text: applyRtlDirection(normalizeChatMarkdown(text)),
-    });
+    let sent: WAMessage | undefined;
+    try {
+      sent = await this.sock.sendMessage(chatJid, {
+        text: applyRtlDirection(normalizeChatMarkdown(text)),
+      });
+    } catch (err) {
+      // The `connected` check above is a pre-flight guard, not a failure
+      // handler: `connection.update` fires asynchronously, so a socket that
+      // dies mid-send throws here with the flag still true. Queueing on the
+      // throw is what actually survives a drop — without it the reply is lost
+      // for good, and the caller's dangling ⏳ status message never clears.
+      return this.queueOutbound(
+        threadId,
+        chatJid,
+        text,
+        err instanceof Error ? err.message : String(err),
+      );
+    }
     if (!sent) {
       throw new Error("WhatsApp sendMessage returned no message");
     }
@@ -443,6 +453,26 @@ export class WhatsAppBaileysAdapter
     };
   }
 
+  /**
+   * Park an outbound text for `flushOutgoingQueue` to replay once the socket
+   * reopens. Returns a synthetic id: the send has not happened yet, so there
+   * is no platform message id to record against it.
+   */
+  private queueOutbound(
+    threadId: string,
+    chatJid: string,
+    text: string,
+    reason: string,
+  ): RawMessage<proto.IWebMessageInfo> {
+    this.outgoingQueue.push({ jid: chatJid, text });
+    logger.warn("WhatsApp queued outbound", {
+      chatJid,
+      reason,
+      queueSize: this.outgoingQueue.length,
+    });
+    return { id: `queued-${Date.now()}`, threadId, raw: {} };
+  }
+
   async editMessage(
     _threadId: string,
     _messageId: string,
@@ -762,9 +792,22 @@ export class WhatsAppBaileysAdapter
       while (this.outgoingQueue.length > 0) {
         const item = this.outgoingQueue.shift();
         if (!item) continue;
-        await this.sock.sendMessage(item.jid, {
-          text: applyRtlDirection(normalizeChatMarkdown(item.text)),
-        });
+        try {
+          await this.sock.sendMessage(item.jid, {
+            text: applyRtlDirection(normalizeChatMarkdown(item.text)),
+          });
+        } catch (err) {
+          // Per item, not per flush: an unsendable message (or a socket that
+          // dropped again mid-drain) must not discard everything still queued
+          // behind it. The item itself is already shifted off — dropping one
+          // is the cost of not blocking the rest, and it is logged.
+          logger.error("WhatsApp queued outbound failed, dropping", {
+            chatJid: item.jid,
+            remaining: this.outgoingQueue.length,
+            error: err instanceof Error ? err.message : String(err),
+          });
+          if (!this.connected || !this.sock) return;
+        }
       }
     } finally {
       this.flushing = false;

package/src/bridges/whatsapp.ts

@@ -297,10 +297,12 @@ export class WhatsAppBridge implements PlatformBridge {
     }
 
     if (!textSent) {
-      const sent = await sock.sendMessage(chatJid, {
-        text: applyRtlDirection(normalizeChatMarkdown(text)),
-      });
-      if (sent?.key?.id) lastSentId = sent.key.id;
+      // Through the adapter, not the raw socket: `postMessage` owns the
+      // queue-and-flush-on-reconnect path, and reaching around it is what let
+      // a mid-run disconnect destroy the whole reply — text included — while
+      // text-only replies in other spaces survived the same drop.
+      const sent = await this.adapter.postMessage(threadId, text);
+      if (sent.id) lastSentId = sent.id;
     }
 
     return lastSentId;

package/src/core/handler.ts

@@ -185,11 +185,44 @@ export function createMessageHandler(opts: MessageHandlerOptions) {
           ? `${reply}\n\n_(responded in ${elapsed}s)_`
           : reply;
       if (finalReply || files.length > 0) {
-        const sentPlatformId = await bridge.sendReply(
-          threadId,
-          finalReply,
-          files.length > 0 ? files : undefined,
-        );
+        // Guarded, because this await used to be the one unprotected step
+        // between a finished run and the user: the try/catch above covers
+        // `handleRawInput` only, so a delivery throw escaped `processIngress`
+        // entirely and surfaced as a bare "Debounce flush error" — with the ⏳
+        // status message left dangling (its best-effort delete had already
+        // failed against the same dead socket). The run is done and the reply
+        // is already stored; losing the transport must not read as "still
+        // thinking".
+        let sentPlatformId: string | undefined;
+        try {
+          sentPlatformId = await bridge.sendReply(
+            threadId,
+            finalReply,
+            files.length > 0 ? files : undefined,
+          );
+        } catch (err) {
+          logger.error("Failed to deliver reply", {
+            platform: bridge.platform,
+            threadId,
+            spaceId: ingress.spaceId,
+            fileCount: files.length,
+            error:
+              err instanceof Error ? (err.stack ?? err.message) : String(err),
+          });
+          // Retry the text alone. On WhatsApp this lands in the adapter's
+          // outbound queue and is replayed on reconnect, so the human gets the
+          // answer even when the attachments are gone; the files stay in
+          // `outbox/` for retrieval.
+          if (finalReply) {
+            await bridge.sendReply(threadId, finalReply).catch((e) =>
+              logger.error("Failed to deliver reply text after retry", {
+                threadId,
+                error: e instanceof Error ? e.message : String(e),
+              }),
+            );
+          }
+          return;
+        }
 
         if (
           sentPlatformId &&