@agentrux/agentrux-openclaw-plugin 0.3.2

package/dist/dispatcher.js

@@ -0,0 +1,266 @@
+"use strict";
+/**
+ * Dispatcher: async loop.
+ * Consumes queue → Pull → dedup → subagent.run() → outbox → waterline.
+ */
+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 });
+exports.Dispatcher = void 0;
+const crypto = __importStar(require("crypto"));
+const http = __importStar(require("http"));
+const http_client_1 = require("./http-client");
+const cursor_1 = require("./cursor");
+const outbox_1 = require("./outbox");
+const session_1 = require("./session");
+const sanitize_1 = require("./sanitize");
+class Dispatcher {
+    constructor(config, creds, cursor, queue, logger) {
+        this.config = config;
+        this.creds = creds;
+        this.cursor = cursor;
+        this.queue = queue;
+        this.logger = logger;
+        this.running = false;
+        this.stopped = false;
+        // 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.
+        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.loop();
+    }
+    stop() {
+        this.stopped = true;
+    }
+    async loop() {
+        try {
+            while (!this.stopped) {
+                try {
+                    await this.tick();
+                }
+                catch (e) {
+                    this.logger.error("Dispatcher tick error:", e.message);
+                }
+                await sleep(500); // 500ms between ticks (reduce CPU)
+            }
+        }
+        finally {
+            this.running = false;
+        }
+    }
+    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);
+            }
+        }
+        // 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);
+        }
+        // 4. Periodic cleanup (every ~50 ticks)
+        if (Math.random() < 0.02) {
+            (0, cursor_1.cleanupExpiredEvents)(this.cursor);
+            (0, cursor_1.persistCursor)(this.cursor);
+            // Cap in-memory sets
+            if (this.processedRequestIds.size > 10_000) {
+                this.processedRequestIds.clear();
+            }
+            if (this.statusPublished.size > 10_000) {
+                this.statusPublished.clear();
+            }
+        }
+    }
+    async processEvent(evt) {
+        const seq = evt.sequence_no;
+        const eventId = evt.event_id;
+        // ---- DEDUP LAYER 1: Transport (seq + event_id) ----
+        if (seq <= this.cursor.waterline)
+            return;
+        if (this.cursor.completed.has(seq))
+            return;
+        if (this.processingSeqs.has(seq))
+            return;
+        // inFlight check: skip if already being processed concurrently,
+        // 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))
+            return;
+        const payload = evt.payload || {};
+        const requestId = payload.request_id || eventId;
+        // ---- DEDUP LAYER 2: Application (request_id) ----
+        if (this.processedRequestIds.has(requestId)) {
+            // Already processed in this session — just advance cursor
+            (0, cursor_1.markCompleted)(this.cursor, seq);
+            return;
+        }
+        const existingOutbox = (0, outbox_1.findByRequestId)(requestId);
+        if (existingOutbox) {
+            (0, cursor_1.markCompleted)(this.cursor, seq);
+            return;
+        }
+        // ---- LOCK ----
+        this.processingSeqs.add(seq);
+        this.processedRequestIds.add(requestId);
+        (0, cursor_1.markInFlight)(this.cursor, seq);
+        // NOTE: recordProcessedEvent is deferred until durable completion (outbox write)
+        try {
+            const messageText = payload.message || payload.text || JSON.stringify(payload);
+            const conversationKey = payload.conversation_key
+                ? (0, session_1.validateConversationKey)(payload.conversation_key)
+                : "default";
+            const sessionKey = (0, session_1.buildSessionKey)(this.config.agentId, this.config.commandTopicId, conversationKey);
+            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);
+                try {
+                    await (0, http_client_1.publishEvent)(this.creds, this.config.resultTopicId, "openclaw.status", {
+                        request_id: requestId,
+                        status: "processing",
+                    });
+                }
+                catch { }
+            }
+            // Call internal dispatch endpoint
+            const dispatchResult = await this.callDispatchEndpoint({
+                sessionKey,
+                message: wrappedMessage,
+                idempotencyKey,
+                timeoutMs: this.config.subagentTimeoutMs,
+            });
+            const responseText = dispatchResult.responseText || "";
+            // Add to outbox (waterline is NOT advanced here — outbox flush owns that)
+            (0, outbox_1.addToOutbox)({
+                eventId,
+                requestId,
+                sequenceNo: seq,
+                result: {
+                    message: (0, sanitize_1.sanitizeResponse)(responseText || "No response from agent"),
+                    status: dispatchResult.status === "ok" ? "completed" : "failed",
+                    conversationKey,
+                },
+            });
+            // Record processed event AFTER durable outbox write
+            (0, cursor_1.recordProcessedEvent)(this.cursor, eventId);
+            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);
+        }
+        finally {
+            this.processingSeqs.delete(seq);
+        }
+    }
+    callDispatchEndpoint(params) {
+        return new Promise((resolve, reject) => {
+            const body = JSON.stringify(params);
+            const req = http.request({
+                hostname: "127.0.0.1",
+                port: this.config.gatewayPort,
+                path: "/agentrux/dispatch",
+                method: "POST",
+                headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) },
+                timeout: params.timeoutMs + 10_000,
+            }, (res) => {
+                let raw = "";
+                res.on("data", (c) => (raw += c.toString()));
+                res.on("end", () => {
+                    try {
+                        resolve(JSON.parse(raw));
+                    }
+                    catch {
+                        reject(new Error(`Dispatch response parse error: ${raw.slice(0, 200)}`));
+                    }
+                });
+            });
+            req.on("error", reject);
+            req.on("timeout", () => { req.destroy(); reject(new Error("Dispatch timeout")); });
+            req.write(body);
+            req.end();
+        });
+    }
+}
+exports.Dispatcher = Dispatcher;
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}

