@brantrusnak/openclaw-omadeus 1.0.1 → 1.0.3

package/dist/src/socket/socket.js

@@ -0,0 +1,153 @@
+import { WebSocket } from "ws";
+//#region src/socket/socket.ts
+const RECONNECT_BASE_MS = 2e3;
+const RECONNECT_MAX_MS = 6e4;
+const HEARTBEAT_INTERVAL_MS = 3e4;
+const HEARTBEAT_MISSED_MAX = 5;
+const KEEP_ALIVE_CONTENT = "keep-alive";
+const KEEP_ALIVE_ACTION = "answer";
+function isServerKeepAlive(data) {
+	return data.content === KEEP_ALIVE_CONTENT;
+}
+function isClientKeepAlive(data) {
+	return data.data === KEEP_ALIVE_CONTENT;
+}
+function createOmadeusSocketClient(opts) {
+	const { maestroUrl, tokenManager, pathSuffix, logPrefix, onEvent, onConnect, onDisconnect, onError, log } = opts;
+	let ws = null;
+	let reconnectAttempt = 0;
+	let reconnectTimer = null;
+	let heartbeatTimer = null;
+	let heartbeatMissCount = 0;
+	let intentionalClose = false;
+	function buildWsUrl() {
+		const base = maestroUrl.replace(/^http/, "ws");
+		const token = tokenManager.getToken();
+		return `${base}/${pathSuffix}?token=${encodeURIComponent(token)}`;
+	}
+	function scheduleReconnect() {
+		if (intentionalClose) return;
+		const delayMs = Math.min(RECONNECT_BASE_MS * 2 ** reconnectAttempt, RECONNECT_MAX_MS);
+		reconnectAttempt++;
+		log?.info(`${logPrefix} reconnecting in ${delayMs}ms (attempt ${reconnectAttempt})`);
+		reconnectTimer = setTimeout(() => connect(), delayMs);
+	}
+	function stopHeartbeat() {
+		if (heartbeatTimer) {
+			clearInterval(heartbeatTimer);
+			heartbeatTimer = null;
+		}
+	}
+	function resetHeartbeat() {
+		heartbeatMissCount = 0;
+	}
+	function sendKeepAlive() {
+		if (ws?.readyState !== WebSocket.OPEN) return;
+		heartbeatMissCount += 1;
+		sendKeepAliveFrame();
+		if (heartbeatMissCount >= HEARTBEAT_MISSED_MAX) {
+			log?.warn(`${logPrefix} heartbeat unanswered ${heartbeatMissCount} times; reconnecting socket`);
+			ws.close();
+		}
+	}
+	function startHeartbeat() {
+		stopHeartbeat();
+		heartbeatTimer = setInterval(() => {
+			sendKeepAlive();
+		}, HEARTBEAT_INTERVAL_MS);
+	}
+	function sendKeepAliveFrame() {
+		if (ws?.readyState === WebSocket.OPEN) ws.send(JSON.stringify({
+			data: KEEP_ALIVE_CONTENT,
+			action: KEEP_ALIVE_ACTION
+		}));
+	}
+	function connect() {
+		if (ws) {
+			ws.removeAllListeners();
+			ws.close();
+			ws = null;
+		}
+		intentionalClose = false;
+		stopHeartbeat();
+		resetHeartbeat();
+		if (tokenManager.needsRefresh()) {
+			tokenManager.refresh().then(() => connect()).catch((err) => {
+				onError?.(err instanceof Error ? err : new Error(String(err)));
+				scheduleReconnect();
+			});
+			return;
+		}
+		const url = buildWsUrl();
+		log?.info(`${logPrefix} connecting...`);
+		ws = new WebSocket(url);
+		ws.on("open", () => {
+			reconnectAttempt = 0;
+			log?.info(`${logPrefix} connected`);
+			onConnect?.();
+			resetHeartbeat();
+			sendKeepAlive();
+			startHeartbeat();
+		});
+		ws.on("message", (raw) => {
+			try {
+				const data = JSON.parse(String(raw));
+				const action = data.action;
+				if (isServerKeepAlive(data) && action === KEEP_ALIVE_ACTION) {
+					resetHeartbeat();
+					return;
+				}
+				if (isClientKeepAlive(data) && action === KEEP_ALIVE_ACTION) {
+					resetHeartbeat();
+					return;
+				}
+				if (isServerKeepAlive(data) && action === "heartbeat") {
+					resetHeartbeat();
+					sendKeepAliveFrame();
+					return;
+				}
+				resetHeartbeat();
+				onEvent?.(data);
+			} catch {
+				log?.warn(`${logPrefix} unparseable message: ${String(raw).slice(0, 200)}`);
+			}
+		});
+		ws.on("close", (code, reason) => {
+			const msg = `code=${code} reason=${String(reason)}`;
+			log?.info(`${logPrefix} disconnected: ${msg}`);
+			onDisconnect?.(msg);
+			ws = null;
+			stopHeartbeat();
+			resetHeartbeat();
+			scheduleReconnect();
+		});
+		ws.on("error", (err) => {
+			log?.error(`${logPrefix} error: ${err.message}`);
+			onError?.(err);
+		});
+	}
+	function disconnect() {
+		intentionalClose = true;
+		if (reconnectTimer) {
+			clearTimeout(reconnectTimer);
+			reconnectTimer = null;
+		}
+		stopHeartbeat();
+		resetHeartbeat();
+		if (ws) {
+			ws.removeAllListeners();
+			ws.close();
+			ws = null;
+		}
+	}
+	return {
+		connect,
+		disconnect,
+		isConnected: () => ws?.readyState === WebSocket.OPEN,
+		send: (data) => {
+			if (ws?.readyState === WebSocket.OPEN) ws.send(JSON.stringify(data));
+		}
+	};
+}
+//#endregion
+export { createOmadeusSocketClient };

