oomi-ai 0.2.3 → 0.2.4

package/bin/oomi-ai.js

@@ -5,6 +5,7 @@ import path from 'path';
 import { spawn } from 'child_process';
 import { randomUUID } from 'crypto';
 import WebSocket from 'ws';
+import { ensureSessionBridge, forwardFrameToSession, flushSessionQueue } from './sessionBridgeState.js';
 
 const MARKER_START = '<oomi-agent-instructions>';
 const MARKER_END = '</oomi-agent-instructions>';
@@ -790,6 +791,58 @@ async function startOpenclawBridge(flags) {
 
     const brokerSocket = new WebSocket(wsUrl.toString());
     let actionCableHeartbeat = null;
+    const setupGatewaySession = (sessionId, sessionBridge) => {
+      if (!sessionBridge || !sessionBridge.socket) return;
+      const gatewaySocket = sessionBridge.socket;
+
+      gatewaySocket.on('open', () => {
+        console.log(`[bridge] gateway.open ${sessionId}`);
+        flushSessionQueue(sessionBridge);
+      });
+
+      gatewaySocket.on('message', (gatewayRaw) => {
+        const frame = typeof gatewayRaw === 'string' ? gatewayRaw : gatewayRaw.toString();
+        sendBrokerPayload(brokerSocket, { action: 'gateway_frame', type: 'gateway.frame', sessionId, frame });
+      });
+
+      gatewaySocket.on('close', (code, reason) => {
+        const reasonText = reason ? reason.toString() : '';
+        console.log(
+          `[bridge] gateway.close ${sessionId} code=${String(code)}${reasonText ? ` reason=${reasonText}` : ''}`
+        );
+        activeGatewaySockets.delete(sessionId);
+        sendBrokerPayload(brokerSocket, {
+          action: 'gateway_closed',
+          type: 'gateway.closed',
+          sessionId,
+          code,
+          reason: reasonText,
+        });
+      });
+
+      gatewaySocket.on('error', (err) => {
+        console.error(`[bridge] gateway.error ${sessionId}: ${String(err)}`);
+        sendBrokerPayload(brokerSocket, {
+          action: 'log',
+          type: 'log',
+          sessionId,
+          level: 'error',
+          message: `Gateway socket error (${sessionId}): ${String(err)}`,
+        });
+      });
+    };
+
+    const getOrCreateGatewaySession = (sessionId) => {
+      const existing = activeGatewaySockets.get(sessionId);
+      if (existing) return existing;
+      const sessionBridge = ensureSessionBridge({
+        sessions: activeGatewaySockets,
+        sessionId,
+        createSocket: () => new WebSocket(gateway.gatewayUrl),
+      });
+      if (sessionBridge) setupGatewaySession(sessionId, sessionBridge);
+      return sessionBridge;
+    };
 
     brokerSocket.on('open', () => {
       console.log('[bridge] Connected to managed broker.');
@@ -831,55 +884,9 @@ async function startOpenclawBridge(flags) {
 
       if (payload.type === 'client.open') {
         const sessionId = String(payload.sessionId || '').trim();
-        if (!sessionId || activeGatewaySockets.has(sessionId)) return;
+        if (!sessionId) return;
         console.log(`[bridge] client.open ${sessionId}`);
-        const gatewaySocket = new WebSocket(gateway.gatewayUrl);
-        const sessionBridge = {
-          socket: gatewaySocket,
-          queue: [],
-        };
-        activeGatewaySockets.set(sessionId, sessionBridge);
-
-        gatewaySocket.on('open', () => {
-          console.log(`[bridge] gateway.open ${sessionId}`);
-          while (sessionBridge.queue.length > 0 && gatewaySocket.readyState === WebSocket.OPEN) {
-            const nextFrame = sessionBridge.queue.shift();
-            if (typeof nextFrame === 'string' && nextFrame) {
-              gatewaySocket.send(nextFrame);
-            }
-          }
-        });
-
-        gatewaySocket.on('message', (gatewayRaw) => {
-          const frame = typeof gatewayRaw === 'string' ? gatewayRaw : gatewayRaw.toString();
-          sendBrokerPayload(brokerSocket, { action: 'gateway_frame', type: 'gateway.frame', sessionId, frame });
-        });
-
-        gatewaySocket.on('close', (code, reason) => {
-          const reasonText = reason ? reason.toString() : '';
-          console.log(
-            `[bridge] gateway.close ${sessionId} code=${String(code)}${reasonText ? ` reason=${reasonText}` : ''}`
-          );
-          activeGatewaySockets.delete(sessionId);
-          sendBrokerPayload(brokerSocket, {
-            action: 'gateway_closed',
-            type: 'gateway.closed',
-            sessionId,
-            code,
-            reason: reasonText,
-          });
-        });
-
-        gatewaySocket.on('error', (err) => {
-          console.error(`[bridge] gateway.error ${sessionId}: ${String(err)}`);
-          sendBrokerPayload(brokerSocket, {
-            action: 'log',
-            type: 'log',
-            sessionId,
-            level: 'error',
-            message: `Gateway socket error (${sessionId}): ${String(err)}`,
-          });
-        });
+        getOrCreateGatewaySession(sessionId);
         return;
       }
 
@@ -888,19 +895,13 @@ async function startOpenclawBridge(flags) {
         const frame = typeof payload.frame === 'string' ? payload.frame : '';
         if (!sessionId || !frame) return;
         console.log(`[bridge] client.frame ${sessionId}`);
-        const sessionBridge = activeGatewaySockets.get(sessionId);
-        if (!sessionBridge || !sessionBridge.socket) {
-          console.log(`[bridge] client.frame dropped (no session) ${sessionId}`);
-          return;
-        }
-        const gatewaySocket = sessionBridge.socket;
+        const sessionBridge = getOrCreateGatewaySession(sessionId);
+        if (!sessionBridge) return;
         const frameWithAuth = injectGatewayAuth(frame, gateway);
-        if (gatewaySocket.readyState === WebSocket.OPEN) {
-          gatewaySocket.send(frameWithAuth);
-        } else if (gatewaySocket.readyState === WebSocket.CONNECTING) {
+        const result = forwardFrameToSession(sessionBridge, frameWithAuth);
+        if (result === 'queued') {
           console.log(`[bridge] client.frame queued ${sessionId}`);
-          sessionBridge.queue.push(frameWithAuth);
-        } else {
+        } else if (result === 'dropped') {
           console.log(`[bridge] client.frame dropped (socket not open) ${sessionId}`);
         }
         return;

package/bin/sessionBridgeState.js

@@ -0,0 +1,51 @@
+const WS_CONNECTING = 0;
+const WS_OPEN = 1;
+
+/**
+ * Ensure session state exists so client frames can be buffered before client.open arrives.
+ */
+export function ensureSessionBridge({ sessions, sessionId, createSocket }) {
+  const id = String(sessionId || '').trim();
+  if (!id) return null;
+
+  const existing = sessions.get(id);
+  if (existing) return existing;
+
+  const socket = createSocket(id);
+  const next = { socket, queue: [] };
+  sessions.set(id, next);
+  return next;
+}
+
+/**
+ * Forward a frame to the gateway socket or queue it while connecting.
+ */
+export function forwardFrameToSession(sessionBridge, frameText) {
+  if (!sessionBridge || !sessionBridge.socket || typeof frameText !== 'string' || !frameText) {
+    return 'dropped';
+  }
+
+  const { socket } = sessionBridge;
+  if (socket.readyState === WS_OPEN) {
+    socket.send(frameText);
+    return 'sent';
+  }
+
+  if (socket.readyState === WS_CONNECTING) {
+    sessionBridge.queue.push(frameText);
+    return 'queued';
+  }
+
+  return 'dropped';
+}
+
+export function flushSessionQueue(sessionBridge) {
+  if (!sessionBridge || !sessionBridge.socket) return;
+  const socket = sessionBridge.socket;
+  while (sessionBridge.queue.length > 0 && socket.readyState === WS_OPEN) {
+    const nextFrame = sessionBridge.queue.shift();
+    if (typeof nextFrame === 'string' && nextFrame) {
+      socket.send(nextFrame);
+    }
+  }
+}

package/openclaw.extension.js

@@ -154,7 +154,12 @@ async function postJson({ url, token, body, timeoutMs }) {
 const oomiChannelPlugin = {
   id: CHANNEL_ID,
   meta: {
-    name: 'Oomi',
+    label: 'Oomi',
+    selectionLabel: 'Oomi (Managed)',
+    docsPath: '/channels/oomi',
+    docsLabel: 'oomi',
+    blurb: 'Managed channel transport for Oomi chat.',
+    aliases: ['oomi-ai'],
     description: 'Managed Oomi channel plugin.',
   },
   capabilities: {
@@ -167,15 +172,22 @@ const oomiChannelPlugin = {
     threads: true,
   },
 
-  config(cfg) {
-    return normalizeConfig(cfg);
-  },
+  config: {
+    listAccountIds(cfg) {
+      const normalized = normalizeConfig(cfg);
+      return Object.entries(normalized.accounts)
+        .filter(([, account]) => account.enabled !== false)
+        .map(([accountId]) => accountId);
+    },
 
-  listAccountIds(cfg) {
-    const normalized = normalizeConfig(cfg);
-    return Object.entries(normalized.accounts)
-      .filter(([, account]) => account.enabled !== false)
-      .map(([accountId]) => accountId);
+    resolveAccount(cfg, accountId) {
+      const { accountId: resolvedAccountId, account } = resolveAccount(cfg, accountId);
+      if (!account) return null;
+      return {
+        id: resolvedAccountId,
+        ...account,
+      };
+    },
   },
 
   outbound: {

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "oomi-ai",
   "name": "Oomi Channel Plugin",
   "description": "Managed Oomi channel integration for OpenClaw.",
-  "version": "0.2.1",
+  "version": "0.2.4",
   "author": "Oomi",
   "license": "MIT",
   "openclawVersion": ">=0.5.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oomi-ai",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "Oomi CLI for OpenClaw setup",
   "bin": {
     "oomi": "bin/oomi-ai.js"
@@ -46,7 +46,8 @@
     "url": "https://github.com/crispcode-io/oomi/issues"
   },
   "scripts": {
-    "check": "node --check bin/oomi-ai.js"
+    "check": "node --check bin/oomi-ai.js",
+    "test": "node --test test/sessionBridgeState.test.mjs"
   },
   "dependencies": {
     "ws": "^8.19.0"
@@ -54,6 +55,7 @@
   "license": "MIT",
   "files": [
     "bin/oomi-ai.js",
+    "bin/sessionBridgeState.js",
     "openclaw.plugin.json",
     "openclaw.extension.js",
     "agent_instructions.md",