@brantrusnak/openclaw-omadeus 1.0.2 → 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brantrusnak/openclaw-omadeus",
-  "version": "1.0.2",
+  "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,7 +53,11 @@
     "extensions": [
       "./index.ts"
     ],
+    "runtimeExtensions": [
+      "./dist/index.js"
+    ],
     "setupEntry": "./setup-entry.ts",
+    "runtimeSetupEntry": "./dist/setup-entry.js",
     "channel": {
       "id": "omadeus",
       "label": "Omadeus",