package/dist/src/store.js

@@ -0,0 +1,13 @@
+//#region src/store.ts
+let currentSession = null;
+function setCasSession(session) {
+	currentSession = session;
+}
+function getCasSession() {
+	return currentSession;
+}
+function clearCasSession() {
+	currentSession = null;
+}
+//#endregion
+export { clearCasSession, getCasSession, setCasSession };

package/dist/src/token.js

@@ -0,0 +1,84 @@
+import { decodeJwtPayload, tokenExpiresInMs } from "./utils/jwt.util.js";
+import { authenticate } from "./auth.js";
+//#region src/token.ts
+const TOKEN_REFRESH_MARGIN_MS = 300 * 1e3;
+const MAX_TIMEOUT_MS = 2147483647;
+/** Whether the token should be refreshed now (within safety margin). */
+function shouldRefreshToken(token) {
+	return tokenExpiresInMs(token) < TOKEN_REFRESH_MARGIN_MS;
+}
+function createTokenManager(params) {
+	const { casUrl, maestroUrl, email, password, organizationId, initialToken, onRefresh, onError } = params;
+	let currentToken = "";
+	let currentPayload = null;
+	if (initialToken) try {
+		const payload = decodeJwtPayload(initialToken);
+		currentToken = initialToken;
+		currentPayload = payload;
+	} catch (err) {
+		const error = err instanceof Error ? err : new Error(String(err));
+		onError?.(error);
+	}
+	let refreshTimer = null;
+	const refresh = async () => {
+		if (currentToken && !shouldRefreshToken(currentToken)) return;
+		const { dolphinToken, payload } = await authenticate({
+			casUrl,
+			maestroUrl,
+			email,
+			password,
+			organizationId
+		});
+		currentToken = dolphinToken;
+		currentPayload = payload;
+		onRefresh?.(dolphinToken);
+	};
+	const scheduleNextRefresh = () => {
+		if (refreshTimer) {
+			clearTimeout(refreshTimer);
+			refreshTimer = null;
+		}
+		if (!currentToken) return;
+		const desiredDelayMs = tokenExpiresInMs(currentToken) - TOKEN_REFRESH_MARGIN_MS;
+		refreshTimer = setTimeout(async () => {
+			try {
+				await refresh();
+				scheduleNextRefresh();
+			} catch (err) {
+				onError?.(err instanceof Error ? err : new Error(String(err)));
+				refreshTimer = setTimeout(() => void scheduleNextRefresh(), 3e4);
+			}
+		}, Math.min(Math.max(desiredDelayMs, 1e4), MAX_TIMEOUT_MS));
+	};
+	return {
+		getToken() {
+			return currentToken;
+		},
+		getPayload() {
+			if (!currentPayload) throw new Error("Omadeus: not authenticated");
+			return currentPayload;
+		},
+		async refresh() {
+			try {
+				await refresh();
+			} catch (err) {
+				onError?.(err instanceof Error ? err : new Error(String(err)));
+				throw err;
+			}
+		},
+		startAutoRefresh() {
+			scheduleNextRefresh();
+		},
+		stopAutoRefresh() {
+			if (refreshTimer) {
+				clearTimeout(refreshTimer);
+				refreshTimer = null;
+			}
+		},
+		needsRefresh() {
+			return !currentToken || shouldRefreshToken(currentToken);
+		}
+	};
+}
+//#endregion
+export { createTokenManager };

