@agentrux/agentrux-openclaw-plugin 0.3.5 → 0.3.7

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

@@ -286,61 +286,56 @@ function default_1(api) {
     // =======================================================================
     if (api.registrationMode !== "full")
         return;
-    // Prevent multiple ingress starts (plugin loaded multiple times by OpenClaw)
+    // Guard: prevent duplicate startup. Set to true only after successful start.
     if (globalThis.__agentruxIngressStarted)
         return;
-    globalThis.__agentruxIngressStarted = true;
-    // Clear token cache on startup to pick up latest grant scopes
-    (0, http_client_1.invalidateToken)();
     const commandTopicId = pluginConfig.commandTopicId;
     const resultTopicId = pluginConfig.resultTopicId;
     const webhookSecret = pluginConfig.webhookSecret;
     const agentId = pluginConfig.agentId;
-    // Skip ingress if not configured
+    const ingressMode = pluginConfig.ingressMode || "webhook";
     if (!commandTopicId || !resultTopicId || !agentId) {
-        logger.info?.("[agentrux] Ingress not configured (missing commandTopicId/resultTopicId/agentId). Tools-only mode.");
-        return;
-    }
-    const creds = (0, credentials_1.loadCredentials)();
-    if (!creds) {
-        logger.warn?.("[agentrux] No credentials found. Run agentrux_activate first. Ingress disabled.");
+        logger.info?.("[agentrux] Ingress not configured. Tools-only mode.");
         return;
     }
-    // Initialize components
-    const cursor = (0, cursor_1.loadCursor)();
-    const queue = new queue_1.BoundedQueue(100);
-    const dispatcher = new dispatcher_1.Dispatcher({
-        commandTopicId,
-        resultTopicId,
-        agentId,
-        maxConcurrency: pluginConfig.maxConcurrency || 3,
-        subagentTimeoutMs: pluginConfig.subagentTimeoutMs || 120_000,
-        gatewayPort: 18789, // OpenClaw default gateway port
-    }, creds, cursor, queue, logger);
-    const ingressMode = pluginConfig.ingressMode || "webhook";
-    const poller = new poller_1.SafetyPoller(creds, commandTopicId, cursor, queue, pluginConfig.pollIntervalMs || 60_000, // default 60s
-    logger);
-    // SSE listener (only when ingressMode=sse)
-    const sseListener = ingressMode === "sse"
-        ? new sse_listener_1.SSEListener(creds, commandTopicId, queue, logger)
-        : null;
-    // --- Internal dispatch endpoint (subagent.run() in Gateway request context) ---
+    // --- /agentrux/dispatch (called by Dispatcher via localhost) ---
     api.registerHttpRoute({
         path: "/agentrux/dispatch",
         auth: "plugin",
         match: "exact",
         handler: async (req, res) => {
+            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(() => { });
+            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;
-                // OpenClaw 2026.3.24+: provider/model override is not authorized
-                // for plugin subagent runs. The agent's configured model is used.
                 const { runId } = await api.runtime.subagent.run({
                     sessionKey: params.sessionKey,
                     message: params.message,
@@ -349,8 +344,7 @@ function default_1(api) {
                     ...(params.extraSystemPrompt ? { extraSystemPrompt: params.extraSystemPrompt } : {}),
                 });
                 const waitResult = await api.runtime.subagent.waitForRun({
-                    runId,
-                    timeoutMs: params.timeoutMs || 60_000,
+                    runId, timeoutMs: params.timeoutMs || 60_000,
                 });
                 let responseText = "";
                 if (waitResult.status === "ok") {
@@ -365,7 +359,9 @@ function default_1(api) {
                         }
                     }
                 }
-                // Collect attachments uploaded during this run
+                else {
+                    responseText = waitResult.error || waitResult.message || `Agent failed: ${waitResult.status}`;
+                }
                 const attachments = consumeAttachments(params.sessionKey);
                 activeSessionKey = null;
                 res.statusCode = 200;
@@ -382,30 +378,58 @@ function default_1(api) {
             return true;
         },
     });
-    // --- Webhook endpoint (only when ingressMode=webhook) ---
-    if (ingressMode === "webhook" && webhookSecret) {
-        api.registerHttpRoute({
-            path: "/agentrux/webhook",
-            auth: "plugin",
-            match: "exact",
-            handler: (0, webhook_handler_1.createWebhookHandler)(queue, webhookSecret, commandTopicId),
-        });
-        logger.info?.("[agentrux] Webhook endpoint registered: /agentrux/webhook");
-    }
-    else if (ingressMode === "webhook" && !webhookSecret) {
-        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.
+    // --- Async startup: credentials → construct → start ---
     (async () => {
         try {
+            // 1. Credentials: load or auto-activate
+            (0, http_client_1.invalidateToken)();
+            let creds = (0, credentials_1.loadCredentials)();
+            if (!creds) {
+                const activationCode = pluginConfig.activationCode;
+                if (!activationCode) {
+                    logger.warn?.("[agentrux] No credentials and no activationCode. Ingress disabled.");
+                    return;
+                }
+                logger.info?.("[agentrux] Auto-activating...");
+                const baseUrl = pluginConfig.baseUrl || "https://api.agentrux.com";
+                const r = await (0, http_client_1.httpJson)("POST", `${baseUrl}/auth/activate`, { activation_code: activationCode });
+                if (r.status !== 200 || !r.data.script_id) {
+                    logger.error?.(`[agentrux] Auto-activation failed (HTTP ${r.status}): ${JSON.stringify(r.data)}`);
+                    return;
+                }
+                creds = { base_url: baseUrl, script_id: r.data.script_id, clientSecret: r.data.client_secret };
+                (0, credentials_1.saveCredentials)(creds);
+                credentials = creds;
+                logger.info?.(`[agentrux] Activated: script_id=${r.data.script_id}`);
+            }
+            // 2. Construct
+            const cursor = (0, cursor_1.loadCursor)();
+            const queue = new queue_1.BoundedQueue(100);
+            const dispatcher = new dispatcher_1.Dispatcher({
+                commandTopicId, resultTopicId, agentId,
+                maxConcurrency: pluginConfig.maxConcurrency || 3,
+                subagentTimeoutMs: pluginConfig.subagentTimeoutMs || 120_000,
+                gatewayPort: 18789,
+                publishProcessingStatus: !!pluginConfig.publishProcessingStatus,
+            }, creds, cursor, queue, logger);
+            const poller = new poller_1.SafetyPoller(creds, commandTopicId, cursor, queue, pluginConfig.pollIntervalMs || 60_000, logger);
+            const sseListener = ingressMode === "sse"
+                ? new sse_listener_1.SSEListener(creds, commandTopicId, queue, logger) : null;
+            // Webhook (only if configured)
+            if (ingressMode === "webhook" && webhookSecret) {
+                api.registerHttpRoute({
+                    path: "/agentrux/webhook", auth: "plugin", match: "exact",
+                    handler: (0, webhook_handler_1.createWebhookHandler)(queue, webhookSecret, commandTopicId),
+                });
+            }
+            // 3. Wait for Gateway
             await waitForGateway(18789, 30_000, logger);
+            // 4. Start
             dispatcher.start().catch((e) => logger.error("[agentrux] Dispatcher failed:", e));
-            if (sseListener) {
+            if (sseListener)
                 sseListener.start().catch((e) => logger.error("[agentrux] SSE failed:", e));
-            }
             poller.start().catch((e) => logger.error("[agentrux] Poller failed:", e));
+            globalThis.__agentruxIngressStarted = true;
             logger.info(`[agentrux] Ingress started: mode=${ingressMode} topic=${commandTopicId} agent=${agentId} poll@${pluginConfig.pollIntervalMs || 60000}ms`);
         }
         catch (e) {
@@ -418,7 +442,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();
@@ -430,5 +454,5 @@ async function waitForGateway(port, timeoutMs, logger) {
             await new Promise((r) => setTimeout(r, 2000));
         }
     }
-    logger.warn("[agentrux] Gateway readiness timeout — starting Dispatcher anyway");
+    logger.warn("[agentrux] Gateway readiness timeout — starting anyway");
 }

package/package.json

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