oomi-ai 0.2.2 → 0.2.4

package/README.md

@@ -49,12 +49,15 @@ oomi openclaw pair --app-url https://your-oomi-app.vercel.app --device-id my-ope
 `--app-url` must be reachable from the OpenClaw host. If OpenClaw runs on a different machine/network, do not use `localhost` unless tunneled.
 
 This prints:
-- `Connect code: <device-id>`
-- `Connect URL: https://.../?connect=managed://<device-id>&sessionKey=...`
+- `Auth invite URL: https://.../connect/<single-use-token>`
 - A copy-ready block for the user:
   - `Oomi Connect Ready`
-  - `Code: ...`
-  - `Link: ...`
+  - `Auth Link: ...`
+
+If you need a fresh auth link later (without re-pairing), run:
+```
+oomi openclaw invite --app-url https://your-oomi-app.vercel.app
+```
 
 Agent-intent mapping (recommended):
 - If user says `Connect yourself to Oomi. Use app URL https://www.oomi.ai.`
@@ -68,7 +71,7 @@ Agent-intent mapping (recommended):
 
 Important distinction:
 - `pairCode` is one-time and used internally by the pair/bootstrap flow.
-- `connect code` is the stable device id used by browser connect (`managed://<device-id>`).
+- Invite auth links are the required user flow.
 
 Sync personas from the repo into the backend registry:
 ```

package/agent_instructions.md

@@ -31,7 +31,12 @@ If the user asks to connect OpenClaw to Oomi voice/web:
    - Example: `oomi openclaw pair --app-url <URL> --no-start`
 8. Return this exact result format to the user:
    - `Oomi Connect Ready`
-   - `Code: ...`
-   - `Link: ...`
+   - `Auth Link: ...`
+   - No extra narrative text before or after those lines.
+
+Primary UX requirement:
+- Never ask the user to enter raw pairing identifiers.
+- The user should open the auth link, complete sign-in, and land directly in connected chat.
+- Return `/connect/<invite-token>` auth links only.
 
 Do not ask users to paste gateway IP/token/password when managed connect is available.

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>';
@@ -142,6 +143,9 @@ Commands:
   openclaw pair
     Pair this OpenClaw host with Oomi and start bridge (single command).
 
+  openclaw invite
+    Create a single-use auth invite link for the paired OpenClaw device.
+
   openclaw plugin
     Print OpenClaw extension install/config guidance for Oomi channel plugin.
 
@@ -158,7 +162,7 @@ Common flags:
   --broker-http URL      Managed broker HTTPS URL (for pair claim)
   --broker-ws URL        Managed broker device WS URL (wss://.../cable)
   --pair-code CODE       One-time pairing code from Oomi
-  --app-url URL          Oomi app URL used for pairing APIs (default: http://127.0.0.1:3000)
+  --app-url URL          Oomi app URL used for pairing APIs (default: http://127.0.0.1:3456)
   --label TEXT           Pairing label shown in broker logs
   --session-key KEY      Session key used in generated connect URL
   --detach               Start bridge in background and exit
@@ -595,6 +599,25 @@ async function requestManagedPairCode({ appUrl, label }) {
   return payload;
 }
 
+async function requestConnectInviteLink({ backendHttp, appUrl, sessionKey, deviceToken }) {
+  const response = await fetch(`${backendHttp.replace(/\/$/, '')}/v1/invite_links/start`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${deviceToken}`,
+    },
+    body: JSON.stringify({ appUrl, sessionKey }),
+  });
+  const payload = await response.json().catch(() => ({}));
+  if (!response.ok || !payload?.inviteUrl) {
+    const message =
+      (payload && typeof payload.error === 'string' && payload.error) ||
+      `Invite link start failed (${response.status})`;
+    throw new Error(message);
+  }
+  return payload;
+}
+
 async function fetchManagedGatewayConfig({ appUrl }) {
   const baseUrl = appUrl.replace(/\/$/, '');
   const response = await fetch(`${baseUrl}/api/gateway/managed/config`, {
@@ -768,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.');
@@ -809,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;
       }
 
@@ -866,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;
@@ -924,7 +947,7 @@ async function startOpenclawBridge(flags) {
 
 async function pairAndStartOpenclawBridge(flags) {
   const bridgeState = readBridgeState();
-  const appUrl = String(flags['app-url'] || process.env.OOMI_APP_URL || 'http://127.0.0.1:3000').trim();
+  const appUrl = String(flags['app-url'] || process.env.OOMI_APP_URL || 'http://127.0.0.1:3456').trim();
   const deviceId = resolveDeviceId(flags, bridgeState);
   const label = String(flags.label || `${deviceId}-bridge`).trim();
   const sessionKey = String(
@@ -961,19 +984,24 @@ async function pairAndStartOpenclawBridge(flags) {
     brokerWs,
     deviceId,
     deviceToken,
+    sessionKey,
     claimedAt: new Date().toISOString(),
     expiresAt: claimed.expiresAt || null,
   });
 
-  const connectCode = deviceId;
-  const gatewayValue = `managed://${deviceId}`;
-  const connectUrl = `${appUrl.replace(/\/$/, '')}/?connect=${encodeURIComponent(gatewayValue)}&sessionKey=${encodeURIComponent(sessionKey)}`;
+  const invite = await requestConnectInviteLink({
+    backendHttp: managedConfig.brokerHttpUrl,
+    appUrl,
+    sessionKey,
+    deviceToken,
+  });
+  const inviteUrl = String(invite.inviteUrl || '').trim();
+  const inviteExpiresAt = String(invite.expiresAt || '').trim();
 
   const pairSummary = {
     deviceId,
-    connectCode,
-    gatewayValue,
-    connectUrl,
+    inviteUrl,
+    inviteExpiresAt,
     brokerHttpUrl: managedConfig.brokerHttpUrl,
     brokerDeviceWsUrl: brokerWs,
     bridgeMode: shouldStart ? (detach ? 'detached' : 'attached') : 'skipped',
@@ -984,15 +1012,15 @@ async function pairAndStartOpenclawBridge(flags) {
     console.log(JSON.stringify(pairSummary, null, 2));
   } else {
     console.log(`Paired device: ${deviceId}`);
-    console.log(`Connect code: ${connectCode}`);
-    console.log(`Gateway value: ${gatewayValue}`);
-    console.log(`Connect URL: ${connectUrl}`);
+    console.log(`Auth invite URL: ${inviteUrl}`);
+    if (inviteExpiresAt) {
+      console.log(`Invite expires at: ${inviteExpiresAt}`);
+    }
     console.log('');
-    console.log('Share this with the user:');
+    console.log('Share this exact response with the user (no extra text):');
     console.log('----------------------------------------');
     console.log('Oomi Connect Ready');
-    console.log(`Code: ${connectCode}`);
-    console.log(`Link: ${connectUrl}`);
+    console.log(`Auth Link: ${inviteUrl}`);
     console.log('----------------------------------------');
   }
 
@@ -1033,6 +1061,61 @@ async function pairAndStartOpenclawBridge(flags) {
   });
 }
 
+async function createOpenclawInviteLink(flags) {
+  const bridgeState = readBridgeState();
+  const backendHttp = String(
+    flags['backend-url'] ||
+      flags['broker-http'] ||
+      process.env.OOMI_BACKEND_URL ||
+      process.env.OOMI_CHAT_BROKER_HTTP_URL ||
+      bridgeState.brokerHttp ||
+      ''
+  ).trim();
+  const appUrl = String(flags['app-url'] || process.env.OOMI_APP_URL || 'http://127.0.0.1:3456').trim();
+  const sessionKey = String(
+    flags['session-key'] ||
+      process.env.OOMI_SESSION_KEY ||
+      bridgeState.sessionKey ||
+      'agent:main:webchat:channel:oomi'
+  ).trim();
+  const deviceToken = String(flags['device-token'] || bridgeState.deviceToken || '').trim();
+  const jsonOutput = isTruthyFlag(flags.json);
+
+  if (!backendHttp) {
+    throw new Error('Missing backend URL. Set --backend-url (or --broker-http) or pair first.');
+  }
+  if (!deviceToken) {
+    throw new Error('Missing device token in bridge state. Run: oomi openclaw pair --app-url https://www.oomi.ai --no-start');
+  }
+
+  const invite = await requestConnectInviteLink({
+    backendHttp,
+    appUrl,
+    sessionKey,
+    deviceToken,
+  });
+
+  const summary = {
+    appUrl,
+    backendHttp,
+    inviteUrl: invite.inviteUrl,
+    expiresAt: invite.expiresAt || null,
+    sessionKey,
+  };
+
+  if (jsonOutput) {
+    console.log(JSON.stringify(summary, null, 2));
+    return;
+  }
+
+  console.log('Oomi Auth Invite Ready');
+  console.log('----------------------');
+  console.log(`Auth Link: ${summary.inviteUrl}`);
+  if (summary.expiresAt) {
+    console.log(`Expires: ${summary.expiresAt}`);
+  }
+}
+
 function printOpenclawPluginSetup(flags) {
   const bridgeState = readBridgeState();
   const backendUrl = String(
@@ -1141,6 +1224,11 @@ async function main() {
     return;
   }
 
+  if (command === 'openclaw' && subcommand === 'invite') {
+    await createOpenclawInviteLink(args.flags);
+    return;
+  }
+
   if (command === 'openclaw' && subcommand === 'plugin') {
     printOpenclawPluginSetup(args.flags);
     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.2",
+  "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",

package/skills/oomi/agent_instructions.md

@@ -31,7 +31,12 @@ If the user asks to connect OpenClaw to Oomi voice/web:
    - Example: `oomi openclaw pair --app-url <URL> --no-start`
 8. Return this exact result format to the user:
    - `Oomi Connect Ready`
-   - `Code: ...`
-   - `Link: ...`
+   - `Auth Link: ...`
+   - No extra narrative text before or after those lines.
+
+Primary UX requirement:
+- Never ask the user to enter raw pairing identifiers.
+- The user should open the auth link, complete sign-in, and land directly in connected chat.
+- Return `/connect/<invite-token>` auth links only.
 
 Do not ask users to paste gateway IP/token/password when managed connect is available.