package/dist/src/types.js

@@ -0,0 +1,15 @@
+//#region src/types.ts
+/** Jaguar entity chats (`subscribableKind`) — DMs and channel rooms use other values. */
+const OMADEUS_INBOUND_ENTITY_KINDS = [
+	"task",
+	"nugget",
+	"project",
+	"release",
+	"sprint",
+	"summary",
+	"client",
+	"folder"
+];
+const OMADEUS_INBOUND_ENTITY_KIND_SET = new Set(OMADEUS_INBOUND_ENTITY_KINDS);
+//#endregion
+export { OMADEUS_INBOUND_ENTITY_KINDS, OMADEUS_INBOUND_ENTITY_KIND_SET };

package/dist/src/utils/http.util.js

@@ -0,0 +1,43 @@
+import { randomUUID } from "node:crypto";
+//#region src/utils/http.util.ts
+function authHeaders(token) {
+	return {
+		Authorization: `Bearer ${token}`,
+		"Content-Type": "application/json"
+	};
+}
+async function apiFetch(opts, path, init) {
+	const token = opts.tokenManager.getToken();
+	if (!token) throw new Error("Omadeus: not authenticated");
+	const url = `${opts.maestroUrl}${path}`;
+	try {
+		return await fetch(url, {
+			...init,
+			headers: {
+				...authHeaders(token),
+				...init?.headers
+			}
+		});
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		throw new Error(`Omadeus API request to ${url} failed: ${message}`);
+	}
+}
+function withApiPrefix(prefix, path) {
+	if (!path) return prefix;
+	if (path.startsWith("/")) return `${prefix}${path}`;
+	return `${prefix}/${path}`;
+}
+const JAGUAR_PREFIX = "/jaguar/apiv1";
+const DOLPHIN_PREFIX = "/dolphin/apiv1";
+async function jaguarFetch(opts, path, init) {
+	return apiFetch(opts, withApiPrefix(JAGUAR_PREFIX, path), init);
+}
+async function dolphinFetch(opts, path, init) {
+	return apiFetch(opts, withApiPrefix(DOLPHIN_PREFIX, path), init);
+}
+function generateTemporaryId() {
+	return `_${randomUUID().replace(/-/g, "").slice(0, 10)}`;
+}
+//#endregion
+export { dolphinFetch, generateTemporaryId, jaguarFetch };

package/dist/src/utils/jwt.util.js

@@ -0,0 +1,15 @@
+//#region src/utils/jwt.util.ts
+/** Decode the payload portion of a JWT without verifying the signature. */
+function decodeJwtPayload(token) {
+	const parts = token.split(".");
+	if (parts.length !== 3) throw new Error("Invalid JWT: expected 3 parts");
+	const payload = Buffer.from(parts[1], "base64url").toString("utf-8");
+	return JSON.parse(payload);
+}
+/** Returns ms until the token expires (negative = already expired). */
+function tokenExpiresInMs(token) {
+	const { exp } = decodeJwtPayload(token);
+	return exp * 1e3 - Date.now();
+}
+//#endregion
+export { decodeJwtPayload, tokenExpiresInMs };

package/openclaw.plugin.json

@@ -12,11 +12,77 @@
       "password": { "type": "string" },
       "organizationId": { "type": "number" },
       "sessionToken": { "type": "string" },
