@clawling/clawchat-plugin-openclaw 2026.6.30-2 → 2026.6.30-3

package/dist/src/runtime.js

@@ -33,6 +33,34 @@ export { setOpenclawClawlingRuntime, getOpenclawClawlingRuntime };
 const activeClients = new Map();
 const CLAWCHAT_PLUGIN_SLASH_COMMANDS = new Set(["clawchat-activate", "clawchat-output"]);
 const ACTIVATION_CREDENTIAL_POLL_INTERVAL_MS = 2_000;
+// Activation-bootstrap retry on the live connection. The bootstrap greeting is
+// otherwise only (re)dispatched on a fresh `connected` edge, so if its send is
+// cancelled mid-turn (e.g. a proactive token-refresh reconnect closed the
+// transport) or a reconnect's claim no-op'd while a stale in-flight dispatch
+// still held the claim, the greeting would stay pending forever on a now-stable
+// connection. These bound an in-connection retry that re-attempts until the
+// greeting lands or the per-connection budget is spent (then it falls back to
+// the next reconnect, as before).
+const ACTIVATION_BOOTSTRAP_RETRY_DELAY_MS = 5_000;
+const ACTIVATION_BOOTSTRAP_MAX_RETRIES = 6;
+// Count of in-flight activation-bootstrap dispatches per account, shared across
+// gateway re-enters so a fresh connection can tell "nothing pending" (don't
+// retry) apart from "a prior dispatch still holds the claim" (retry once it
+// releases).
+const activationBootstrapInFlight = new Map();
+function incrementActivationBootstrapInFlight(accountId) {
+    activationBootstrapInFlight.set(accountId, (activationBootstrapInFlight.get(accountId) ?? 0) + 1);
+}
+function decrementActivationBootstrapInFlight(accountId) {
+    const next = (activationBootstrapInFlight.get(accountId) ?? 0) - 1;
+    if (next <= 0)
+        activationBootstrapInFlight.delete(accountId);
+    else
+        activationBootstrapInFlight.set(accountId, next);
+}
+function activationBootstrapInFlightCount(accountId) {
+    return activationBootstrapInFlight.get(accountId) ?? 0;
+}
 // Upper bound (ms) on how long group ingest waits for the FIRST group-settings
 // pull to settle before proceeding anyway. Best-effort governance must never
 // permanently disable group traffic, so a stalled initial GET (endpoint accepts
