@brantrusnak/openclaw-omadeus 1.0.2 → 1.0.4

package/dist/src/channel.js

@@ -0,0 +1,626 @@
+import { DEFAULT_ACCOUNT_ID, missingTargetError } from "../runtime-api.js";
+import { ALLOWED_OMADEUS_REACTION_EMOJI_LIST, isAllowedOmadeusReactionEmoji } from "./allowed-reaction-emojis.js";
+import { createNugget, resolveTaskRoomIdByNumber } from "./api/nugget.api.js";
+import { addMessageReaction, deleteMessage, editMessage } from "./api/message.api.js";
+import { getOmadeusChannelConfig, listOmadeusAccountIds, resolveDefaultOmadeusAccountId, resolveOmadeusAccount } from "./config.js";
+import { parseJaguarMessage } from "./inbound.js";
+import { parseTaskChannelTargetIntent } from "./nugget-lookup.js";
+import { sendOmadeusMessage } from "./outbound.js";
+import { getOmadeusRuntime } from "./runtime.js";
+import { createOmadeusMessageHandler } from "./message-handler.js";
+import { omadeusSetupAdapter } from "./setup-core.js";
+import { omadeusSetupWizard } from "./onboarding.js";
+import "./setup-surface.js";
+import { createDolphinSocketClient } from "./socket/dolphin.socket.js";
+import { createJaguarSocketClient } from "./socket/jaguar.socket.js";
+import { createTokenManager } from "./token.js";
+import { createTopLevelChannelConfigAdapter } from "openclaw/plugin-sdk/channel-config-helpers";
+import { createAttachedChannelResultAdapter } from "openclaw/plugin-sdk/channel-send-result";
+import { buildComputedAccountStatusSnapshot } from "openclaw/plugin-sdk/status-helpers";
+import { buildPassiveChannelStatusSummary, buildTrafficStatusSummary } from "openclaw/plugin-sdk/extension-shared";
+//#region src/channel.ts
+const CHANNEL_ID = "omadeus";
+const gatewayState = {
+	tokenManager: null,
+	dolphin: null,
+	jaguar: null
+};
+const isUnconfigured = (account) => account.credentialSource === "none";
+let lastPersistedToken = null;
+async function persistSessionToken(token) {
+	if (lastPersistedToken === token) return;
+	const runtime = getOmadeusRuntime();
+	if ((getOmadeusChannelConfig(runtime.config.current()) ?? {}).sessionToken === token) {
+		lastPersistedToken = token;
+		return;
+	}
+	await runtime.config.mutateConfigFile({
+		afterWrite: { mode: "auto" },
+		mutate: (draft) => {
+			draft.channels = {
+				...draft.channels ?? {},
+				omadeus: {
+					...getOmadeusChannelConfig(draft) ?? {},
+					sessionToken: token
+				}
+			};
+		}
+	});
+	lastPersistedToken = token;
+}
+function actionError(text, error = text) {
+	return {
+		isError: true,
+		content: [{
+			type: "text",
+			text
+		}],
+		details: { error }
+	};
+}
+function actionOk(payload) {
+	return {
+		content: [{
+			type: "text",
+			text: JSON.stringify({
+				ok: true,
+				channel: CHANNEL_ID,
+				...payload
+			})
+		}],
+		details: {
+			ok: true,
+			channel: CHANNEL_ID,
+			...payload
+		}
+	};
+}
+const omadeusConfigAdapter = createTopLevelChannelConfigAdapter({
+	sectionKey: "omadeus",
+	resolveAccount: (cfg) => resolveOmadeusAccount({ cfg }),
+	listAccountIds: listOmadeusAccountIds,
+	defaultAccountId: resolveDefaultOmadeusAccountId,
+	deleteMode: "clear-fields",
+	clearBaseFields: [
+		"casUrl",
+		"maestroUrl",
+		"email",
+		"password",
+		"organizationId",
+		"sessionToken",
+		"inbound"
+	],
+	resolveAllowFrom: () => [],
+	formatAllowFrom: () => []
+});
+const defaultRuntimeState = {
+	accountId: DEFAULT_ACCOUNT_ID,
+	running: false,
+	connected: false,
+	lastConnectedAt: null,
+	lastStartAt: null,
+	lastStopAt: null,
+	lastInboundAt: null,
+	lastOutboundAt: null,
+	lastError: null
+};
+/** Normalize Jaguar chat target: `room:123` or `123` -> `123` (numeric room id for APIs). */
+function normalizeOmadeusRoomId(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return;
+	const prefixed = /^room:(\d+)$/i.exec(trimmed);
+	if (prefixed) return prefixed[1];
+	return /^\d+$/.test(trimmed) ? trimmed : void 0;
+}
+function readReactionMessageId(params, toolContext) {
+	const raw = params.messageId ?? params.message_id ?? toolContext?.currentMessageId;
+	if (raw == null) return;
+	const n = typeof raw === "number" ? raw : Number(String(raw).trim());
+	return Number.isFinite(n) ? n : void 0;
+}
+function readStringParam(params, keys) {
+	for (const key of keys) {
+		const value = params[key];
+		if (typeof value === "string" && value.trim()) return value.trim();
+	}
+}
+function readNumberParam(params, keys) {
+	for (const key of keys) {
+		const value = params[key];
+		if (typeof value === "number" && Number.isFinite(value)) return value;
+		if (typeof value === "string" && /^\d+$/.test(value.trim())) return Number(value.trim());
+	}
+}
+function readNuggetKind(params) {
+	return readStringParam(params, [
+		"kind",
+		"entity",
+		"type"
+	])?.toLowerCase() === "nugget" ? "nugget" : "task";
+}
+function readNuggetPriority(params) {
+	const raw = readStringParam(params, ["priority"])?.toLowerCase();
+	if (raw === "urgent" || raw === "high" || raw === "medium" || raw === "low") return raw;
+	return "low";
+}
+function isCreateNuggetRequest(params) {
+	const op = readStringParam(params, [
+		"op",
+		"operation",
+		"intent"
+	])?.toLowerCase();
+	if (op === "create_nugget" || op === "create_task") return true;
+	if (params["createNugget"] === true || params["createTask"] === true || params["create"] === true || readStringParam(params, ["actionType", "mode"])?.toLowerCase() === "create") return true;
+	return Boolean(readStringParam(params, ["title"]) && readStringParam(params, ["description"]));
+}
+const omadeusPlugin = {
+	id: "omadeus",
+	meta: {
+		id: "omadeus",
+		label: "Omadeus",
+		selectionLabel: "Omadeus (API + WebSocket)",
+		docsPath: "",
+		docsLabel: "",
+		blurb: "AI-native project management that knows your role, speaks your language, and keeps your team in sync. No noise."
+	},
+	capabilities: {
+		chatTypes: ["direct", "group"],
+		reactions: true,
+		threads: false,
+		media: false,
+		nativeCommands: false,
+		blockStreaming: true
+	},
+	agentPrompt: { messageToolHints: () => [
+		"- Omadeus routing: **send** uses **room id** (`to` / `target`, e.g. `room:117947` or `117947`). **edit**, **delete**, **react** use the Jaguar **message** `id` (`messageId`, or the current inbound message from context).",
+		"- Create Omadeus task/nugget: use `action=send` with params `{ op: \"create_task\"|\"create_nugget\", title, description, priority?, stage?, kind?, memberReferenceId?, clientId?, folderId? }`.",
+		"- Omadeus **Task** and **Nugget** are distinct product types (Jaguar `subscribableKind`). **Project**, **Sprint**, **Release**, **Folder**, **Client**, **Summary**, etc. also have entity chat rooms. User \"task\" / \"the task\" → map to **this room's** `subscribableKind` (Task vs Nugget vs other), not an OpenClaw background task.",
+		"- In Task or Nugget rooms, inbound may include **Dolphin nuggetviews** JSON for this chat's `roomId` — **summarize that** for status questions. The payload may include a **`people`** object (Omadeus member names). Use those for assignees; do not read `referenceId` numbers as names. Do not tell the user to go use the Omadeus app instead of answering from that data or the thread.",
+		"- `session_status` / SessionKey: **OpenClaw** gateway only. Use the inbound SessionKey, \"current\", or the hint in **entity** rooms — never a fake `task/<...>` string from a title.",
+		`- Reactions only allow these emojis (others are ignored): ${ALLOWED_OMADEUS_REACTION_EMOJI_LIST.join(" ")}`,
+		"- Reply in chat with plain text; use the message tool for proactive sends, edits, deletes, or reactions."
+	] },
+	actions: {
+		describeMessageTool: ({ cfg }) => {
+			return {
+				actions: cfg.channels?.omadeus?.enabled !== false && !isUnconfigured(resolveOmadeusAccount({ cfg })) ? [
+					"send",
+					"edit",
+					"delete",
+					"react"
+				] : [],
+				capabilities: [],
+				schema: null
+			};
+		},
+		handleAction: async (ctx) => {
+			const account = resolveOmadeusAccount({ cfg: ctx.cfg });
+			const apiOpts = () => {
+				if (!gatewayState.tokenManager) throw new Error("Omadeus: not connected; gateway must be running with Omadeus enabled.");
+				return {
+					maestroUrl: account.maestroUrl,
+					tokenManager: gatewayState.tokenManager
+				};
+			};
+			if (ctx.action === "send" && isCreateNuggetRequest(ctx.params)) {
+				const title = readStringParam(ctx.params, [
+					"title",
+					"subject",
+					"name"
+				]);
+				const description = readStringParam(ctx.params, [
+					"description",
+					"details",
+					"body"
+				]);
+				if (!title || !description) return actionError("Omadeus create task/nugget requires `title` and `description`.", "Missing title/description.");
+				const kind = readNuggetKind(ctx.params);
+				const priority = readNuggetPriority(ctx.params);
+				const stage = readStringParam(ctx.params, ["stage"]) ?? "Triage";
+				const memberReferenceId = readNumberParam(ctx.params, ["memberReferenceId", "assigneeReferenceId"]) ?? gatewayState.tokenManager?.getPayload().referenceId;
+				const clientId = readNumberParam(ctx.params, ["clientId"]) ?? 1;
+				const folderId = readNumberParam(ctx.params, ["folderId"]) ?? 1;
+				if (!memberReferenceId) return actionError("Omadeus create task/nugget needs `memberReferenceId` or an active authenticated user.", "Missing memberReferenceId.");
+				try {
+					const created = await createNugget(apiOpts(), {
+						title,
+						description,
+						stage,
+						kind,
+						priority,
+						memberReferenceId,
+						clientId,
+						folderId
+					});
+					return actionOk({
+						action: "create",
+						kind,
+						number: created["number"],
+						id: created["id"],
+						title
+					});
+				} catch (err) {
+					return actionError(err instanceof Error ? err.message : String(err));
+				}
+			}
+			if (ctx.action === "edit") {
+				const messageId = readReactionMessageId(ctx.params, ctx.toolContext);
+				const body = typeof ctx.params.message === "string" && ctx.params.message.trim() || typeof ctx.params.text === "string" && ctx.params.text.trim() || typeof ctx.params.content === "string" && ctx.params.content.trim() || "";
+				if (messageId == null) return actionError("Omadeus edit requires `messageId` (Jaguar message id) or current inbound MessageSid.", "Missing messageId for edit.");
+				if (!body) return actionError("Omadeus edit requires new text in `message`, `text`, or `content`.", "Missing body for edit.");
+				try {
+					await editMessage(apiOpts(), {
+						messageId,
+						body
+					});
+				} catch (err) {
+					return actionError(err instanceof Error ? err.message : String(err));
+				}
+				return actionOk({
+					action: "edit",
+					messageId
+				});
+			}
+			if (ctx.action === "delete") {
+				const messageId = readReactionMessageId(ctx.params, ctx.toolContext);
+				if (messageId == null) return actionError("Omadeus delete requires `messageId` (Jaguar message id) or current inbound MessageSid.", "Missing messageId for delete.");
+				try {
+					await deleteMessage(apiOpts(), { messageId });
+				} catch (err) {
+					return actionError(err instanceof Error ? err.message : String(err));
+				}
+				return actionOk({
+					action: "delete",
+					messageId
+				});
+			}
+			if (ctx.action === "react") {
+				const emoji = typeof ctx.params.emoji === "string" ? ctx.params.emoji.trim() : "";
+				if (!emoji) return actionError("Omadeus react requires `emoji`.", "Omadeus react requires emoji.");
+				if (!isAllowedOmadeusReactionEmoji(emoji)) return {
+					content: [{
+						type: "text",
+						text: JSON.stringify({
+							ok: true,
+							channel: CHANNEL_ID,
+							ignored: true,
+							reason: "unsupported_emoji",
+							emoji,
+							allowed: [...ALLOWED_OMADEUS_REACTION_EMOJI_LIST]
+						})
+					}],
+					details: {
+						ok: true,
+						ignored: true,
+						channel: CHANNEL_ID
+					}
+				};
+				const messageId = readReactionMessageId(ctx.params, ctx.toolContext);
+				if (messageId == null) return actionError("Omadeus react requires `messageId` or a current inbound message id (MessageSid).", "Missing messageId for reaction.");
+				try {
+					await addMessageReaction(apiOpts(), {
+						messageId,
+						emoji
+					});
+				} catch (err) {
+					return actionError(err instanceof Error ? err.message : String(err));
+				}
+				return actionOk({
+					messageId,
+					emoji
+				});
+			}
+			throw new Error(`Unhandled Omadeus action: ${String(ctx.action)}`);
+		}
+	},
+	reload: { configPrefixes: ["channels.omadeus"] },
+	setup: omadeusSetupAdapter,
+	setupWizard: omadeusSetupWizard,
+	config: {
+		...omadeusConfigAdapter,
+		isConfigured: (account) => !isUnconfigured(account),
+		unconfiguredReason: () => "Omadeus requires email, password, and organizationId. Run: openclaw setup omadeus",
+		describeAccount: (account) => ({
+			accountId: account.accountId,
+			name: account.name,
+			enabled: account.enabled,
+			configured: !isUnconfigured(account),
+			credentialSource: account.credentialSource,
+			baseUrl: account.maestroUrl
+		})
+	},
+	messaging: { targetResolver: {
+		hint: "Use room:<roomId> (matches OpenClaw OriginatingTo) or a numeric Jaguar room id.",
+		looksLikeId: (raw) => {
+			const t = raw.trim();
+			return /^room:\d+$/i.test(t) || /^\d+$/.test(t) || /^[nt]\d+$/i.test(t);
+		},
+		resolveTarget: async ({ cfg, input }) => {
+			const id = normalizeOmadeusRoomId(input);
+			if (!id) {
+				const taskIntent = parseTaskChannelTargetIntent(input);
+				if (!taskIntent || !gatewayState.tokenManager) return null;
+				const roomId = await resolveTaskRoomIdByNumber({
+					maestroUrl: resolveOmadeusAccount({ cfg }).maestroUrl,
+					tokenManager: gatewayState.tokenManager
+				}, { nuggetNumber: taskIntent.nuggetNumber });
+				if (!roomId) return null;
+				return {
+					to: String(roomId),
+					kind: "group",
+					display: `${taskIntent.rawPrefix.toUpperCase()}${taskIntent.nuggetNumber}`,
+					source: "normalized"
+				};
+			}
+			return {
+				to: id,
+				kind: "group",
+				display: `room:${id}`,
+				source: "normalized"
+			};
+		}
+	} },
+	outbound: {
+		deliveryMode: "direct",
+		textChunkLimit: 4e3,
+		chunker: (text, limit) => getOmadeusRuntime().channel.text.chunkMarkdownText(text, limit),
+		chunkerMode: "markdown",
+		...createAttachedChannelResultAdapter({
+			channel: CHANNEL_ID,
+			sendText: async ({ cfg, to, text }) => {
+				if (!gatewayState.jaguar || !gatewayState.tokenManager) throw new Error("Omadeus: not connected. Is the gateway running with Omadeus enabled?");
+				return await sendOmadeusMessage({
+					apiOpts: {
+						maestroUrl: resolveOmadeusAccount({ cfg }).maestroUrl,
+						tokenManager: gatewayState.tokenManager
+					},
+					jaguarSocket: gatewayState.jaguar
+				}, {
+					to,
+					text
+				});
+			}
+		}),
+		resolveTarget: ({ to }) => {
+			const trimmed = to?.trim() ?? "";
+			const id = normalizeOmadeusRoomId(trimmed);
+			if (!id) {
+				if (/^[nt]\d+$/i.test(trimmed)) return {
+					ok: true,
+					to: trimmed
+				};
+				return {
+					ok: false,
+					error: missingTargetError("Omadeus", "room:<roomId> or numeric room id")
+				};
+			}
+			return {
+				ok: true,
+				to: id
+			};
+		}
+	},
+	status: {
+		defaultRuntime: defaultRuntimeState,
+		collectStatusIssues: (accounts) => accounts.flatMap((entry) => {
+			const issues = [];
+			if (entry.enabled !== false && entry.configured !== true) issues.push({
+				channel: CHANNEL_ID,
+				accountId: String(entry.accountId ?? DEFAULT_ACCOUNT_ID),
+				kind: "config",
+				message: "Omadeus credentials are missing.",
+				fix: "Run: openclaw setup omadeus"
+			});
+			return issues;
+		}),
+		buildChannelSummary: ({ snapshot }) => ({
+			...buildPassiveChannelStatusSummary(snapshot, {
+				credentialSource: snapshot.credentialSource ?? "none",
+				baseUrl: snapshot.baseUrl ?? null,
+				connected: snapshot.connected ?? false,
+				lastConnectedAt: snapshot.lastConnectedAt ?? null
+			}),
+			...buildTrafficStatusSummary(snapshot)
+		}),
+		buildAccountSnapshot: ({ account, runtime }) => ({
+			...buildComputedAccountStatusSnapshot({
+				accountId: account.accountId,
+				name: account.name,
+				enabled: account.enabled,
+				configured: !isUnconfigured(account),
+				runtime
+			}),
+			baseUrl: account.maestroUrl,
+			credentialSource: account.credentialSource,
+			connected: runtime?.connected ?? false,
+			lastConnectedAt: runtime?.lastConnectedAt ?? null
+		})
+	},
+	gateway: { startAccount: async (ctx) => {
+		const { account, cfg, abortSignal } = ctx;
+		ctx.log?.info(`[omadeus] starting for org ${account.organizationId}`);
+		if (isUnconfigured(account)) {
+			ctx.log?.warn("[omadeus] skipping start: credentials not configured");
+			ctx.setStatus({
+				accountId: account.accountId,
+				running: false,
+				lastError: "credentials not configured"
+			});
+			return;
+		}
+		const hasCachedSession = Boolean(account.sessionToken?.trim());
+		if (!account.password && !hasCachedSession) {
+			ctx.log?.warn("[omadeus] skipping start: password/sessionToken not set");
+			ctx.setStatus({
+				accountId: account.accountId,
+				running: false,
+				lastError: "password/sessionToken not set"
+			});
+			return;
+		}
+		const log = ctx.log ?? {
+			info: () => {},
+			warn: () => {},
+			error: () => {}
+		};
+		let isConnected = false;
+		const tokenManager = createTokenManager({
+			casUrl: account.casUrl,
+			maestroUrl: account.maestroUrl,
+			email: account.email,
+			password: account.password,
+			organizationId: account.organizationId,
+			initialToken: account.sessionToken,
+			onRefresh: (token) => {
+				log.info("[omadeus] token refreshed");
+				persistSessionToken(token).catch((err) => log.warn(`[omadeus] failed to persist session token: ${String(err)}`));
+			},
+			onError: (err) => {
+				log.error(`[omadeus] token refresh failed: ${err.message}`);
+				ctx.setStatus({
+					accountId: account.accountId,
+					lastError: err.message
+				});
+			}
+		});
+		try {
+			await tokenManager.refresh();
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			log.error(`[omadeus] initial auth failed: ${msg}`);
+			ctx.setStatus({
+				accountId: account.accountId,
+				running: false,
+				lastError: msg
+			});
+			return;
+		}
+		tokenManager.startAutoRefresh();
+		gatewayState.tokenManager = tokenManager;
+		const selfReferenceId = tokenManager.getPayload().referenceId;
+		const outboundDeps = {
+			apiOpts: {
+				maestroUrl: account.maestroUrl,
+				tokenManager
+			},
+			jaguarSocket: null
+		};
+		const handleMessage = createOmadeusMessageHandler({
+			cfg,
+			runtime: ctx.runtime,
+			log,
+			outboundDeps,
+			selfReferenceId
+		});
+		const jaguar = createJaguarSocketClient({
+			maestroUrl: account.maestroUrl,
+			tokenManager,
+			log,
+			onMessage: (msg) => {
+				const label = msg.subscribableKind === "direct" ? `DM from ${msg.senderReferenceId}` : `${msg.subscribableKind}/${msg.roomName ?? msg.roomId} from ${msg.senderReferenceId}`;
+				log.info(`[jaguar] ${label}: ${msg.body.slice(0, 80)}`);
+				const inbound = parseJaguarMessage(msg, { selfReferenceId }, log);
+				if (inbound) {
+					log.info(`[jaguar] inbound: ${inbound.subscribableKind} room=${inbound.roomId} from=${inbound.from} mention=${inbound.isMention}`);
+					ctx.setStatus({
+						accountId: account.accountId,
+						lastInboundAt: Date.now()
+					});
+					handleMessage(inbound).catch((err) => {
+						log.error(`[jaguar] dispatch error: ${err instanceof Error ? err.message : String(err)}`);
+					});
+				}
+			},
+			onOtherEvent: (data) => {
+				log.info(`[jaguar] non-message event: ${JSON.stringify(data).slice(0, 120)}`);
+			},
+			onConnect: () => {
+				if (!isConnected) {
+					isConnected = true;
+					ctx.setStatus({
+						accountId: account.accountId,
+						connected: true,
+						lastConnectedAt: Date.now()
+					});
+				}
+			},
+			onDisconnect: () => {
+				isConnected = false;
+				ctx.setStatus({
+					accountId: account.accountId,
+					connected: false
+				});
+			},
+			onError: (err) => ctx.setStatus({
+				accountId: account.accountId,
+				lastError: err.message
+			})
+		});
+		const dolphin = createDolphinSocketClient({
+			maestroUrl: account.maestroUrl,
+			tokenManager,
+			log,
+			onEvent: (data) => {
+				log.info(`[dolphin] event: ${JSON.stringify(data).slice(0, 120)}`);
+			},
+			onConnect: () => {
+				if (!isConnected) {
+					isConnected = true;
+					ctx.setStatus({
+						accountId: account.accountId,
+						connected: true,
+						lastConnectedAt: Date.now()
+					});
+				}
+			},
+			onDisconnect: () => {
+				isConnected = false;
+				ctx.setStatus({
+					accountId: account.accountId,
+					connected: false
+				});
+			},
+			onError: (err) => ctx.setStatus({
+				accountId: account.accountId,
+				lastError: err.message
+			})
+		});
+		outboundDeps.jaguarSocket = jaguar;
+		jaguar.connect();
+		dolphin.connect();
+		gatewayState.jaguar = jaguar;
+		gatewayState.dolphin = dolphin;
+		ctx.setStatus({
+			accountId: account.accountId,
+			running: true,
+			lastStartAt: Date.now()
+		});
+		let cleanedUp = false;
+		const cleanup = () => {
+			if (cleanedUp) return;
+			cleanedUp = true;
+			tokenManager.stopAutoRefresh();
+			jaguar.disconnect();
+			dolphin.disconnect();
+			gatewayState.tokenManager = null;
+			gatewayState.jaguar = null;
+			gatewayState.dolphin = null;
+			lastPersistedToken = null;
+			ctx.setStatus({
+				accountId: account.accountId,
+				running: false,
+				lastStopAt: Date.now()
+			});
+		};
+		await new Promise((resolve) => {
+			if (abortSignal.aborted) {
+				resolve();
+				return;
+			}
+			abortSignal.addEventListener("abort", () => resolve(), { once: true });
+		});
+		cleanup();
+	} }
+};
+//#endregion
+export { omadeusPlugin };

