@agentrux/agentrux-openclaw-plugin 0.3.5 → 0.3.6

package/dist/dispatcher.d.ts

@@ -12,6 +12,8 @@ export interface DispatcherConfig {
     maxConcurrency: number;
     subagentTimeoutMs: number;
     gatewayPort: number;
+    /** Publish "processing" status to result topic before dispatch. Debug/dev only. */
+    publishProcessingStatus?: boolean;
 }
 export declare class Dispatcher {
     private config;
@@ -23,7 +25,6 @@ export declare class Dispatcher {
     private stopped;
     private processedRequestIds;
     private processingSeqs;
-    private statusPublished;
     constructor(config: DispatcherConfig, creds: Credentials, cursor: CursorState, queue: BoundedQueue, logger: {
         info: (...a: any[]) => void;
         error: (...a: any[]) => void;

package/dist/dispatcher.js

@@ -57,36 +57,24 @@ class Dispatcher {
         // In-memory dedup: prevents same seq/request from being processed twice
         this.processedRequestIds = new Set();
         this.processingSeqs = new Set();
-        // Status publish tracking: only publish "processing" once per request
-        this.statusPublished = new Set();
     }
     async start() {
         if (this.running)
             throw new Error("Dispatcher already running");
         this.running = true;
         this.stopped = false;
-        // Crash recovery: re-enqueue inFlight seqs from previous run
-        // NOTE: do NOT clear inFlight here — they stay in-flight until processEvent
-        // completes and the outbox flush finalizes them via markCompleted.
+        // Crash recovery: clear ALL inFlight seqs by marking them completed.
+        // Rationale: Dispatcher is a part, not an orchestrator. If a crash interrupted
+        // processing, we drop those events rather than risk an infinite restart cycle.
+        // The alternative (re-enqueueing) can loop forever if processEvent's dedup
+        // (processedEvents/findByRequestId) blocks the re-enqueued event before
+        // markCompleted is reached, leaving inFlight permanently dirty.
         if (this.cursor.inFlight.size > 0) {
-            this.logger.info(`Crash recovery: re-enqueueing ${this.cursor.inFlight.size} in-flight seqs`);
-            const recovered = [];
-            for (const seq of this.cursor.inFlight) {
-                const ok = this.queue.enqueue({
-                    topicId: this.config.commandTopicId,
-                    latestSequenceNo: seq,
-                    timestamp: Date.now(),
-                });
-                if (ok)
-                    recovered.push(seq);
-            }
-            // Only remove from inFlight the ones we failed to enqueue (queue full)
-            // The successfully enqueued ones will be cleared by processEvent → markCompleted
-            for (const seq of this.cursor.inFlight) {
-                if (!recovered.includes(seq)) {
-                    this.logger.warn(`Crash recovery: could not re-enqueue seq=${seq} (queue full)`);
-                }
+            this.logger.warn(`Crash recovery: clearing ${this.cursor.inFlight.size} stale in-flight seqs`);
+            for (const seq of [...this.cursor.inFlight]) {
+                (0, cursor_1.markCompleted)(this.cursor, seq);
             }
+            this.logger.info("Crash recovery: all stale in-flight seqs cleared");
         }
         this.loop();
     }
@@ -112,17 +100,42 @@ class Dispatcher {
     async tick() {
         // 1. Dequeue hints
         const hints = this.queue.dequeue(this.config.maxConcurrency);
-        // 2. Pull full events for hints
-        if (hints.length > 0) {
-            const events = await (0, http_client_1.pullEvents)(this.creds, this.config.commandTopicId, this.cursor.waterline, 50);
-            for (const evt of events) {
-                await this.processEvent(evt);
+        // 2. Pull + process events (errors must NOT prevent step 3 outbox flush)
+        try {
+            if (hints.length > 0) {
+                const events = await (0, http_client_1.pullEvents)(this.creds, this.config.commandTopicId, this.cursor.waterline, 50);
+                for (const evt of events) {
+                    try {
+                        await this.processEvent(evt);
+                    }
+                    catch (e) {
+                        // Safety net: force-complete to prevent waterline stall
+                        const seq = evt.sequence_no;
+                        this.logger.error(`processEvent unexpected error, force-completing seq=${seq}: ${e.message}`);
+                        try {
+                            (0, cursor_1.markCompleted)(this.cursor, seq);
+                        }
+                        catch { }
+                        this.processingSeqs.delete(seq);
+                    }
+                }
             }
         }
-        // 3. Flush outbox (always, regardless of hints)
-        const finalized = await (0, outbox_1.flushOutbox)(this.creds, this.config.resultTopicId, this.logger);
-        for (const seq of finalized) {
-            (0, cursor_1.markCompleted)(this.cursor, seq);
+        catch (e) {
+            // pullEvents failed (network error, auth error, etc.)
+            // Log but continue to step 3 — outbox flush must always run
+            this.logger.error(`Pull failed: ${e.message}`);
+        }
+        // 3. Flush outbox — MUST always run, even if pull/processEvent failed above.
+        // This is the only path that finalizes outboxed seqs → markCompleted → waterline advance.
+        try {
+            const finalized = await (0, outbox_1.flushOutbox)(this.creds, this.config.resultTopicId, this.logger);
+            for (const seq of finalized) {
+                (0, cursor_1.markCompleted)(this.cursor, seq);
+            }
+        }
+        catch (e) {
+            this.logger.error(`Outbox flush failed: ${e.message}`);
         }
         // 4. Periodic cleanup (every ~50 ticks)
         if (Math.random() < 0.02) {
@@ -132,9 +145,6 @@ class Dispatcher {
             if (this.processedRequestIds.size > 10_000) {
                 this.processedRequestIds.clear();
             }
-            if (this.statusPublished.size > 10_000) {
-                this.statusPublished.clear();
-            }
         }
     }
     async processEvent(evt) {
@@ -151,8 +161,13 @@ class Dispatcher {
         // but allow re-processing for crash recovery (inFlight from previous run)
         if (this.cursor.inFlight.has(seq) && this.processingSeqs.has(seq))
             return;
-        if ((0, cursor_1.isEventProcessed)(this.cursor, eventId))
+        if ((0, cursor_1.isEventProcessed)(this.cursor, eventId)) {
+            // Event already processed — markCompleted to prevent waterline stall.
+            // Without this, a seq stuck at waterline+1 with processedEvents=true
+            // would block all subsequent events forever.
+            (0, cursor_1.markCompleted)(this.cursor, seq);
             return;
+        }
         const payload = evt.payload || {};
         const requestId = payload.request_id || eventId;
         // ---- DEDUP LAYER 2: Application (request_id) ----
@@ -180,9 +195,8 @@ class Dispatcher {
             const wrappedMessage = (0, sanitize_1.wrapMessage)(messageText);
             const idempotencyKey = crypto.randomUUID();
             this.logger.info(`Processing: seq=${seq} requestId=${requestId}`);
-            // Publish "processing" status ONCE per request
-            if (!this.statusPublished.has(requestId)) {
-                this.statusPublished.add(requestId);
+            // Optional: publish "processing" status (debug/dev only)
+            if (this.config.publishProcessingStatus) {
                 try {
                     await (0, http_client_1.publishEvent)(this.creds, this.config.resultTopicId, "openclaw.status", {
                         request_id: requestId,
@@ -209,7 +223,7 @@ class Dispatcher {
                 requestId,
                 sequenceNo: seq,
                 result: {
-                    message: (0, sanitize_1.sanitizeResponse)(responseText || "No response from agent"),
+                    message: (0, sanitize_1.sanitizeResponse)(responseText || dispatchResult.error || ""),
                     status: dispatchResult.status === "ok" ? "completed" : "failed",
                     conversationKey,
                     ...(attachments.length > 0 ? { attachments } : {}),

package/dist/index.js

@@ -330,12 +330,37 @@ function default_1(api) {
         auth: "plugin",
         match: "exact",
         handler: async (req, res) => {
+            // Reject non-POST (e.g. HEAD from readiness probe)
+            if (req.method !== "POST") {
+                res.statusCode = 405;
+                res.setHeader("Allow", "POST");
+                res.setHeader("Content-Type", "application/json");
+                res.end('{"error":"method not allowed"}');
+                return true;
+            }
             const chunks = [];
-            await new Promise((resolve) => {
+            await new Promise((resolve, reject) => {
                 req.on("data", (c) => chunks.push(c));
                 req.on("end", resolve);
-            });
-            const params = JSON.parse(Buffer.concat(chunks).toString());
+                req.on("error", reject);
+            }).catch(() => { }); // aborted/truncated request → empty body → 400 below
+            const raw = Buffer.concat(chunks).toString();
+            if (!raw) {
+                res.statusCode = 400;
+                res.setHeader("Content-Type", "application/json");
+                res.end('{"error":"empty body"}');
+                return true;
+            }
+            let params;
+            try {
+                params = JSON.parse(raw);
+            }
+            catch (e) {
+                res.statusCode = 400;
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({ error: "invalid JSON", detail: e.message }));
+                return true;
+            }
             try {
                 // Track active session for attachment registry
                 activeSessionKey = params.sessionKey;
@@ -365,6 +390,10 @@ function default_1(api) {
                         }
                     }
                 }
+                else {
+                    // Subagent failed (rate limit, timeout, etc.) — include reason in response
+                    responseText = waitResult.error || waitResult.message || `Agent failed: ${waitResult.status}`;
+                }
                 // Collect attachments uploaded during this run
                 const attachments = consumeAttachments(params.sessionKey);
                 activeSessionKey = null;
@@ -396,8 +425,9 @@ function default_1(api) {
         logger.warn?.("[agentrux] ingressMode=webhook but webhookSecret not set. Falling back to poll-only.");
     }
     // --- Start Dispatcher + (Webhook|SSE) + Poller ---
-    // Gateway readiness probe: wait until /agentrux/dispatch is reachable
-    // before starting Dispatcher. Prevents startup ECONNREFUSED from dropping events.
+    // Gateway readiness probe: wait until /health responds.
+    // Even if /health comes up before plugin routes, the transport retry
+    // in callDispatchEndpoint (3 attempts, 2s/4s backoff) covers the gap.
     (async () => {
         try {
             await waitForGateway(18789, 30_000, logger);
@@ -418,7 +448,7 @@ async function waitForGateway(port, timeoutMs, logger) {
     while (Date.now() - start < timeoutMs) {
         try {
             await new Promise((resolve, reject) => {
-                const req = require("http").request({ hostname: "127.0.0.1", port, path: "/agentrux/dispatch", method: "HEAD", timeout: 2000 }, (res) => { res.resume(); resolve(); });
+                const req = require("http").request({ hostname: "127.0.0.1", port, path: "/health", method: "GET", timeout: 2000 }, (res) => { res.resume(); resolve(); });
                 req.on("error", reject);
                 req.on("timeout", () => { req.destroy(); reject(new Error("timeout")); });
                 req.end();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentrux/agentrux-openclaw-plugin",
-  "version": "0.3.5",
+  "version": "0.3.6",
   "description": "OpenClaw plugin for AgenTrux — Agent-to-Agent authenticated Pub/Sub",
   "keywords": [
     "openclaw",