-      "selectedMemberReferenceId": { "type": "number" },
-      "selectedChannelViewId": { "type": "number" },
-      "selectedChannelTitle": { "type": "string" },
-      "selectedChannelPrivateRoomId": { "type": "number" },
-      "selectedChannelPublicRoomId": { "type": "number" }
+      "inbound": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "version": { "type": "integer", "minimum": 1 },
+          "direct": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+              "enabled": { "type": "boolean" },
+              "allowedSenderReferenceIds": {
+                "type": "array",
+                "items": { "type": "number" }
+              },
+              "requireMention": { "type": "string", "enum": ["never", "always"] }
+            },
+            "required": ["enabled"]
+          },
+          "channels": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+              "enabled": { "type": "boolean" },
+              "allowedRoomIds": { "type": "array", "items": { "type": "number" } },
+              "allowedChannelViewIds": { "type": "array", "items": { "type": "number" } },
+              "allowedSenderReferenceIds": {
+                "type": "array",
+                "items": { "type": "number" }
+              },
+              "requireMention": {
+                "type": "string",
+                "enum": ["never", "always", "outsideAllowlist"]
+              }
+            },
+            "required": ["enabled"]
+          },
+          "entities": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+              "enabled": { "type": "boolean" },
+              "allowedKinds": {
+                "type": "array",
+                "items": {
+                  "type": "string",
+                  "enum": [
+                    "task",
+                    "nugget",
+                    "project",
+                    "release",
+                    "sprint",
+                    "summary",
+                    "client",
+                    "folder"
+                  ]
+                }
+              },
+              "allowedRoomIds": { "type": "array", "items": { "type": "number" } },
+              "allowedSenderReferenceIds": {
+                "type": "array",
+                "items": { "type": "number" }
+              },
+              "requireMention": {
+                "type": "string",
+                "enum": ["never", "always", "outsideAllowlist"]
+              }
+            },
+            "required": ["enabled"]
+          }
+        }
+      }
     }
   },
   "channelConfigs": {
@@ -32,11 +98,77 @@
           "password": { "type": "string" },
           "organizationId": { "type": "number" },
           "sessionToken": { "type": "string" },
-          "selectedMemberReferenceId": { "type": "number" },
-          "selectedChannelViewId": { "type": "number" },
-          "selectedChannelTitle": { "type": "string" },
-          "selectedChannelPrivateRoomId": { "type": "number" },
-          "selectedChannelPublicRoomId": { "type": "number" }
+          "inbound": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+              "version": { "type": "integer", "minimum": 1 },
+              "direct": {
+                "type": "object",
+                "additionalProperties": false,
+                "properties": {
+                  "enabled": { "type": "boolean" },
+                  "allowedSenderReferenceIds": {
+                    "type": "array",
+                    "items": { "type": "number" }
+                  },
+                  "requireMention": { "type": "string", "enum": ["never", "always"] }
+                },
+                "required": ["enabled"]
+              },
+              "channels": {
+                "type": "object",
+                "additionalProperties": false,
+                "properties": {
+                  "enabled": { "type": "boolean" },
+                  "allowedRoomIds": { "type": "array", "items": { "type": "number" } },
+                  "allowedChannelViewIds": { "type": "array", "items": { "type": "number" } },
+                  "allowedSenderReferenceIds": {
+                    "type": "array",
+                    "items": { "type": "number" }
+                  },
+                  "requireMention": {
+                    "type": "string",
+                    "enum": ["never", "always", "outsideAllowlist"]
+                  }
+                },
+                "required": ["enabled"]
+              },
+              "entities": {
+                "type": "object",
+                "additionalProperties": false,
+                "properties": {
+                  "enabled": { "type": "boolean" },
+                  "allowedKinds": {
+                    "type": "array",
+                    "items": {
+                      "type": "string",
+                      "enum": [
+                        "task",
+                        "nugget",
+                        "project",
+                        "release",
+                        "sprint",
+                        "summary",
+                        "client",
+                        "folder"
+                      ]
+                    }
+                  },
+                  "allowedRoomIds": { "type": "array", "items": { "type": "number" } },
+                  "allowedSenderReferenceIds": {
+                    "type": "array",
+                    "items": { "type": "number" }
+                  },
+                  "requireMention": {
+                    "type": "string",
+                    "enum": ["never", "always", "outsideAllowlist"]
+                  }
+                },
+                "required": ["enabled"]
+              }
+            }
+          }
         }
       },
       "uiHints": {
@@ -63,24 +195,8 @@
           "sensitive": true,
           "advanced": true
         },
-        "selectedMemberReferenceId": {
-          "label": "Selected member reference ID",
-          "advanced": true
-        },
-        "selectedChannelViewId": {
-          "label": "Selected channel view ID",
-          "advanced": true
-        },
-        "selectedChannelTitle": {
-          "label": "Selected channel title",
-          "advanced": true
-        },
-        "selectedChannelPrivateRoomId": {
-          "label": "Selected private room ID",
-          "advanced": true
-        },
-        "selectedChannelPublicRoomId": {
-          "label": "Selected public room ID",
+        "inbound": {
+          "label": "Inbound policy (Jaguar chat)",
           "advanced": true
         }
       },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brantrusnak/openclaw-omadeus",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "private": false,
   "description": "OpenClaw Omadeus project management channel plugin",
   "homepage": "https://github.com/brantrusnak/openclaw-omadeus-plugin#readme",
