@brantrusnak/openclaw-omadeus 1.0.2 → 1.0.4

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.4",
   "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",

package/src/api/auth.api.ts

@@ -9,6 +9,27 @@ import type {
 const CAS_APPLICATION_ID = 1;
 const CAS_SCOPES = "title,email,avatar,firstName,lastName,birth,phone,countryCode";
 
+function formatFetchError(label: string, url: string, method: string, err: unknown): Error {
+  const base = err instanceof Error ? err.message : String(err);
+  const cause =
+    err instanceof Error && err.cause instanceof Error ? err.cause.message : undefined;
+  const detail = cause && cause !== base ? `${base} (${cause})` : base;
+  return new Error(`${label} (${method} ${url}) failed: ${detail}`);
+}
+
+async function omadeusFetch(
+  label: string,
+  url: string,
+  init: RequestInit,
+): Promise<Response> {
+  const method = init.method ?? "GET";
+  try {
+    return await fetch(url, init);
+  } catch (err) {
+    throw formatFetchError(label, url, method, err);
+  }
+}
+
 export async function createCasToken(params: {
   casUrl: string;
   email: string;
@@ -17,11 +38,10 @@ export async function createCasToken(params: {
   const { casUrl, email, password } = params;
   const url = `${casUrl}/apiv1/tokens`;
   const jsonBody = JSON.stringify({ email, password });
-  const res = await fetch(url, {
+  const res = await omadeusFetch("CAS token request", url, {
     method: "CREATE",
     headers: {
       "Content-Type": "application/json;charset=UTF-8",
-      "Content-Length": String(jsonBody.length),
     },
     body: jsonBody,
   });
@@ -44,7 +64,7 @@ export async function getMe(params: {
 }): Promise<{ email: string }> {
   const { casUrl, casToken, refreshCookie } = params;
   const url = `${casUrl}/apiv1/members/me`;
-  const res = await fetch(url, {
+  const res = await omadeusFetch("CAS get member", url, {
     method: "GET",
     headers: {
       Authorization: `Bearer ${casToken}`,
@@ -80,7 +100,7 @@ export async function createAuthorizationCode(params: {
     Authorization: `Bearer ${token}`,
     ...(casSession?.refreshCookie ? { Cookie: casSession.refreshCookie } : {}),
   };
-  const res = await fetch(url, {
+  const res = await omadeusFetch("CAS authorization code request", url, {
     method: "CREATE",
     body,
     headers,
@@ -104,7 +124,7 @@ export async function obtainSessionToken(params: {
 }): Promise<string> {
   const { maestroUrl, authorizationCode, organizationId } = params;
   const url = `${maestroUrl}/dolphin/apiv1/oauth2/tokens`;
-  const res = await fetch(url, {
+  const res = await omadeusFetch("Omadeus session token request", url, {
     method: "OBTAIN",
     headers: { "Content-Type": "application/json;charset=UTF-8" },
     body: JSON.stringify({ authorizationCode, organizationId }),
@@ -126,7 +146,7 @@ export async function listOrganizations(params: {
 }): Promise<OmadeusOrganization[]> {
   const { maestroUrl, email } = params;
   const url = `${maestroUrl}/dolphin/apiv1/organizations`;
-  const res = await fetch(url, {
+  const res = await omadeusFetch("Omadeus list organizations", url, {
     method: "LIST",
     headers: { "Content-Type": "application/json;charset=UTF-8" },
     body: JSON.stringify({ email }),
@@ -145,7 +165,7 @@ export async function listOrganizationMembers(params: {
 }): Promise<OmadeusOrganizationMember[]> {
   const { maestroUrl, sessionToken, organizationId } = params;
   const url = `${maestroUrl}/dolphin/apiv1/organizations/${organizationId}/members`;
-  const res = await fetch(url, {
+  const res = await omadeusFetch("Omadeus list organization members", url, {
     method: "LIST",
     headers: {
       Authorization: `Bearer ${sessionToken}`,