@clawling/clawchat-plugin-openclaw 2026.10.11-2 → 2026.10.13-1

package/dist/src/api-client.js

@@ -251,6 +251,7 @@ export function createOpenclawClawlingApiClient(opts) {
                     ? env.message
                     : "";
             if (code !== 0) {
+                // Business-code 401 is an API error, not HTTP auth expiry; do not refresh.
                 throw new ClawlingApiError("api", msg || `code=${code}`, {
                     code,
                     status: res.status,

package/dist/src/inbound.js

@@ -1,6 +1,34 @@
 import { EVENT, MENTION_ALL_USER_ID, } from "./protocol-types.js";
 import { extractMediaFragments, fragmentsToText } from "./message-mapper.js";
 import { hasRenderableText, isInboundMessagePayload } from "./protocol.js";
+/**
+ * The text after the mention fragments a message opens with (only blank text
+ * may sit between them), when one of those mentions is `userId` or
+ * @everyone. Mention fragments are the source of truth: a display name may
+ * contain spaces, so the rendered `@name` cannot be split off by pattern.
+ */
+export function textAfterLeadingMentionsOf(fragments, userId) {
+    if (!userId || !Array.isArray(fragments))
+        return null;
+    const ids = [];
+    let index = 0;
+    for (; index < fragments.length; index += 1) {
+        const fragment = fragments[index];
+        if (fragment?.kind === "mention") {
+            const id = typeof fragment.user_id === "string" ? fragment.user_id.trim() : "";
+            if (id)
+                ids.push(id);
+            continue;
+        }
+        if (fragment?.kind === "text" && typeof fragment.text === "string" && !fragment.text.trim())
+            continue;
+        break;
+    }
+    if (!ids.includes(userId) && !ids.includes(MENTION_ALL_USER_ID))
+        return null;
+    const rest = fragmentsToText(fragments.slice(index));
+    return rest || null;
+}
 function normalizeSender(sender) {
     if (!sender || typeof sender !== "object")
         return null;
@@ -160,6 +188,10 @@ export async function dispatchOpenclawClawlingInbound(params) {
         mentionFallbackIds: mentionIds,
     });
     const mediaItems = extractMediaFragments(message.body.fragments);
+    const afterMentions = isGroup
+        ? textAfterLeadingMentionsOf(message.body.fragments, account.userId)
+        : null;
+    const addressedCommandBody = afterMentions?.startsWith("/") ? afterMentions : null;
     const wasMentioned = detectMention({
         mentions: mentionIds,
         chatType,
@@ -209,6 +241,7 @@ export async function dispatchOpenclawClawlingInbound(params) {
         senderId: sender.id,
         senderNickName: sender.nickName,
         rawBody,
+        ...(addressedCommandBody ? { addressedCommandBody } : {}),
         messageId: payload.message_id,
         // Single inbound message — allMessageIds starts as a one-element array.
         // The group coalescer merges these into the full set for batched turns.

package/dist/src/refresh-manager.js

@@ -1,4 +1,9 @@
+import { createHash } from "node:crypto";
 import { authRefresh, CODE_INVALID_REFRESH, decodeJwtExp, } from "./api-client.js";
+/** Fingerprint only: revoked refresh credentials must never enter marker storage. */
+export function fingerprintRefreshToken(token) {
+    return createHash("sha256").update(token.trim()).digest("hex");
+}
 /**
  * §A–§D — ClawChat token refresh + auto-logout orchestration for the OpenClaw
  * plugin.
@@ -70,12 +75,9 @@ export class RefreshManager {
     inFlight = null;
     /** §A.3 — the access token a refresh was last attempted for. */
     rejectedToken = null;
-    /**
-     * §B race — the refresh token we last successfully rotated AWAY from (now
-     * consumed server-side). A subsequent `code:10003` for this exact token is a
-     * consumed-rotation race, NOT a revocation, so it must not auto-logout.
-     */
+    /** Consumed-token history is diagnostic; a live successor is required to recover. */
     lastRotatedFromToken = null;
+    consecutiveRaceDowngrades = 0;
     /** §A.3 — epoch-ms of the last refresh attempt (any token). */
     lastAttemptAt = 0;
     proactiveTimer = null;
@@ -135,10 +137,12 @@ export class RefreshManager {
             result = await authRefresh({ baseUrl: this.ports.baseUrl, ...(this.ports.fetchImpl ? { fetchImpl: this.ports.fetchImpl } : {}) }, { refreshToken, deviceId: this.ports.deviceId });
         }
         catch (err) {
+            this.consecutiveRaceDowngrades = 0;
             const message = err instanceof Error ? err.message : String(err);
             return { kind: "transient", message };
         }
         if (result.kind === "success") {
+            this.consecutiveRaceDowngrades = 0;
             // §0 rotation hazard — persist FIRST, swap SECOND. If persistence REJECTS
             // (a store/config write failed), DO NOT swap the in-memory token: a
             // sqlite-sourced agent must not keep a now-dead refresh token in its row
@@ -163,8 +167,7 @@ export class RefreshManager {
                 accessToken: result.accessToken,
                 refreshToken: result.refreshToken,
             });
-            // §B race — record the now-consumed refresh token so a later `10003` for it
-            // is recognized as a rotation race rather than a revocation.
+            // Keep rotation history for inspection; it never overrides the live-token check.
             this.lastRotatedFromToken = refreshToken;
             // Clear the latch; the access token has actually changed.
             this.rejectedToken = null;
@@ -172,31 +175,27 @@ export class RefreshManager {
             return { kind: "success", accessToken: result.accessToken, refreshToken: result.refreshToken };
         }
         if (result.kind === "permanent") {
-            // §B race — a `code:10003` is also returned for a refresh token already
-            // CONSUMED by a prior successful rotation (once the backend grace window
-            // no longer covers it). Before auto-logging-out
-            // (which wipes credentials and bricks the agent), distinguish that race
-            // from a genuine revocation. It is a race when EITHER the submitted token
-            // is one we already rotated away from, OR the live store refresh token has
-            // moved on since we read it (another worker rotated underneath us). In
-            // either case the credential chain is still alive — report transient (no
-            // latch, no logout) so the next attempt proceeds with the live token. A
-            // `code:400` (client bug) is never a race.
+            // A consumed-token race is recoverable only with a real live successor.
+            // Bound repeated downgrades, including across gateway re-enters.
             if (result.code === CODE_INVALID_REFRESH) {
                 const liveRefresh = this.ports.getRefreshToken();
-                const rotatedByUs = this.lastRotatedFromToken !== null && refreshToken === this.lastRotatedFromToken;
-                const rotatedUnderneath = !!liveRefresh && liveRefresh.trim().length > 0 && liveRefresh !== refreshToken;
-                if (rotatedByUs || rotatedUnderneath) {
-                    this.ports.log?.info?.(`clawchat-plugin-openclaw refresh 10003 treated as consumed-rotation race (rotatedByUs=${rotatedByUs} rotatedUnderneath=${rotatedUnderneath}); recovering with live token`);
+                const hasSuccessor = !!liveRefresh?.trim() && liveRefresh !== refreshToken;
+                if (hasSuccessor && this.consecutiveRaceDowngrades < 2) {
+                    this.consecutiveRaceDowngrades += 1;
+                    this.ports.log?.info?.("clawchat-plugin-openclaw refresh 10003 treated as consumed-rotation race; recovering with live token");
                     return { kind: "transient", message: "refresh token already rotated (race); retrying with current token" };
                 }
             }
             // §A.3 — latch the dead token so reconnect storms don't re-fire refresh.
             this.rejectedToken = accessToken;
             this.ports.log?.error?.(`clawchat-plugin-openclaw refresh permanent failure code=${result.code}: ${result.message}`);
-            await this.ports.onPermanentFailure({ code: result.code, message: result.message });
+            await this.ports.onPermanentFailure({
+                code: result.code,
+                message: result.message,
+            }, { fingerprint: fingerprintRefreshToken(refreshToken), revokedAt: this.now() });
             return { kind: "permanent", code: result.code, message: result.message };
         }
+        this.consecutiveRaceDowngrades = 0;
         // Transient — never auto-logout; the old refresh token is still valid.
         this.ports.log?.info?.(`clawchat-plugin-openclaw refresh transient failure: ${result.message}`);
         return { kind: "transient", message: result.message };
@@ -362,6 +361,7 @@ export class RefreshManager {
             rejectedToken: this.rejectedToken,
             lastAttemptAt: this.lastAttemptAt,
             lastRotatedFromToken: this.lastRotatedFromToken,
+            consecutiveRaceDowngrades: this.consecutiveRaceDowngrades,
         };
     }
     /** §A.3/§A.4 — restore guard state from a prior manager (see `exportState`). */
@@ -369,6 +369,7 @@ export class RefreshManager {
         this.rejectedToken = state.rejectedToken;
         this.lastAttemptAt = state.lastAttemptAt;
         this.lastRotatedFromToken = state.lastRotatedFromToken ?? null;
+        this.consecutiveRaceDowngrades = state.consecutiveRaceDowngrades ?? 0;
     }
 }
 function decodeJwtIat(token) {

package/dist/src/reply-dispatcher.js

@@ -4,7 +4,7 @@ import { classifyFrameworkError, formatFrameworkErrorForOwner, isFrameworkErrorR
 import { createOpenclawClawlingApiClient } from "./api-client.js";
 import { effectiveOutputVisibility, } from "./config.js";
 import { describeOutboundMediaShortfall, uploadOutboundMedia, } from "./media-runtime.js";
-import { mintMessageId, sendOpenclawClawlingText, } from "./outbound.js";
+import { mintMessageId, sendOpenclawClawlingReaction, sendOpenclawClawlingText, } from "./outbound.js";
 import { isClawChatNoopResponseText } from "./profile-prompt.js";
 import { consumeTerminalClawChatSend } from "./terminal-send.js";
 import { createReplyStream, streamableText } from "./reply-stream.js";
@@ -266,7 +266,7 @@ function formatApprovalSummary(payload) {
  * as separate ClawChat messages.
  */
 export function createOpenclawClawlingReplyDispatcher(options) {
-    const { cfg, runtime, account, client, target, replyCtx, inboundMessageId, store, resolveOwnerConversationId, resolveOwnerLocale, log, } = options;
+    const { cfg, runtime, account, client, target, replyCtx, inboundMessageId, store, resolveOwnerConversationId, resolveOwnerLocale, ownerCommandReceipt, log, } = options;
     const isGroupTarget = target.chatType === "group";
     let warnedLocalReplyMedia = false;
     // Non-owner turns may only send remote (http/https) media. Local sources are
@@ -411,7 +411,7 @@ export function createOpenclawClawlingReplyDispatcher(options) {
         log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw suppressing ${reason} reply after terminal tool send msg=${terminal.messageId} to=${target.chatId}`);
         return true;
     };
-    const claimOutbound = (eventType, messageId, text, raw) => {
+    const claimOutbound = (eventType, messageId, text, raw, chatId = target.chatId) => {
         if (!store || !messageId)
             return null;
         try {
@@ -421,7 +421,7 @@ export function createOpenclawClawlingReplyDispatcher(options) {
                 kind: "message",
                 direction: "outbound",
                 eventType,
-                chatId: target.chatId,
+                chatId,
                 messageId,
                 text,
                 raw,
@@ -607,6 +607,70 @@ export function createOpenclawClawlingReplyDispatcher(options) {
         // terminal tool send), the stream is closed now.
         replyStream = null;
     };
+    // ----- Owner command receipt -------------------------------------------
+    //
+    // The owner's group command answers in the owner's direct chat, so the
+    // group sees only a ✅ on the command. Any failure falls back to the group:
+    // a noisy group beats an owner who never hears back.
+    let receiptReacted = false;
+    const receiptTarget = () => {
+        if (!ownerCommandReceipt || !isGroupTarget)
+            return null;
+        const ownerTarget = ownerDirectTarget();
+        if (!ownerTarget) {
+            log?.warn?.(`[${account.accountId}] clawchat-plugin-openclaw owner command receipt kept in group reason=missing_owner_conversation group=${target.chatId}`);
+        }
+        return ownerTarget;
+    };
+    const markCommandReceived = () => {
+        if (!ownerCommandReceipt || receiptReacted)
+            return;
+        receiptReacted = true;
+        try {
+            sendOpenclawClawlingReaction({
+                client,
+                chatId: target.chatId,
+                targetMessageId: ownerCommandReceipt.commandMessageId,
+                emoji: "✅",
+                removed: false,
+                log,
+            });
+        }
+        catch (error) {
+            log?.warn?.(`[${account.accountId}] clawchat-plugin-openclaw owner command ✅ failed group=${target.chatId}: ${String(error)}`);
+        }
+    };
+    const sendOwnerCommandReceipt = async (ownerTarget, text, mediaFragments, richFragments, messageMode) => {
+        const messageId = mintStaticMessageId();
+        const receiptText = text.trim()
+            ? `${ownerCommandReceipt.header}\n\n${text}`
+            : ownerCommandReceipt.header;
+        const raw = { target: ownerTarget, mode: "owner-command-receipt", group: target.chatId };
+        if (claimOutbound("message.send", messageId, receiptText, raw, ownerTarget.chatId) !== true)
+            return null;
+        try {
+            const result = await sendOpenclawClawlingText({
+                client,
+                account,
+                to: ownerTarget,
+                text: receiptText,
+                messageId,
+                ...(richFragments.length > 0 ? { richFragments } : {}),
+                ...(mediaFragments.length > 0 ? { mediaFragments } : {}),
+                ...(messageMode !== "normal" ? { messageMode } : {}),
+                log,
+            });
+            if (!result)
+                return null;
+            log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw owner command receipt sent to owner chat group=${target.chatId} msg=${messageId}`);
+            markCommandReceived();
+            return { result, messageId };
+        }
+        catch (error) {
+            log?.warn?.(`[${account.accountId}] clawchat-plugin-openclaw owner command receipt kept in group reason=owner_send_failed group=${target.chatId}: ${String(error)}`);
+            return null;
+        }
+    };
     // ----- Static send ------------------------------------------------------
     const sendStatic = async (text, mediaFragments = [], richFragments = [], options = {}) => {
         const messageMode = options.messageMode ?? "normal";
@@ -639,6 +703,16 @@ export function createOpenclawClawlingReplyDispatcher(options) {
             return null;
         if (consumeTerminalSend("static"))
             return null;
+        const ownerTarget = receiptTarget();
+        if (ownerTarget) {
+            const receipt = await sendOwnerCommandReceipt(ownerTarget, text, mediaFragments, richFragments, messageMode);
+            if (receipt) {
+                recordOutboundAck("message", receipt.messageId, receipt.result);
+                if (messageMode === "normal")
+                    outboundDeliveredCount += 1;
+                return receipt.result;
+            }
+        }
         log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw sending static mode=${messageMode} text_len=${text.length} media=${mediaFragments.length} rich=${richFragments.length} to=${target.chatId}`);
         const streamMessageId = messageMode === "normal" ? claimStreamMessageId(text) : null;
         const messageId = streamMessageId ?? mintStaticMessageId();