nexus-channel 1.7.6 → 1.7.7

package/dist/src/runtime/event-handler.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getEventTimestamp = getEventTimestamp;
 exports.getEventDecision = getEventDecision;
 exports.buildEventPrompt = buildEventPrompt;
+exports.parseSessionDirectives = parseSessionDirectives;
 exports.processEvent = processEvent;
 const schema_1 = require("../config/schema");
 const chat_client_1 = require("../gateway/chat-client");
@@ -53,6 +54,33 @@ function buildEventPrompt(event, config) {
     }
     return `[from: ${from}] ${content}`;
 }
+// ── Orchestrator Session Key Parsing ──────────────────────────────────────
+/**
+ * Extract and strip orchestrator session directives from event.text.
+ *
+ * hub2d injects these prefixes for orchestrated tasks:
+ *   [SESSION_KEY:nexus:roomId:e:planId]  — use this session key instead of room default
+ *   [SESSION_RESET]                      — send /new to OpenClaw before dispatching
+ *
+ * Returns { text (cleaned), sessionKey (if overridden), sessionReset (boolean) }
+ */
+function parseSessionDirectives(rawText) {
+    let text = rawText;
+    let sessionKey = null;
+    let sessionReset = false;
+    // Extract [SESSION_KEY:xxx]
+    const keyMatch = text.match(/\[SESSION_KEY:([^\]]+)\]/);
+    if (keyMatch) {
+        sessionKey = keyMatch[1];
+        text = text.replace(/\[SESSION_KEY:[^\]]+\]\n?/, '');
+    }
+    // Extract [SESSION_RESET]
+    if (text.includes('[SESSION_RESET]')) {
+        sessionReset = true;
+        text = text.replace(/\[SESSION_RESET\]\n?/, '');
+    }
+    return { text: text.trim(), sessionKey, sessionReset };
+}
 async function processEvent(params) {
     const { event, config, selfUserId, isRecent, markRecent, gatewayConfig, sendReply, sendAck, updateResumeToken } = params;
     const decision = getEventDecision({ event, config, selfUserId, isRecent });
@@ -66,13 +94,32 @@ async function processEvent(params) {
     }
     markRecent(event.event_id);
     try {
-        let prompt = buildEventPrompt(event, config);
+        // Parse orchestrator session directives from event.text
+        const { text: cleanedText, sessionKey: overrideKey, sessionReset } = parseSessionDirectives(event.text || '');
+        // Build event with cleaned text (orchestrator prefixes stripped)
+        const cleanedEvent = { ...event, text: cleanedText };
+        let prompt = buildEventPrompt(cleanedEvent, config);
         const hub2dUrl = config.hub2dUrl || 'ws://127.0.0.1:3001';
         const context = await (0, context_1.fetchNexusContext)(roomId, hub2dUrl, config);
         if (context) {
             prompt = `${context}${prompt}`;
         }
-        const sessionKey = `nexus:${roomId}`;
+        // Use overridden session key from orchestrator, or default room session
+        const sessionKey = overrideKey || `nexus:${roomId}`;
+        // If session reset requested, send /new to gateway first to clear conversation history
+        if (sessionReset) {
+            try {
+                await (0, chat_client_1.callGatewayWithRetry)([{ role: 'user', content: '/new' }], sessionKey, gatewayConfig);
+                console.log(`[nexus] Session reset: key=${sessionKey}`);
+            }
+            catch (resetErr) {
+                console.warn(`[nexus] Session reset failed for ${sessionKey}:`, resetErr);
+            }
+            // Early return: session reset events should not generate a reply
+            sendAck(roomId, event.event_id);
+            updateResumeToken(roomId, event.event_id);
+            return 'skip-reset';
+        }
         const response = await (0, chat_client_1.callGatewayWithRetry)([{ role: 'user', content: prompt }], sessionKey, gatewayConfig);
         sendReply(event.event_id, roomId, event.from || 'unknown', response.content, 'done');
         sendAck(roomId, event.event_id);

package/dist/src/transport/ws-client.js

@@ -43,10 +43,19 @@ const path = __importStar(require("path"));
 const frames_1 = require("./frames");
 const reconnect_1 = require("./reconnect");
 const resume_store_1 = require("./resume-store");
+const MAX_OUTBOX_SIZE = 100;
+// ── Client-side liveness ───────────────────────────────────────────────────
+const IDLE_TIMEOUT_MS = 90000; // 90 seconds — if no frame received, connection is dead
+const IDLE_CHECK_INTERVAL_MS = 30000; // check every 30 seconds
 class WSClient {
     constructor(config) {
         this.ws = null;
         this.reconnectTimer = null;
+        // Client-side liveness tracking
+        this.lastFrameAt = 0;
+        this.idleCheckTimer = null;
+        // Outbound message queue
+        this.outbox = [];
         this.config = config;
         this.reconnectState = (0, reconnect_1.createReconnectState)();
         this.state = { connected: false };
@@ -60,12 +69,15 @@ class WSClient {
             catch { }
             this.ws = null;
         }
+        // Stop previous idle check
+        this.stopIdleCheck();
         console.log(`[nexus] WS connecting: ${this.config.hub2dUrl} rooms=${this.config.rooms.join(',')}`);
         this.ws = new ws_1.default(this.config.hub2dUrl);
         this.ws.on('open', () => {
             this.sendConnectFrame();
         });
         this.ws.on('message', (data) => {
+            this.lastFrameAt = Date.now();
             this.handleMessage(data);
         });
         this.ws.on('close', (code, reason) => {
@@ -74,6 +86,9 @@ class WSClient {
         this.ws.on('error', (error) => {
             console.error(`[nexus] WS error: ${error.message}`);
         });
+        // Start idle detection
+        this.lastFrameAt = Date.now();
+        this.startIdleCheck();
     }
     sendConnectFrame() {
         const frame = (0, frames_1.buildConnectFrame)({
@@ -108,6 +123,61 @@ class WSClient {
             return 'unknown';
         }
     }
+    // ── Idle detection (client-side liveness) ──────────────────────────────
+    startIdleCheck() {
+        this.stopIdleCheck();
+        this.idleCheckTimer = setInterval(() => {
+            if (!this.state.connected || !this.ws)
+                return;
+            const idle = Date.now() - this.lastFrameAt;
+            if (idle > IDLE_TIMEOUT_MS) {
+                console.warn(`[nexus] No frames received for ${Math.round(idle / 1000)}s, terminating stale connection`);
+                try {
+                    this.ws.terminate();
+                }
+                catch {
+                    // terminate triggers the close handler, which handles reconnect
+                }
+            }
+        }, IDLE_CHECK_INTERVAL_MS);
+    }
+    stopIdleCheck() {
+        if (this.idleCheckTimer) {
+            clearInterval(this.idleCheckTimer);
+            this.idleCheckTimer = null;
+        }
+    }
+    // ── Outbox (send queue for offline buffering) ─────────────────────────
+    enqueueOutbox(type, frame) {
+        const item = {
+            frame: JSON.stringify(frame),
+            type,
+            enqueuedAt: Date.now(),
+        };
+        this.outbox.push(item);
+        if (this.outbox.length > MAX_OUTBOX_SIZE) {
+            const dropped = this.outbox.shift();
+            console.warn(`[nexus] Outbox full, dropping oldest ${dropped?.type} (age ${Math.round((Date.now() - (dropped?.enqueuedAt || 0)) / 1000)}s)`);
+        }
+    }
+    flushOutbox() {
+        if (this.outbox.length === 0)
+            return;
+        const items = this.outbox.splice(0);
+        console.log(`[nexus] Flushing outbox: ${items.length} queued messages`);
+        for (const item of items) {
+            if (this.ws?.readyState === ws_1.default.OPEN) {
+                this.ws.send(item.frame);
+            }
+            else {
+                // Connection dropped again during flush — re-enqueue remaining
+                this.outbox.push(item);
+                console.warn(`[nexus] WS closed during outbox flush, ${this.outbox.length} items re-queued`);
+                return;
+            }
+        }
+    }
+    // ── Message handling ──────────────────────────────────────────────────
     handleMessage(data) {
         let frame;
         try {
@@ -127,6 +197,8 @@ class WSClient {
                     this.state.userId = connectedFrame.user_id;
                 }
                 console.log(`[nexus] WS connected: user_id=${this.state.userId} backlog_count=${JSON.stringify(connectedFrame.backlog_count || {})}`);
+                // Flush any messages queued during the disconnect
+                this.flushOutbox();
                 this.config.onConnected?.(connectedFrame);
                 break;
             }
@@ -160,7 +232,14 @@ class WSClient {
     handleClose(code, reason, myConnId) {
         console.log(`[nexus] WS closed: code=${code} reason=${reason.toString() || 'none'} connId=${myConnId}/${this.reconnectState.connId}`);
         this.state.connected = false;
+        this.stopIdleCheck();
         (0, resume_store_1.flushResumeTokens)();
+        // Phase 3.3: Reset pendingApproval unless the close was due to pending approval
+        // (code 4003 is used by hub2d for PENDING_APPROVAL rejections)
+        if (this.state.pendingApproval && code !== 4003) {
+            this.state.pendingApproval = false;
+            (0, reconnect_1.resetReconnectDelay)(this.reconnectState);
+        }
         if (!(0, reconnect_1.isStaleConnection)(this.reconnectState, myConnId)) {
             this.scheduleReconnect();
         }
@@ -191,35 +270,45 @@ class WSClient {
         }
     }
     sendAck(roomId, eventId) {
-        if (!this.ws || this.ws.readyState !== ws_1.default.OPEN)
-            return;
-        this.ws.send(JSON.stringify((0, frames_1.buildAckFrame)(roomId, eventId)));
+        const frame = (0, frames_1.buildAckFrame)(roomId, eventId);
+        if (this.ws?.readyState === ws_1.default.OPEN) {
+            this.ws.send(JSON.stringify(frame));
+        }
+        else {
+            this.enqueueOutbox('ack', frame);
+        }
     }
     sendReply(eventId, roomId, to, text, status) {
-        if (!this.ws || this.ws.readyState !== ws_1.default.OPEN) {
-            console.error(`[nexus] Cannot send reply, WS not open (event_id=${eventId})`);
-            return;
-        }
-        this.ws.send(JSON.stringify((0, frames_1.buildReplyFrame)({
+        const frame = (0, frames_1.buildReplyFrame)({
             eventId,
             roomId,
             from: this.config.agentName,
             to,
             text,
             status,
-        })));
+        });
+        if (this.ws?.readyState === ws_1.default.OPEN) {
+            this.ws.send(JSON.stringify(frame));
+        }
+        else {
+            this.enqueueOutbox('reply', frame);
+            console.warn(`[nexus] WS not open, queued reply (event_id=${eventId})`);
+        }
     }
     sendMessage(roomId, text, mentions, clientMsgId) {
-        if (!this.ws || this.ws.readyState !== ws_1.default.OPEN) {
-            console.error('[nexus] Cannot send message, WS not connected');
-            return;
-        }
-        this.ws.send(JSON.stringify((0, frames_1.buildSendFrame)({
+        const frame = (0, frames_1.buildSendFrame)({
             roomId,
             text,
             mentions,
             clientMsgId,
-        })));
+        });
+        if (this.ws?.readyState === ws_1.default.OPEN) {
+            this.ws.send(JSON.stringify(frame));
+        }
+        else {
+            this.enqueueOutbox('send', frame);
+            console.warn('[nexus] WS not open, queued message');
+        }
     }
     getState() {
         return { ...this.state };
@@ -230,11 +319,15 @@ class WSClient {
     getUserId() {
         return this.state.userId;
     }
+    getOutboxSize() {
+        return this.outbox.length;
+    }
     close() {
         if (this.reconnectTimer) {
             clearTimeout(this.reconnectTimer);
             this.reconnectTimer = null;
         }
+        this.stopIdleCheck();
         if (this.ws) {
             try {
                 this.ws.close();

package/dist/tests/unit/transport.outbox-idle.test.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const strict_1 = __importDefault(require("node:assert/strict"));
+/**
+ * Unit tests for WSClient outbox queue and idle detection features.
+ *
+ * These test the data structures and logic without actual WebSocket connections.
+ */
+// ── Outbox queue logic ─────────────────────────────────────────────────
+(0, node_test_1.describe)('outbox queue', () => {
+    const MAX_OUTBOX_SIZE = 100;
+    function createOutbox() {
+        return [];
+    }
+    function enqueue(outbox, type, frame) {
+        const item = {
+            frame: JSON.stringify(frame),
+            type,
+            enqueuedAt: Date.now(),
+        };
+        outbox.push(item);
+        if (outbox.length > MAX_OUTBOX_SIZE) {
+            const dropped = outbox.shift();
+            console.warn(`Outbox full, dropping oldest ${dropped?.type}`);
+        }
+        return outbox;
+    }
+    (0, node_test_1.it)('queues items when WS is not connected', () => {
+        const outbox = createOutbox();
+        enqueue(outbox, 'reply', { type: 'reply', text: 'hello' });
+        enqueue(outbox, 'ack', { type: 'ack', room_id: 'general', event_id: '123' });
+        strict_1.default.equal(outbox.length, 2);
+        strict_1.default.equal(outbox[0].type, 'reply');
+        strict_1.default.equal(outbox[1].type, 'ack');
+    });
+    (0, node_test_1.it)('drops oldest when queue exceeds max size', () => {
+        const outbox = createOutbox();
+        // Fill beyond max
+        for (let i = 0; i < MAX_OUTBOX_SIZE + 10; i++) {
+            enqueue(outbox, 'reply', { type: 'reply', text: `msg-${i}` });
+        }
+        strict_1.default.equal(outbox.length, MAX_OUTBOX_SIZE);
+        // First item should be msg-10 (first 10 were dropped)
+        const first = JSON.parse(outbox[0].frame);
+        strict_1.default.equal(first.text, 'msg-10');
+    });
+    (0, node_test_1.it)('flush drains the queue', () => {
+        const outbox = createOutbox();
+        enqueue(outbox, 'reply', { type: 'reply', text: 'hello' });
+        enqueue(outbox, 'ack', { type: 'ack', room_id: 'general', event_id: '123' });
+        const flushed = outbox.splice(0);
+        strict_1.default.equal(flushed.length, 2);
+        strict_1.default.equal(outbox.length, 0);
+    });
+    (0, node_test_1.it)('preserves frame serialization', () => {
+        const outbox = createOutbox();
+        const original = { type: 'reply', event_id: '123-0', room_id: 'general', from: 'cortana', to: 'boss', text: 'test reply', status: 'done' };
+        enqueue(outbox, 'reply', original);
+        const parsed = JSON.parse(outbox[0].frame);
+        strict_1.default.deepEqual(parsed, original);
+    });
+});
+// ── Idle detection logic ──────────────────────────────────────────────
+(0, node_test_1.describe)('idle detection', () => {
+    const IDLE_TIMEOUT_MS = 90000;
+    (0, node_test_1.it)('detects stale connection when no frames received', () => {
+        const lastFrameAt = Date.now() - 100000; // 100s ago, over 90s threshold
+        const idle = Date.now() - lastFrameAt;
+        strict_1.default.ok(idle > IDLE_TIMEOUT_MS, 'Should be over idle threshold');
+    });
+    (0, node_test_1.it)('does not flag fresh connection as stale', () => {
+        const lastFrameAt = Date.now() - 30000; // 30s ago, under 90s threshold
+        const idle = Date.now() - lastFrameAt;
+        strict_1.default.ok(idle < IDLE_TIMEOUT_MS, 'Should be under idle threshold');
+    });
+    (0, node_test_1.it)('reset pendingApproval on non-pending close', () => {
+        let pendingApproval = true;
+        const closeCode = 1000; // normal close, not 4003
+        if (pendingApproval && closeCode !== 4003) {
+            pendingApproval = false;
+        }
+        strict_1.default.equal(pendingApproval, false, 'pendingApproval should be reset on normal close');
+    });
+    (0, node_test_1.it)('keep pendingApproval on 4003 close code', () => {
+        let pendingApproval = true;
+        const closeCode = 4003; // PENDING_APPROVAL code
+        if (pendingApproval && closeCode !== 4003) {
+            pendingApproval = false;
+        }
+        strict_1.default.equal(pendingApproval, true, 'pendingApproval should stay on PENDING_APPROVAL close');
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexus-channel",
-  "version": "1.7.6",
+  "version": "1.7.7",
   "description": "Nexus Hub 2.0 channel plugin for OpenClaw — enables agents to connect to Nexus Hub as a channel, with A2A dispatch, room summary, and Control Plane management.",
   "type": "commonjs",
   "main": "dist/index.js",
@@ -26,7 +26,9 @@
   "peerDependencies": {
     "openclaw": "*"
   },
-  "bundledDependencies": ["ws"],
+  "bundledDependencies": [
+    "ws"
+  ],
   "openclaw": {
     "extensions": [
       "./dist/index.js"