@@ -14,15 +14,17 @@
   "license": "ISC",
   "author": "Brant Rusnak",
   "type": "module",
-  "main": "./index.ts",
+  "main": "./dist/index.js",
   "scripts": {
+    "build": "rolldown -c rolldown.config.mjs",
     "test": "vitest run",
-    "prepack": "node ./scripts/verify-npm-files.mjs"
+    "prepack": "npm run build && node ./scripts/verify-npm-files.mjs"
   },
   "dependencies": {
     "ws": "^8.20.0"
   },
   "files": [
+    "dist",
     "index.ts",
     "setup-entry.ts",
     "api.ts",
@@ -33,6 +35,7 @@
   ],
   "devDependencies": {
     "openclaw": ">=2026.4.10",
+    "rolldown": "1.0.0-rc.17",
     "vitest": "^4.1.5"
   },
   "peerDependencies": {
@@ -50,14 +53,16 @@
     "extensions": [
       "./index.ts"
     ],
+    "runtimeExtensions": [
+      "./dist/index.js"
+    ],
     "setupEntry": "./setup-entry.ts",
+    "runtimeSetupEntry": "./dist/setup-entry.js",
     "channel": {
       "id": "omadeus",
       "label": "Omadeus",
-      "selectionLabel": "Omadeus (WebSocket)",
-      "docsPath": "/channels/omadeus",
-      "docsLabel": "omadeus",
-      "blurb": "Omadeus project management — tasks, chat rooms, and sprints.",
+      "selectionLabel": "Omadeus (API + WebSocket)",
+      "blurb": "AI-native project management that knows your role, speaks your language, and keeps your team in sync. No noise.",
       "order": 70
     },
     "install": {

package/src/api/auth.api.ts

@@ -1,7 +1,6 @@
 import { getCasSession, setCasSession } from "../store.js";
 import type {
   CasAuthorizationCodeResponse,
-  OmadeusChannelView,
   OmadeusOrganizationMember,
   OmadeusOrganization,
   OmadeusSessionTokenResponse,
@@ -139,34 +138,6 @@ export async function listOrganizations(params: {
   return (await res.json()) as OmadeusOrganization[];
 }
 
-export async function listMemberChannelViews(params: {
-  maestroUrl: string;
-  sessionToken: string;
-  memberReferenceId: number;
-  skip?: number;
-  take?: number;
-}): Promise<OmadeusChannelView[]> {
-  const { maestroUrl, sessionToken, memberReferenceId, skip = 0, take = 100 } = params;
-  const qs = new URLSearchParams({
-    skip: String(skip),
-    take: String(take),
-    sort: "-recentMessageAt",
-  });
-  const url = `${maestroUrl}/jaguar/apiv1/members/${memberReferenceId}/channelviews?${qs.toString()}`;
-  const res = await fetch(url, {
-    method: "LIST",
-    headers: {
-      Authorization: `Bearer ${sessionToken}`,
-      "Content-Type": "application/json;charset=UTF-8",
-    },
-  });
-  if (!res.ok) {
-    const text = await res.text().catch(() => "");
-    throw new Error(`Omadeus list channel views failed (${res.status}): ${text}`);
-  }
-  return (await res.json()) as OmadeusChannelView[];
-}
-
 export async function listOrganizationMembers(params: {
   maestroUrl: string;
   sessionToken: string;

package/src/api/channel.api.ts

@@ -0,0 +1,29 @@
+import type { OmadeusChannelView } from "../types.js";
+
+export async function listMemberChannelViews(params: {
+  maestroUrl: string;
+  sessionToken: string;
+  memberReferenceId: number;
+  skip?: number;
+  take?: number;
+}): Promise<OmadeusChannelView[]> {
+  const { maestroUrl, sessionToken, memberReferenceId, skip = 0, take = 100 } = params;
+  const qs = new URLSearchParams({
+    skip: String(skip),
+    take: String(take),
+    sort: "-recentMessageAt",
+  });
+  const url = `${maestroUrl}/jaguar/apiv1/members/${memberReferenceId}/channelviews?${qs.toString()}`;
+  const res = await fetch(url, {
+    method: "LIST",
+    headers: {
+      Authorization: `Bearer ${sessionToken}`,
+      "Content-Type": "application/json;charset=UTF-8",
+    },
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`Omadeus list channel views failed (${res.status}): ${text}`);
+  }
+  return (await res.json()) as OmadeusChannelView[];
+}