package/dist/http-client.d.ts

@@ -0,0 +1,22 @@
+/**
+ * AgenTrux HTTP client — no external dependencies.
+ * Handles JWT auth with auto-refresh.
+ */
+import { type Credentials } from "./credentials";
+export declare function httpJson(method: string, url: string, body?: Record<string, unknown>, headers?: Record<string, string>): Promise<{
+    status: number;
+    data: any;
+}>;
+export declare function ensureToken(creds: Credentials): Promise<string>;
+export declare function invalidateToken(): void;
+export declare function authRequest(creds: Credentials, method: string, urlPath: string, body?: Record<string, unknown>): Promise<any>;
+export declare function pullEvents(creds: Credentials, topicId: string, afterSeq: number, limit?: number): Promise<any[]>;
+export declare function publishEvent(creds: Credentials, topicId: string, eventType: string, payload: Record<string, unknown>): Promise<string>;
+/**
+ * Upload a file to AgenTrux via presigned URL.
+ * Returns { object_id, download_url } for attaching to events.
+ */
+export declare function uploadFile(creds: Credentials, topicId: string, filePath: string, contentType: string): Promise<{
+    object_id: string;
+    download_url: string;
+}>;

package/dist/http-client.js

@@ -0,0 +1,204 @@
+"use strict";
+/**
+ * AgenTrux HTTP client — no external dependencies.
+ * Handles JWT auth with auto-refresh.
+ */
+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 });
+exports.httpJson = httpJson;
+exports.ensureToken = ensureToken;
+exports.invalidateToken = invalidateToken;
+exports.authRequest = authRequest;
+exports.pullEvents = pullEvents;
+exports.publishEvent = publishEvent;
+exports.uploadFile = uploadFile;
+const https = __importStar(require("https"));
+const http = __importStar(require("http"));
+// ---------------------------------------------------------------------------
+// HTTP helper
+// ---------------------------------------------------------------------------
+function httpJson(method, url, body, headers) {
+    return new Promise((resolve, reject) => {
+        const u = new URL(url);
+        const mod = u.protocol === "https:" ? https : http;
+        const opts = {
+            method,
+            hostname: u.hostname,
+            port: u.port,
+            path: u.pathname + u.search,
+            headers: {
+                "Content-Type": "application/json",
+                ...headers,
+            },
+        };
+        const req = mod.request(opts, (res) => {
+            let raw = "";
+            res.on("data", (c) => (raw += c.toString()));
+            res.on("end", () => {
+                try {
+                    resolve({ status: res.statusCode || 0, data: JSON.parse(raw) });
+                }
+                catch {
+                    resolve({ status: res.statusCode || 0, data: raw });
+                }
+            });
+        });
+        req.on("error", reject);
+        if (body)
+            req.write(JSON.stringify(body));
+        req.end();
+    });
+}
+let tokenState = null;
+async function ensureToken(creds) {
+    // Valid token with 60s buffer
+    if (tokenState && tokenState.expires_at > Date.now() + 60_000) {
+        return tokenState.access_token;
+    }
+    // Try refresh
+    if (tokenState?.refresh_token) {
+        const r = await httpJson("POST", `${creds.base_url}/auth/refresh`, {
+            refresh_token: tokenState.refresh_token,
+        });
+        if (r.status === 200) {
+            tokenState = {
+                access_token: r.data.access_token,
+                refresh_token: r.data.refresh_token,
+                expires_at: parseExpiresAt(r.data.expires_at),
+            };
+            return tokenState.access_token;
+        }
+    }
+    // Full auth
+    const r = await httpJson("POST", `${creds.base_url}/auth/token`, {
+        script_id: creds.script_id,
+        client_secret: creds.clientSecret,
+    });
+    if (r.status !== 200)
+        throw new Error(`Auth failed: ${JSON.stringify(r.data)}`);
+    tokenState = {
+        access_token: r.data.access_token,
+        refresh_token: r.data.refresh_token,
+        expires_at: parseExpiresAt(r.data.expires_at),
+    };
+    return tokenState.access_token;
+}
+function invalidateToken() {
+    tokenState = null;
+}
+function parseExpiresAt(ea) {
+    if (typeof ea === "string" && ea.includes("T")) {
+        return new Date(ea).getTime();
+    }
+    return typeof ea === "number" ? ea : Date.now() + 3600_000;
+}
+// ---------------------------------------------------------------------------
+// Authenticated requests
+// ---------------------------------------------------------------------------
+async function authRequest(creds, method, urlPath, body) {
+    const token = await ensureToken(creds);
+    const r = await httpJson(method, `${creds.base_url}${urlPath}`, body, {
+        Authorization: `Bearer ${token}`,
+    });
+    if (r.status === 401) {
+        invalidateToken();
+        const newToken = await ensureToken(creds);
+        const retry = await httpJson(method, `${creds.base_url}${urlPath}`, body, {
+            Authorization: `Bearer ${newToken}`,
+        });
+        if (retry.status >= 400)
+            throw new Error(`Request failed: ${JSON.stringify(retry.data)}`);
+        return retry.data;
+    }
+    if (r.status >= 400)
+        throw new Error(`Request failed (${r.status}): ${JSON.stringify(r.data)}`);
+    return r.data;
+}
+// ---------------------------------------------------------------------------
+// AgenTrux API operations
+// ---------------------------------------------------------------------------
+async function pullEvents(creds, topicId, afterSeq, limit = 20) {
+    const result = await authRequest(creds, "GET", `/topics/${topicId}/events?after_sequence_no=${afterSeq}&limit=${limit}`);
+    return result.items || [];
+}
+async function publishEvent(creds, topicId, eventType, payload) {
+    const result = await authRequest(creds, "POST", `/topics/${topicId}/events`, {
+        type: eventType,
+        payload,
+    });
+    return result.event_id;
+}
+/**
+ * Upload a file to AgenTrux via presigned URL.
+ * Returns { object_id, download_url } for attaching to events.
+ */
+async function uploadFile(creds, topicId, filePath, contentType) {
+    const fs = await Promise.resolve().then(() => __importStar(require("fs")));
+    const path = await Promise.resolve().then(() => __importStar(require("path")));
+    const data = fs.readFileSync(filePath);
+    const filename = path.basename(filePath);
+    // 1. Get presigned upload URL
+    const info = await authRequest(creds, "POST", `/topics/${topicId}/payloads`, {
+        content_type: contentType,
+        filename,
+    });
+    // 2. Upload file to presigned URL
+    const uploadUrl = new URL(info.upload_url);
+    const mod = uploadUrl.protocol === "https:" ? await Promise.resolve().then(() => __importStar(require("https"))) : await Promise.resolve().then(() => __importStar(require("http")));
+    await new Promise((resolve, reject) => {
+        const req = mod.request({
+            hostname: uploadUrl.hostname,
+            port: uploadUrl.port,
+            path: uploadUrl.pathname + uploadUrl.search,
+            method: "PUT",
+            headers: { "Content-Type": contentType, "Content-Length": data.length },
+        }, (res) => {
+            res.resume();
+            res.on("end", () => {
+                if (res.statusCode && res.statusCode < 300)
+                    resolve();
+                else
+                    reject(new Error(`Upload failed: ${res.statusCode}`));
+            });
+        });
+        req.on("error", reject);
+        req.write(data);
+        req.end();
+    });
+    return {
+        object_id: info.object_id,
+        download_url: info.download_url || `${creds.base_url}/topics/${topicId}/payloads/${info.object_id}`,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * AgenTrux Ingress + Tools plugin for OpenClaw.
+ *
+ * Tools (LLM-callable):
+ *   - agentrux_activate, agentrux_publish, agentrux_read,
+ *     agentrux_send_message, agentrux_redeem_grant
+ *
+ * Ingress (external → OpenClaw):
+ *   - registerHttpRoute("/agentrux/webhook") — AgenTrux Webhook receiver
+ *   - Dispatcher (async loop) — subagent.run() + outbox + waterline cursor
+ *   - SafetyPoller — gap detection fallback
+ *
+ * Credentials: ~/.agentrux/credentials.json (0600)
+ */
+export default function (api: any): void;