@agentrux/agentrux-openclaw-plugin 0.3.4 → 0.3.5

package/README.md

@@ -2,7 +2,7 @@
 
 Connect your OpenClaw agent to other agents via AgenTrux — authenticated Pub/Sub for autonomous agents.
 
-**v0.3.3**: Ingress mode with image attachments, auto topic resolution for uploads, SSE/webhook dual support.
+**v0.3.4**: Ingress mode with image attachments, auto topic resolution for uploads, SSE/webhook dual support.
 
 ## Install
 
@@ -10,7 +10,7 @@ Connect your OpenClaw agent to other agents via AgenTrux — authenticated Pub/S
 > config 未設定だと OpenClaw CLI がロードエラーで停止します。
 
 ```bash
-openclaw plugins install @agentrux/agentrux-openclaw-plugin@0.3.3
+openclaw plugins install @agentrux/agentrux-openclaw-plugin@0.3.4
 ```
 
 ## Quick Start

package/dist/__tests__/dispatcher.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Dispatcher transient error handling tests.
+ *
+ * Verifies:
+ * 1. Transport retry: callDispatchEndpoint retries on transient errors
+ * 2. Transient drop: transport failure after retries does NOT write to outbox
+ * 3. Application failure: non-transport errors still write to outbox (existing behavior)
+ * 4. isTransientError classification
+ */
+export {};

package/dist/__tests__/dispatcher.test.js