package/dist/src/config.js

@@ -0,0 +1,52 @@
+import { DEFAULT_ACCOUNT_ID } from "../runtime-api.js";
+import "./defaults.js";
+//#region src/config.ts
+function getOmadeusChannelConfig(cfg) {
+	return cfg.channels?.["omadeus"];
+}
+function listOmadeusAccountIds(cfg) {
+	if (!getOmadeusChannelConfig(cfg) && !resolveOmadeusEnvCredentials()) return [];
+	return [DEFAULT_ACCOUNT_ID];
+}
+function resolveDefaultOmadeusAccountId(_cfg) {
+	return DEFAULT_ACCOUNT_ID;
+}
+function resolveOmadeusAccount(params) {
+	const { cfg } = params;
+	const section = getOmadeusChannelConfig(cfg) ?? {};
+	const envCredentials = resolveOmadeusEnvCredentials();
+	const email = section.email?.trim() || envCredentials?.email || "";
+	const password = section.password?.trim() || envCredentials?.password || "";
+	const orgId = section.organizationId ?? envCredentials?.organizationId;
+	const sessionToken = section.sessionToken?.trim() ?? "";
+	const hasCredentials = Boolean(email && password && orgId);
+	const hasSessionToken = Boolean(sessionToken);
+	const credentialSource = Boolean(section.email?.trim() && section.password?.trim() && section.organizationId) ? "config" : hasCredentials ? "env" : hasSessionToken ? "session" : "none";
+	return {
+		accountId: DEFAULT_ACCOUNT_ID,
+		name: "Omadeus",
+		enabled: section.enabled !== false,
+		config: section,
+		casUrl: section.casUrl?.trim() || "https://dev1-cas.rouztech.com",
+		maestroUrl: section.maestroUrl?.trim() || "https://dev3-maestro.rouztech.com",
+		email,
+		password,
+		organizationId: orgId ?? 0,
+		...hasSessionToken ? { sessionToken } : {},
+		credentialSource
+	};
+}
+function resolveOmadeusEnvCredentials() {
+	const email = process.env.OMADEUS_EMAIL?.trim();
+	const password = process.env.OMADEUS_PASSWORD?.trim();
+	const organizationIdRaw = process.env.OMADEUS_ORGANIZATION_ID?.trim();
+	if (!email || !password || !organizationIdRaw || !/^\d+$/.test(organizationIdRaw)) return;
+	return {
+		email,
+		password,
+		organizationId: Number(organizationIdRaw)
+	};
+}
+/** Whether messages from the authenticated user should be ignored. */
+//#endregion
+export { getOmadeusChannelConfig, listOmadeusAccountIds, resolveDefaultOmadeusAccountId, resolveOmadeusAccount };

package/dist/src/defaults.js

@@ -0,0 +1,5 @@
+//#region src/defaults.ts
+const OMADEUS_CAS_URL = "https://dev1-cas.rouztech.com";
+const OMADEUS_MAESTRO_URL = "https://dev3-maestro.rouztech.com";
+//#endregion
+export { OMADEUS_CAS_URL, OMADEUS_MAESTRO_URL };