@@ -1450,6 +1478,33 @@ export async function startOpenclawClawlingGateway(params) {
     // outbound message (the greeting). The bootstrap dispatcher reads it to decide
     // whether to mark the bootstrap sent or leave it pending for a later retry.
     let bootstrapProducedFinal = false;
+    // Per-connection retry for a pending activation bootstrap (see the module-level
+    // constants). Re-attempts on the live connection while `wsReady`, bounded by
+    // ACTIVATION_BOOTSTRAP_MAX_RETRIES; the budget resets on each fresh connect.
+    let bootstrapRetryTimer;
+    let bootstrapRetryAttempts = 0;
+    const bootstrapRetryDelayMs = Math.max(1, params.activationBootstrapRetryDelayMs ?? ACTIVATION_BOOTSTRAP_RETRY_DELAY_MS);
+    const clearBootstrapRetry = () => {
+        if (bootstrapRetryTimer !== undefined) {
+            clearTimeout(bootstrapRetryTimer);
+            bootstrapRetryTimer = undefined;
+        }
+    };
+    const armBootstrapRetry = () => {
+        if (bootstrapRetryTimer !== undefined)
+            return;
+        if (!wsReady)
+            return;
+        if (bootstrapRetryAttempts >= ACTIVATION_BOOTSTRAP_MAX_RETRIES)
+            return;
+        bootstrapRetryTimer = setTimeout(() => {
+            bootstrapRetryTimer = undefined;
+            if (!wsReady)
+                return;
+            bootstrapRetryAttempts += 1;
+            void dispatchActivationBootstrap();
+        }, bootstrapRetryDelayMs);
+    };
     client.on("state", ({ from, to }) => {
         log?.info?.(`[${accountId}] clawchat-plugin-openclaw state ${from} -> ${to}`);
         wsReady = to === "connected";
@@ -1522,6 +1577,9 @@ export async function startOpenclawClawlingGateway(params) {
                 // The queue keeps the failed frame at the head and will retry after the next reconnect.
             }
             void refreshConversationCacheAfterReady();
+            // Fresh connection → fresh retry budget; cancel any stale timer first.
+            bootstrapRetryAttempts = 0;
+            clearBootstrapRetry();
             void dispatchActivationBootstrap();
             // Re-pull per-group agent settings on every successful (re)connect so the
             // cache stays current after a network interruption or token refresh.
@@ -1533,6 +1591,8 @@ export async function startOpenclawClawlingGateway(params) {
         }
         else if (to === "disconnected") {
             reconnectTracker.markClosed();
+            // Stop the bootstrap retry while down; it re-arms on the next ready.
+            clearBootstrapRetry();
             // §A.1 — clear the proactive timer on disconnect; it re-arms on the next
             // ready, or the gateway re-enter arms a fresh one.
             if (!reconnectWithRefreshedToken)
@@ -2389,6 +2449,7 @@ export async function startOpenclawClawlingGateway(params) {
         if (!store?.claimPendingActivationBootstrap || !store.markActivationBootstrapSent)
             return;
         let bootstrap;
+        let claimedInFlight = false;
         const releaseBootstrap = () => {
             if (!bootstrap || !store.releaseActivationBootstrapClaim)
                 return;
@@ -2401,23 +2462,34 @@ export async function startOpenclawClawlingGateway(params) {
         };
         try {
             bootstrap = recordConnection("activation bootstrap claim", () => store.claimPendingActivationBootstrap?.({ platform: "openclaw", accountId }));
-            if (!bootstrap)
+            if (!bootstrap) {
+                // Nothing claimable right now. If another dispatch (e.g. a pre-reconnect
+                // one that was about to fail) still holds the claim, keep retrying on
+                // this live connection so the greeting isn't stranded once it releases.
+                if (activationBootstrapInFlightCount(accountId) > 0)
+                    armBootstrapRetry();
                 return;
+            }
             const claimedBootstrap = bootstrap;
+            claimedInFlight = true;
+            incrementActivationBootstrapInFlight(accountId);
             bootstrapProducedFinal = false;
             const result = await handleInboundEnvelope(buildActivationBootstrapEnvelope({ account, conversationId: claimedBootstrap.conversationId }));
             if (result !== "submitted") {
                 releaseBootstrap();
+                armBootstrapRetry();
                 return;
             }
             // Only mark the bootstrap done once the agent has actually sent a greeting
             // (a final outbound message). If the turn was handed off but produced no
-            // final reply — e.g. the agent went off to write a file/note instead of
-            // replying — leave the bootstrap pending (release the claim) so the next
-            // ready re-dispatches it, rather than silently consuming it forever.
+            // final reply — e.g. the greeting send was cancelled by a reconnect, or the
+            // agent went off to write a file/note instead of replying — leave the
+            // bootstrap pending (release the claim) and retry on the live connection,
+            // rather than silently consuming it forever or waiting for the next reconnect.
             if (!bootstrapProducedFinal) {
                 log?.info?.(`[${accountId}] clawchat-plugin-openclaw activation bootstrap dispatched but produced no final reply; leaving pending for retry`);
                 releaseBootstrap();
+                armBootstrapRetry();
                 return;
             }
             recordConnection("activation bootstrap sent", () => store.markActivationBootstrapSent?.({
@@ -2425,11 +2497,18 @@ export async function startOpenclawClawlingGateway(params) {
                 accountId,
                 conversationId: claimedBootstrap.conversationId,
             }));
+            // Delivered — stop any pending retry.
+            clearBootstrapRetry();
         }
         catch (err) {
             releaseBootstrap();
+            armBootstrapRetry();
             log?.error?.(`[${accountId}] clawchat-plugin-openclaw activation bootstrap failed: ${err instanceof Error ? err.message : String(err)}`);
         }
+        finally {
+            if (claimedInFlight)
+                decrementActivationBootstrapInFlight(accountId);
+        }
     };
     client.on("message", (env) => {
         void (async () => {
@@ -2541,6 +2620,7 @@ export async function startOpenclawClawlingGateway(params) {
         log?.info?.(`[${accountId}] clawchat-plugin-openclaw runtime abort received; closing client`);
         activeClients.delete(accountId);
         closingForAbort = true;
+        clearBootstrapRetry();
         // §A.1 — stop the proactive refresh timer on shutdown.
         refreshManager.stop();
         groupCoalescer.cancelAll();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawling/clawchat-plugin-openclaw",
-  "version": "2026.6.30-2",
+  "version": "2026.6.30-3",
   "description": "OpenClaw ClawChat channel plugin",
   "license": "MIT",
   "author": "CLAWLING PTE. LTD.",

package/src/runtime.ts

@@ -120,6 +120,32 @@ export { setOpenclawClawlingRuntime, getOpenclawClawlingRuntime };
 const activeClients = new Map<string, ClawlingChatClient>();
 const CLAWCHAT_PLUGIN_SLASH_COMMANDS = new Set(["clawchat-activate", "clawchat-output"]);
 const ACTIVATION_CREDENTIAL_POLL_INTERVAL_MS = 2_000;
+// Activation-bootstrap retry on the live connection. The bootstrap greeting is
+// otherwise only (re)dispatched on a fresh `connected` edge, so if its send is
+// cancelled mid-turn (e.g. a proactive token-refresh reconnect closed the
+// transport) or a reconnect's claim no-op'd while a stale in-flight dispatch
+// still held the claim, the greeting would stay pending forever on a now-stable
+// connection. These bound an in-connection retry that re-attempts until the
+// greeting lands or the per-connection budget is spent (then it falls back to
+// the next reconnect, as before).
+const ACTIVATION_BOOTSTRAP_RETRY_DELAY_MS = 5_000;
+const ACTIVATION_BOOTSTRAP_MAX_RETRIES = 6;
+// Count of in-flight activation-bootstrap dispatches per account, shared across
+// gateway re-enters so a fresh connection can tell "nothing pending" (don't
+// retry) apart from "a prior dispatch still holds the claim" (retry once it
+// releases).
+const activationBootstrapInFlight = new Map<string, number>();
+function incrementActivationBootstrapInFlight(accountId: string): void {
+  activationBootstrapInFlight.set(accountId, (activationBootstrapInFlight.get(accountId) ?? 0) + 1);
+}
+function decrementActivationBootstrapInFlight(accountId: string): void {
+  const next = (activationBootstrapInFlight.get(accountId) ?? 0) - 1;
+  if (next <= 0) activationBootstrapInFlight.delete(accountId);
+  else activationBootstrapInFlight.set(accountId, next);
+}
+function activationBootstrapInFlightCount(accountId: string): number {
+  return activationBootstrapInFlight.get(accountId) ?? 0;
+}
 // Upper bound (ms) on how long group ingest waits for the FIRST group-settings
 // pull to settle before proceeding anyway. Best-effort governance must never
 // permanently disable group traffic, so a stalled initial GET (endpoint accepts
@@ -543,6 +569,8 @@ export interface StartGatewayParams {
   backoffTimer?: (cb: () => void, ms: number) => void;
   /** Test hook only — fixed transport-backoff delay (ms) for re-enter. */
   transportBackoffDelayMs?: number;
+  /** Test hook only — retry delay (ms) for re-dispatching a pending activation bootstrap. */
+  activationBootstrapRetryDelayMs?: number;
 }
 
 /**
@@ -1826,6 +1854,32 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
   // outbound message (the greeting). The bootstrap dispatcher reads it to decide
   // whether to mark the bootstrap sent or leave it pending for a later retry.
   let bootstrapProducedFinal = false;
+  // Per-connection retry for a pending activation bootstrap (see the module-level
+  // constants). Re-attempts on the live connection while `wsReady`, bounded by
+  // ACTIVATION_BOOTSTRAP_MAX_RETRIES; the budget resets on each fresh connect.
+  let bootstrapRetryTimer: ReturnType<typeof setTimeout> | undefined;
+  let bootstrapRetryAttempts = 0;
+  const bootstrapRetryDelayMs = Math.max(
+    1,
+    params.activationBootstrapRetryDelayMs ?? ACTIVATION_BOOTSTRAP_RETRY_DELAY_MS,
+  );
+  const clearBootstrapRetry = () => {
+    if (bootstrapRetryTimer !== undefined) {
+      clearTimeout(bootstrapRetryTimer);
+      bootstrapRetryTimer = undefined;
+    }
+  };
+  const armBootstrapRetry = () => {
+    if (bootstrapRetryTimer !== undefined) return;
+    if (!wsReady) return;
+    if (bootstrapRetryAttempts >= ACTIVATION_BOOTSTRAP_MAX_RETRIES) return;
+    bootstrapRetryTimer = setTimeout(() => {
+      bootstrapRetryTimer = undefined;
+      if (!wsReady) return;
+      bootstrapRetryAttempts += 1;
+      void dispatchActivationBootstrap();
+    }, bootstrapRetryDelayMs);
+  };
 
   client.on("state", ({ from, to }) => {
     log?.info?.(`[${accountId}] clawchat-plugin-openclaw state ${from} -> ${to}`);
@@ -1900,6 +1954,9 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
         // The queue keeps the failed frame at the head and will retry after the next reconnect.
       }
       void refreshConversationCacheAfterReady();
+      // Fresh connection → fresh retry budget; cancel any stale timer first.
+      bootstrapRetryAttempts = 0;
+      clearBootstrapRetry();
       void dispatchActivationBootstrap();
       // Re-pull per-group agent settings on every successful (re)connect so the
       // cache stays current after a network interruption or token refresh.
@@ -1910,6 +1967,8 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
       refreshManager.armProactiveTimer(activatedAtMs);
     } else if (to === "disconnected") {
       reconnectTracker.markClosed();
+      // Stop the bootstrap retry while down; it re-arms on the next ready.
+      clearBootstrapRetry();
       // §A.1 — clear the proactive timer on disconnect; it re-arms on the next
       // ready, or the gateway re-enter arms a fresh one.
       if (!reconnectWithRefreshedToken) refreshManager.disarmProactiveTimer();
@@ -2876,6 +2935,7 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
   dispatchActivationBootstrap = async (): Promise<void> => {
     if (!store?.claimPendingActivationBootstrap || !store.markActivationBootstrapSent) return;
     let bootstrap: { conversationId: string } | null | undefined;
+    let claimedInFlight = false;
     const releaseBootstrap = () => {
       if (!bootstrap || !store.releaseActivationBootstrapClaim) return;
       const claimedBootstrap = bootstrap;
@@ -2891,26 +2951,37 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
       bootstrap = recordConnection("activation bootstrap claim", () =>
         store.claimPendingActivationBootstrap?.({ platform: "openclaw", accountId }),
       );
-      if (!bootstrap) return;
+      if (!bootstrap) {
+        // Nothing claimable right now. If another dispatch (e.g. a pre-reconnect
+        // one that was about to fail) still holds the claim, keep retrying on
+        // this live connection so the greeting isn't stranded once it releases.
+        if (activationBootstrapInFlightCount(accountId) > 0) armBootstrapRetry();
+        return;
+      }
       const claimedBootstrap = bootstrap;
+      claimedInFlight = true;
+      incrementActivationBootstrapInFlight(accountId);
       bootstrapProducedFinal = false;
       const result = await handleInboundEnvelope(
         buildActivationBootstrapEnvelope({ account, conversationId: claimedBootstrap.conversationId }),
       );
       if (result !== "submitted") {
         releaseBootstrap();
+        armBootstrapRetry();
         return;
       }
       // Only mark the bootstrap done once the agent has actually sent a greeting
       // (a final outbound message). If the turn was handed off but produced no
-      // final reply — e.g. the agent went off to write a file/note instead of
-      // replying — leave the bootstrap pending (release the claim) so the next
-      // ready re-dispatches it, rather than silently consuming it forever.
+      // final reply — e.g. the greeting send was cancelled by a reconnect, or the
+      // agent went off to write a file/note instead of replying — leave the
+      // bootstrap pending (release the claim) and retry on the live connection,
+      // rather than silently consuming it forever or waiting for the next reconnect.
       if (!bootstrapProducedFinal) {
         log?.info?.(
           `[${accountId}] clawchat-plugin-openclaw activation bootstrap dispatched but produced no final reply; leaving pending for retry`,
         );
         releaseBootstrap();
+        armBootstrapRetry();
         return;
       }
       recordConnection("activation bootstrap sent", () =>
@@ -2920,11 +2991,16 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
           conversationId: claimedBootstrap.conversationId,
         }),
       );
+      // Delivered — stop any pending retry.
+      clearBootstrapRetry();
     } catch (err) {
       releaseBootstrap();
+      armBootstrapRetry();
       log?.error?.(
         `[${accountId}] clawchat-plugin-openclaw activation bootstrap failed: ${err instanceof Error ? err.message : String(err)}`,
       );
+    } finally {
+      if (claimedInFlight) decrementActivationBootstrapInFlight(accountId);
     }
   };
 
@@ -3049,6 +3125,7 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
     log?.info?.(`[${accountId}] clawchat-plugin-openclaw runtime abort received; closing client`);
     activeClients.delete(accountId);
     closingForAbort = true;
+    clearBootstrapRetry();
     // §A.1 — stop the proactive refresh timer on shutdown.
     refreshManager.stop();
     groupCoalescer.cancelAll();