@@ -0,0 +1,232 @@
+"use strict";
+/**
+ * Dispatcher transient error handling tests.
+ *
+ * Verifies:
+ * 1. Transport retry: callDispatchEndpoint retries on transient errors
+ * 2. Transient drop: transport failure after retries does NOT write to outbox
+ * 3. Application failure: non-transport errors still write to outbox (existing behavior)
+ * 4. isTransientError classification
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const http = __importStar(require("http"));
+// --- isTransientError (extracted for testing) ---
+function isTransientError(e) {
+    const code = e?.code;
+    if (code && ["ECONNREFUSED", "ETIMEDOUT", "ECONNRESET", "EHOSTUNREACH"].includes(code)) {
+        return true;
+    }
+    const msg = e?.message || "";
+    return msg.includes("socket hang up") || msg.includes("Dispatch timeout");
+}
+describe("isTransientError", () => {
+    test("ECONNREFUSED → transient", () => {
+        const e = new Error("connect ECONNREFUSED 127.0.0.1:18789");
+        e.code = "ECONNREFUSED";
+        expect(isTransientError(e)).toBe(true);
+    });
+    test("ETIMEDOUT → transient", () => {
+        const e = new Error("connect ETIMEDOUT");
+        e.code = "ETIMEDOUT";
+        expect(isTransientError(e)).toBe(true);
+    });
+    test("ECONNRESET → transient", () => {
+        const e = new Error("read ECONNRESET");
+        e.code = "ECONNRESET";
+        expect(isTransientError(e)).toBe(true);
+    });
+    test("EHOSTUNREACH → transient", () => {
+        const e = new Error("connect EHOSTUNREACH");
+        e.code = "EHOSTUNREACH";
+        expect(isTransientError(e)).toBe(true);
+    });
+    test("socket hang up → transient", () => {
+        expect(isTransientError(new Error("socket hang up"))).toBe(true);
+    });
+    test("Dispatch timeout → transient", () => {
+        expect(isTransientError(new Error("Dispatch timeout"))).toBe(true);
+    });
+    test("JSON parse error → NOT transient", () => {
+        expect(isTransientError(new Error("Dispatch response parse error: <html>"))).toBe(false);
+    });
+    test("generic Error → NOT transient", () => {
+        expect(isTransientError(new Error("something unexpected"))).toBe(false);
+    });
+    test("null/undefined → NOT transient", () => {
+        expect(isTransientError(null)).toBe(false);
+        expect(isTransientError(undefined)).toBe(false);
+    });
+});
+// --- Transport retry integration test ---
+describe("callDispatchEndpoint transport retry", () => {
+    test("retries on ECONNREFUSED then succeeds", async () => {
+        let requestCount = 0;
+        const PORT = 19876;
+        let server;
+        // _doDispatchRequest equivalent
+        function doRequest() {
+            return new Promise((resolve, reject) => {
+                const body = JSON.stringify({ sessionKey: "test", message: "hi", idempotencyKey: "k1", timeoutMs: 5000 });
+                const req = http.request({ hostname: "127.0.0.1", port: PORT, path: "/agentrux/dispatch", method: "POST",
+                    headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) }, timeout: 5000 }, (res) => {
+                    let raw = "";
+                    res.on("data", (c) => (raw += c.toString()));
+                    res.on("end", () => { try {
+                        resolve(JSON.parse(raw));
+                    }
+                    catch {
+                        reject(new Error("parse error"));
+                    } });
+                });
+                req.on("error", reject);
+                req.on("timeout", () => { req.destroy(); reject(new Error("Dispatch timeout")); });
+                req.write(body);
+                req.end();
+            });
+        }
+        // Retry wrapper (mirrors callDispatchEndpoint)
+        async function callWithRetry() {
+            const MAX = 3;
+            const BASE = 200; // shorter for test
+            for (let attempt = 0; attempt < MAX; attempt++) {
+                try {
+                    return await doRequest();
+                }
+                catch (e) {
+                    if (isTransientError(e) && attempt < MAX - 1) {
+                        await new Promise((r) => setTimeout(r, BASE * Math.pow(2, attempt)));
+                        continue;
+                    }
+                    throw e;
+                }
+            }
+            throw new Error("max retries");
+        }
+        // Start server after 300ms (1st attempt fails, 2nd succeeds)
+        setTimeout(() => {
+            server = http.createServer((req, res) => {
+                requestCount++;
+                let body = "";
+                req.on("data", (c) => (body += c));
+                req.on("end", () => {
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ responseText: "ok", status: "ok" }));
+                });
+            });
+            server.listen(PORT);
+        }, 300);
+        const result = await callWithRetry();
+        expect(result.status).toBe("ok");
+        expect(requestCount).toBe(1);
+        await new Promise((resolve) => server.close(() => resolve()));
+    }, 15000);
+    test("all retries fail → throws transient error", async () => {
+        // Simulate 3 ECONNREFUSED failures without real sockets
+        let attempts = 0;
+        async function fakeRequest() {
+            attempts++;
+            const e = new Error("connect ECONNREFUSED 127.0.0.1:19877");
+            e.code = "ECONNREFUSED";
+            throw e;
+        }
+        async function callWithRetry() {
+            const MAX = 3;
+            const BASE = 50; // short for test
+            for (let attempt = 0; attempt < MAX; attempt++) {
+                try {
+                    return await fakeRequest();
+                }
+                catch (e) {
+                    if (isTransientError(e) && attempt < MAX - 1) {
+                        await new Promise((r) => setTimeout(r, BASE));
+                        continue;
+                    }
+                    throw e;
+                }
+            }
+        }
+        let threw = false;
+        try {
+            await callWithRetry();
+        }
+        catch (e) {
+            threw = true;
+            expect(isTransientError(e)).toBe(true);
+        }
+        expect(threw).toBe(true);
+        expect(attempts).toBe(3); // all 3 attempts made
+    }, 10000);
+});
+// --- Transient vs Application error routing ---
+describe("processEvent error routing", () => {
+    test("transient error should NOT produce outbox entry", () => {
+        // Simulate the decision logic from processEvent catch block
+        const e = new Error("connect ECONNREFUSED 127.0.0.1:18789");
+        e.code = "ECONNREFUSED";
+        let outboxWritten = false;
+        let eventRecorded = false;
+        let completed = false;
+        if (isTransientError(e)) {
+            // Transport failure path: drop event
+            completed = true;
+            // outboxWritten stays false
+            // eventRecorded stays false
+        }
+        else {
+            outboxWritten = true;
+            eventRecorded = true;
+        }
+        expect(outboxWritten).toBe(false);
+        expect(eventRecorded).toBe(false);
+        expect(completed).toBe(true);
+    });
+    test("application error SHOULD produce outbox entry", () => {
+        const e = new Error("Subagent execution failed");
+        let outboxWritten = false;
+        let eventRecorded = false;
+        let completed = false;
+        if (isTransientError(e)) {
+            completed = true;
+        }
+        else {
+            outboxWritten = true;
+            eventRecorded = true;
+        }
+        expect(outboxWritten).toBe(true);
+        expect(eventRecorded).toBe(true);
+        expect(completed).toBe(false);
+    });
+});

package/dist/dispatcher.d.ts

@@ -35,4 +35,5 @@ export declare class Dispatcher {
     private tick;
     private processEvent;
     private callDispatchEndpoint;
+    private _doDispatchRequest;
 }

package/dist/dispatcher.js

@@ -220,23 +220,61 @@ class Dispatcher {
             this.logger.info(`Outboxed: seq=${seq} requestId=${requestId}`);
         }
         catch (e) {
-            this.logger.error(`Event processing failed: seq=${seq} error=${e.message}`);
-            (0, outbox_1.addToOutbox)({
-                eventId,
-                requestId,
-                sequenceNo: seq,
-                result: {
-                    message: `Agent error: ${e.message}`,
-                    status: "failed",
-                },
-            });
-            (0, cursor_1.recordProcessedEvent)(this.cursor, eventId);
+            if (isTransientError(e)) {
+                // Transport failure: Gateway に届かなかった。
+                // outbox に書かない → findByRequestId で後続をブロックしない。
+                // recordProcessedEvent しない → event_id dedup で後続をブロックしない。
+                // markCompleted で waterline を進める → このイベントはドロップ。
+                this.logger.error(`Transport failed after retries, dropping: seq=${seq} error=${e.message}`);
+                (0, cursor_1.markCompleted)(this.cursor, seq);
+                try {
+                    await (0, http_client_1.publishEvent)(this.creds, this.config.resultTopicId, "openclaw.status", {
+                        request_id: requestId,
+                        status: "dropped",
+                        error: e.message,
+                    });
+                }
+                catch { }
+            }
+            else {
+                // Application failure: Gateway に届いた上でのエラー → 既存処理
+                this.logger.error(`Event processing failed: seq=${seq} error=${e.message}`);
+                (0, outbox_1.addToOutbox)({
+                    eventId,
+                    requestId,
+                    sequenceNo: seq,
+                    result: {
+                        message: `Agent error: ${e.message}`,
+                        status: "failed",
+                    },
+                });
+                (0, cursor_1.recordProcessedEvent)(this.cursor, eventId);
+            }
         }
         finally {
             this.processingSeqs.delete(seq);
         }
     }
-    callDispatchEndpoint(params) {
+    async callDispatchEndpoint(params) {
+        const MAX_TRANSPORT_RETRIES = 3;
+        const RETRY_BASE_MS = 2000;
+        for (let attempt = 0; attempt < MAX_TRANSPORT_RETRIES; attempt++) {
+            try {
+                return await this._doDispatchRequest(params);
+            }
+            catch (e) {
+                if (isTransientError(e) && attempt < MAX_TRANSPORT_RETRIES - 1) {
+                    const delay = RETRY_BASE_MS * Math.pow(2, attempt);
+                    this.logger.warn(`Dispatch transport retry ${attempt + 1}/${MAX_TRANSPORT_RETRIES} in ${delay}ms: ${e.message}`);
+                    await sleep(delay);
+                    continue;
+                }
+                throw e;
+            }
+        }
+        throw new Error("Dispatch: max transport retries exceeded");
+    }
+    _doDispatchRequest(params) {
         return new Promise((resolve, reject) => {
             const body = JSON.stringify(params);
             const req = http.request({
@@ -269,3 +307,12 @@ exports.Dispatcher = Dispatcher;
 function sleep(ms) {
     return new Promise((r) => setTimeout(r, ms));
 }
+/** Transport-layer errors: Gateway に届かなかった場合のみ true */
+function isTransientError(e) {
+    const code = e?.code;
+    if (code && ["ECONNREFUSED", "ETIMEDOUT", "ECONNRESET", "EHOSTUNREACH"].includes(code)) {
+        return true;
+    }
+    const msg = e?.message || "";
+    return msg.includes("socket hang up") || msg.includes("Dispatch timeout");
+}

package/dist/index.js

@@ -396,8 +396,11 @@ function default_1(api) {
         logger.warn?.("[agentrux] ingressMode=webhook but webhookSecret not set. Falling back to poll-only.");
     }
     // --- Start Dispatcher + (Webhook|SSE) + Poller ---
-    setTimeout(() => {
+    // Gateway readiness probe: wait until /agentrux/dispatch is reachable
+    // before starting Dispatcher. Prevents startup ECONNREFUSED from dropping events.
+    (async () => {
         try {
+            await waitForGateway(18789, 30_000, logger);
             dispatcher.start().catch((e) => logger.error("[agentrux] Dispatcher failed:", e));
             if (sseListener) {
                 sseListener.start().catch((e) => logger.error("[agentrux] SSE failed:", e));
@@ -408,5 +411,24 @@ function default_1(api) {
         catch (e) {
             logger.error("[agentrux] Ingress startup error:", e);
         }
-    }, 5000);
+    })();
+}
+async function waitForGateway(port, timeoutMs, logger) {
+    const start = Date.now();
+    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(); });
+                req.on("error", reject);
+                req.on("timeout", () => { req.destroy(); reject(new Error("timeout")); });
+                req.end();
+            });
+            logger.info("[agentrux] Gateway is ready");
+            return;
+        }
+        catch {
+            await new Promise((r) => setTimeout(r, 2000));
+        }
+    }
+    logger.warn("[agentrux] Gateway readiness timeout — starting Dispatcher anyway");
 }

package/package.json

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