@brantrusnak/openclaw-omadeus 1.0.4 → 1.0.6

package/src/onboarding.ts

@@ -7,12 +7,19 @@ import {
 import { listMemberChannelViews } from "./api/channel.api.js";
 import { authenticate } from "./auth.js";
 import { getOmadeusChannelConfig, resolveOmadeusAccount } from "./config.js";
-import { OMADEUS_CAS_URL, OMADEUS_MAESTRO_URL } from "./defaults.js";
+import {
+  getOmadeusEnvironmentUrls,
+  OMADEUS_DEFAULT_ENVIRONMENT,
+  OMADEUS_ENVIRONMENTS,
+  resolveOmadeusEnvironment,
+  type OmadeusEnvironment,
+} from "./defaults.js";
 import { formatMemberLabel } from "./member-resolve.js";
 import type {
   OmadeusChannelConfig,
   OmadeusChannelView,
   OmadeusInboundEntityKind,
+  OmadeusInboundMentionPolicy,
   OmadeusOrganizationMember,
 } from "./types.js";
 import { OMADEUS_INBOUND_ENTITY_KINDS } from "./types.js";
@@ -41,21 +48,38 @@ function formatAuthError(err: unknown): string {
   return parts.join(" — ");
 }
 
-async function noteOmadeusAuthHelp(prompter: WizardPrompter): Promise<void> {
+async function noteOmadeusAuthHelp(
+  prompter: WizardPrompter,
+  environment: OmadeusEnvironment,
+): Promise<void> {
+  const envLabel = OMADEUS_ENVIRONMENTS[environment].label;
   await prompter.note(
     [
-      "Omadeus authenticates via CAS + Maestro (email + password + organization).",
-      "You need:",
-      "  - Email + password",
-      "  - Organization ID (we can look it up for you)",
-      `CAS URL: ${OMADEUS_CAS_URL}`,
-      `Maestro URL: ${OMADEUS_MAESTRO_URL}`,
-      "Env vars supported: OMADEUS_EMAIL, OMADEUS_PASSWORD, OMADEUS_ORGANIZATION_ID.",
+      `Connect OpenClaw to Omadeus (${envLabel}).`,
+      "",
+      "We'll ask for your email and password, then show the organizations on your account so you can pick one.",
     ].join("\n"),
     "Omadeus setup",
   );
 }
 
+async function promptEnvironment(
+  prompter: WizardPrompter,
+  existing?: OmadeusEnvironment,
+): Promise<OmadeusEnvironment> {
+  const initial = existing ?? OMADEUS_DEFAULT_ENVIRONMENT;
+  const choice = await prompter.select({
+    message: "Select Omadeus environment",
+    options: (Object.keys(OMADEUS_ENVIRONMENTS) as OmadeusEnvironment[]).map((env) => ({
+      value: env,
+      label: OMADEUS_ENVIRONMENTS[env].label,
+      hint: getOmadeusEnvironmentUrls(env).maestroUrl,
+    })),
+    initialValue: initial,
+  });
+  return resolveOmadeusEnvironment(choice);
+}
+
 async function promptOrganizationId(params: {
   prompter: WizardPrompter;
   maestroUrl: string;
@@ -226,36 +250,68 @@ async function promptCredentials(
   return { email, password };
 }
 
-async function promptSenderAllowlist(params: {
+/**
+ * Prompt for the set of users allowed to message this OpenClaw instance.
+ *
+ * This single allowlist governs direct messages, channels, and entity rooms.
+ * There is no "all users" option: only whitelisted members may message
+ * OpenClaw. The logged-in user is always added
+ * to the allowlist (and is excluded from the selectable list by the caller) so
+ * they can interact with their own OpenClaw. Self-authored echoes (the reply
+ * loop) are filtered earlier, at socket ingestion, by the SentMessageTracker —
+ * not by the inbound policy — so allowing yourself here cannot cause a loop.
+ */
+async function promptMessagingAllowlist(params: {
   prompter: WizardPrompter;
-  message: string;
   members: OmadeusOrganizationMember[];
+  selfReferenceId: number;
   existingReferenceIds?: number[];
-}): Promise<number[] | undefined> {
-  const { prompter, message, members, existingReferenceIds } = params;
+}): Promise<number[]> {
+  const { prompter, members, selfReferenceId, existingReferenceIds } = params;
+
+  let selected: number[] = [];
   if (members.length === 0) {
-    throw new Error("No organization members found.");
+    await prompter.note(
+      "No other organization members found. Only you will be able to message OpenClaw.",
+      "Omadeus messaging allowlist",
+    );
+  } else {
+    const memberReferenceIds = new Set(members.map((member) => member.referenceId));
+    const initialValues = (existingReferenceIds ?? [])
+      .filter((id) => id !== selfReferenceId && memberReferenceIds.has(id))
+      .map(String);
+    const chosen = await promptMultiSelect({
+      prompter,
+      message: "Which users do you want to be able to message this OpenClaw instance? (You are always allowed.)",
+      options: memberOptions(members),
+      initialValues,
+    });
+    selected = readReferenceIds(chosen);
   }
 
-  const mode = await prompter.select({
-    message,
-    options: [
-      { value: "all", label: "All users", hint: "No sender allowlist" },
-      { value: "specific", label: "Specific users", hint: "Select one or more users" },
-    ],
-    initialValue: existingReferenceIds && existingReferenceIds.length > 0 ? "specific" : "all",
-  });
-  if (mode === "all") {
-    return undefined;
-  }
+  // Always allow the logged-in user so they can message their own OpenClaw.
+  return Array.from(new Set([selfReferenceId, ...selected]));
+}
 
-  const selected = await promptMultiSelect({
-    prompter,
-    message: `${message} (specific users)`,
-    options: memberOptions(members),
-    initialValues: existingReferenceIds?.map(String),
+/**
+ * Ask whether an @mention is required to trigger OpenClaw in a given surface
+ * (channels or entity rooms). DMs never use this — you can't @mention in a DM.
+ */
+async function promptRequireMention(params: {
+  prompter: WizardPrompter;
+  surfaceLabel: string;
+  existing?: OmadeusInboundMentionPolicy;
+}): Promise<OmadeusInboundMentionPolicy> {
+  // Preserve an existing "outsideAllowlist" policy so rerunning onboarding does
+  // not force previously allowlisted users to start @mentioning OpenClaw.
+  if (params.existing === "outsideAllowlist") {
+    return "outsideAllowlist";
+  }
+  const required = await params.prompter.confirm({
+    message: `Require an @mention to trigger OpenClaw in ${params.surfaceLabel}?`,
+    initialValue: params.existing ? params.existing !== "never" : true,
   });
-  return readReferenceIds(selected);
+  return required ? "always" : "never";
 }
 
 async function promptEntityKindSelection(params: {
@@ -315,16 +371,19 @@ export const omadeusSetupWizard: ChannelSetupWizard = {
     const section = getOmadeusChannelConfig(cfg) ?? {};
     let next = cfg;
 
+    const environment = await promptEnvironment(
+      prompter,
+      section.environment ? resolveOmadeusEnvironment(section.environment) : undefined,
+    );
+    const { casUrl, maestroUrl } = getOmadeusEnvironmentUrls(environment);
+
     if (account.credentialSource === "none") {
-      await noteOmadeusAuthHelp(prompter);
+      await noteOmadeusAuthHelp(prompter, environment);
     }
 
     const envEmail = process.env.OMADEUS_EMAIL?.trim();
     const envPassword = process.env.OMADEUS_PASSWORD?.trim();
 
-    const casUrl = OMADEUS_CAS_URL;
-    const maestroUrl = OMADEUS_MAESTRO_URL;
-
     let { email, password } = await promptCredentials(prompter, {
       email: section.email ?? envEmail,
       password: section.password ?? envPassword,
@@ -388,11 +447,17 @@ export const omadeusSetupWizard: ChannelSetupWizard = {
     });
     const existingInbound = section.inbound;
 
-    const directSenderIds = await promptSenderAllowlist({
+    const allowedUserReferenceIds = await promptMessagingAllowlist({
       prompter,
-      message: "Which users can DM OpenClaw directly?",
       members,
-      existingReferenceIds: existingInbound?.direct?.allowedSenderReferenceIds,
+      selfReferenceId,
+      existingReferenceIds: Array.from(
+        new Set([
+          ...(existingInbound?.direct?.allowedSenderReferenceIds ?? []),
+          ...(existingInbound?.channels?.allowedSenderReferenceIds ?? []),
+          ...(existingInbound?.entities?.allowedSenderReferenceIds ?? []),
+        ]),
+      ),
     });
 
     const selectedChannels = await promptChannelSelection({
@@ -403,30 +468,32 @@ export const omadeusSetupWizard: ChannelSetupWizard = {
       existingChannelViewIds: existingInbound?.channels?.allowedChannelViewIds,
     });
 
-    const channelSenderIds =
+    // Channels reuse the same messaging allowlist as direct messages.
+    const channelSenderIds = selectedChannels.length > 0 ? allowedUserReferenceIds : undefined;
+    const channelRequireMention =
       selectedChannels.length > 0
-        ? await promptSenderAllowlist({
+        ? await promptRequireMention({
             prompter,
-            message: "Which users can trigger OpenClaw from allowed channels?",
-            members,
-            existingReferenceIds: existingInbound?.channels?.allowedSenderReferenceIds,
+            surfaceLabel: "allowed channels",
+            existing: existingInbound?.channels?.requireMention,
           })
-        : undefined;
+        : "never";
 
     const entityKinds = await promptEntityKindSelection({
       prompter,
       existingKinds: existingInbound?.entities?.allowedKinds,
     });
 
-    const entitySenderIds =
+    // Entity rooms reuse the same messaging allowlist as direct messages.
+    const entitySenderIds = entityKinds.length > 0 ? allowedUserReferenceIds : undefined;
+    const entityRequireMention =
       entityKinds.length > 0
-        ? await promptSenderAllowlist({
+        ? await promptRequireMention({
             prompter,
-            message: "Which users can trigger OpenClaw from entity rooms?",
-            members,
-            existingReferenceIds: existingInbound?.entities?.allowedSenderReferenceIds,
+            surfaceLabel: "entity rooms",
+            existing: existingInbound?.entities?.requireMention,
           })
-        : undefined;
+        : "never";
 
     const channelRoomIds = selectedChannels
       .flatMap((selectedChannel) => [
@@ -441,20 +508,29 @@ export const omadeusSetupWizard: ChannelSetupWizard = {
 
     const senderSummary = (ids: number[] | undefined) =>
       ids && ids.length > 0 ? ids.join(", ") : "all users";
-    const entityKindSummary =
-      entityKinds.length > 0 ? entityKinds.join(", ") : "none (entity rooms disabled)";
+    const mentionSummary = (require: OmadeusInboundMentionPolicy) =>
+      require === "never"
+        ? "no @mention required"
+        : require === "outsideAllowlist"
+          ? "@mention required outside the allowlist"
+          : "@mention required";
 
     const channelSummary =
       selectedChannels.length > 0
-        ? `- Channels "${channelTitles}": rooms ${channelRoomIds.join(", ") || "(no room ids)"} from ${senderSummary(channelSenderIds)}; @mention not required in those rooms.`
+        ? `- Channels "${channelTitles}": rooms ${channelRoomIds.join(", ") || "(no room ids)"} from ${senderSummary(channelSenderIds)}; ${mentionSummary(channelRequireMention)}.`
         : "- Channels: disabled (none selected).";
 
+    const entitySummary =
+      entityKinds.length > 0
+        ? `- Entity rooms (${entityKinds.join(", ")}): ${senderSummary(entitySenderIds)}; ${mentionSummary(entityRequireMention)}.`
+        : "- Entity rooms: disabled (no room types selected).";
+
     await prompter.note(
       [
         `Inbound policy (Jaguar chat):`,
-        `- Direct messages: enabled for ${senderSummary(directSenderIds)} (no @mention required).`,
+        `- Direct messages: enabled for ${senderSummary(allowedUserReferenceIds)}.`,
         channelSummary,
-        `- Entity rooms (${entityKindSummary}): ${senderSummary(entitySenderIds)}; @mention required.`,
+        entitySummary,
       ].join("\n"),
       "Omadeus inbound policy",
     );
@@ -465,17 +541,17 @@ export const omadeusSetupWizard: ChannelSetupWizard = {
         ...next.channels,
         omadeus: {
           enabled: true,
-          casUrl,
-          maestroUrl,
+          environment,
           email,
           password,
           organizationId,
           sessionToken,
+          sessionTokenEnvironment: environment,
           inbound: {
             version: 1,
             direct: {
               enabled: true,
-              ...(directSenderIds ? { allowedSenderReferenceIds: directSenderIds } : {}),
+              allowedSenderReferenceIds: allowedUserReferenceIds,
               requireMention: "never",
             },
             channels: {
@@ -483,13 +559,13 @@ export const omadeusSetupWizard: ChannelSetupWizard = {
               allowedRoomIds: channelRoomIds,
               allowedChannelViewIds: channelViewIds,
               ...(channelSenderIds ? { allowedSenderReferenceIds: channelSenderIds } : {}),
-              requireMention: "outsideAllowlist",
+              requireMention: channelRequireMention,
             },
             entities: {
               enabled: entityKinds.length > 0,
               allowedKinds: entityKinds,
               ...(entitySenderIds ? { allowedSenderReferenceIds: entitySenderIds } : {}),
-              requireMention: "always",
+              requireMention: entityRequireMention,
             },
           },
         },

package/src/outbound.ts

@@ -1,10 +1,13 @@
 import { sendRoomMessage } from "./api/message.api.js";
+import type { SentMessageTracker } from "./sent-message-tracker.js";
 import type { JaguarSocketClient } from "./socket/jaguar.socket.js";
-import type { OmadeusApiOptions } from "./utils/http.util.js";
+import { generateTemporaryId, type OmadeusApiOptions } from "./utils/http.util.js";
 
 export type OutboundDeps = {
   apiOpts: OmadeusApiOptions;
   jaguarSocket: JaguarSocketClient;
+  /** Records messages we send so their socket echoes can be suppressed. */
+  sentTracker?: SentMessageTracker;
 };
 
 export async function sendOmadeusMessage(
@@ -13,11 +16,20 @@ export async function sendOmadeusMessage(
 ): Promise<{ channel: string; messageId: string; chatId: string }> {
   const { to, text } = params;
 
-  const result = await sendRoomMessage(deps.apiOpts, { roomId: to, body: text });
+  const temporaryId = generateTemporaryId();
+  // Register before sending: the socket echo can arrive before this HTTP call
+  // returns, so the temporaryId (and body fallback) must already be tracked.
+  deps.sentTracker?.trackOutbound({ temporaryId, body: text, roomId: to });
+
+  const result = await sendRoomMessage(deps.apiOpts, { roomId: to, body: text, temporaryId });
   if (!result.ok) {
     throw new Error(`Omadeus send failed: ${result.error}`);
   }
 
+  if (typeof result.message?.id === "number") {
+    deps.sentTracker?.trackId(result.message.id);
+  }
+
   return {
     channel: "omadeus",
     messageId: String(result.message?.id ?? ""),

package/src/sent-message-tracker.ts

@@ -0,0 +1,155 @@
+/**
+ * Tracks messages this plugin sent so their Jaguar socket echoes can be
+ * suppressed, instead of dropping every message authored by the logged-in
+ * account.
+ *
+ * OpenClaw sends as the same Omadeus account it listens on, so each outbound
+ * message is broadcast back to us over the socket. We register up to three keys
+ * per send:
+ *
+ * - the client-generated `temporaryId` — known *before* the HTTP round-trip, so
+ *   it matches even when the socket echo beats the send response (the common
+ *   race);
+ * - the backend message `id` — known once the send response returns;
+ * - a normalized copy of the body scoped to its room — a last-resort fallback
+ *   used only for self-authored echoes that somehow arrive without a
+ *   recognizable id. Scoping by room prevents the same text sent in one chat
+ *   from suppressing an identical message in a different chat.
+ *
+ * `id` and `temporaryId` are kept in separate maps. Entries expire after a
+ * short TTL and each map is size-capped, so the tracker cannot grow unbounded.
+ */
+
+const DEFAULT_TTL_MS = 2 * 60 * 1000; // 2 minutes — comfortably covers echo latency.
+const DEFAULT_MAX_ENTRIES = 500;
+
+export type SentMessageTrackerOptions = {
+  ttlMs?: number;
+  maxEntries?: number;
+  now?: () => number;
+};
+
+function normalizeContent(body: string): string {
+  return body.trim();
+}
+
+/** Normalize a room identity so outbound (`"room:123"`/`"123"`) and the socket
+ * echo (numeric `123`) map to the same key. */
+function roomKey(roomId: string | number): string {
+  return String(roomId).replace(/^room:/, "").trim();
+}
+
+/** Build the room-scoped content key, or undefined when the body is empty. */
+function contentKey(roomId: string | number, body: string): string | undefined {
+  const normalized = normalizeContent(body);
+  if (!normalized) return undefined;
+  return `${roomKey(roomId)}\n${normalized}`;
+}
+
+export class SentMessageTracker {
+  private readonly ttlMs: number;
+  private readonly maxEntries: number;
+  private readonly now: () => number;
+  private readonly ids = new Map<number, number>();
+  private readonly temporaryIds = new Map<string, number>();
+  private readonly contents = new Map<string, number>();
+
+  constructor(options: SentMessageTrackerOptions = {}) {
+    this.ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
+    this.maxEntries = options.maxEntries ?? DEFAULT_MAX_ENTRIES;
+    this.now = options.now ?? Date.now;
+  }
+
+  /** Register a client-generated temporaryId. Call before sending. */
+  trackTemporaryId(temporaryId: string): void {
+    if (!temporaryId) return;
+    this.remember(this.temporaryIds, temporaryId);
+  }
+
+  /** Register the backend message id once the send response returns. */
+  trackId(id: number): void {
+    if (!Number.isFinite(id)) return;
+    this.remember(this.ids, id);
+  }
+
+  /** Register a message body, scoped to its room, as a fallback match key. */
+  trackContent(roomId: string | number, body: string): void {
+    const key = contentKey(roomId, body);
+    if (!key) return;
+    this.remember(this.contents, key);
+  }
+
+  /** Convenience: register whichever keys are available for one outbound message. */
+  trackOutbound(params: {
+    temporaryId?: string;
+    id?: number;
+    body?: string;
+    roomId?: string | number;
+  }): void {
+    if (params.temporaryId) this.trackTemporaryId(params.temporaryId);
+    if (typeof params.id === "number") this.trackId(params.id);
+    if (typeof params.body === "string" && params.roomId !== undefined) {
+      this.trackContent(params.roomId, params.body);
+    }
+  }
+
+  /**
+   * Returns true when an inbound socket message is an echo of something we sent.
+   *
+   * `id`/`temporaryId` matches are authoritative. The content fallback only
+   * applies to self-authored messages — the only ones that can form a reply
+   * loop — and is scoped to the message's room, so a different user repeating
+   * our text (or the same text in another room) is never suppressed.
+   */
+  isEcho(msg: {
+    id?: number;
+    temporaryId?: string;
+    body?: string;
+    roomId?: string | number;
+    fromSelf: boolean;
+  }): boolean {
+    if (typeof msg.id === "number" && this.has(this.ids, msg.id)) return true;
+    if (msg.temporaryId && this.has(this.temporaryIds, msg.temporaryId)) return true;
+    if (msg.fromSelf && typeof msg.body === "string" && msg.roomId !== undefined) {
+      const key = contentKey(msg.roomId, msg.body);
+      if (key && this.has(this.contents, key)) return true;
+    }
+    return false;
+  }
+
+  private remember<K>(map: Map<K, number>, key: K): void {
+    // Delete-then-set so re-registered keys move to the end, keeping insertion
+    // order aligned with expiry order (the TTL is constant).
+    map.delete(key);
+    map.set(key, this.now() + this.ttlMs);
+    this.prune(map);
+  }
+
+  private has<K>(map: Map<K, number>, key: K): boolean {
+    const expiry = map.get(key);
+    if (expiry === undefined) return false;
+    if (expiry <= this.now()) {
+      map.delete(key);
+      return false;
+    }
+    return true;
+  }
+
+  private prune<K>(map: Map<K, number>): void {
+    const now = this.now();
+    for (const [key, expiry] of map) {
+      if (expiry <= now) {
+        map.delete(key);
+      } else {
+        // Insertion order matches expiry order, so the first live entry means
+        // everything after it is also live.
+        break;
+      }
+    }
+    while (map.size > this.maxEntries) {
+      const oldest = map.keys().next().value as K | undefined;
+      if (oldest === undefined) break;
+      map.delete(oldest);
+    }
+  }
+}

package/src/setup-core.ts

@@ -1,5 +1,6 @@
 import type { ChannelSetupAdapter } from "openclaw/plugin-sdk/setup";
 import type { OpenClawConfig } from "../runtime-api.js";
+import { resolveOmadeusEnvironment } from "./defaults.js";
 
 function readSetupStringField(input: Record<string, unknown>, key: string): string | undefined {
   const value = input[key];
@@ -29,8 +30,8 @@ export const omadeusSetupAdapter: ChannelSetupAdapter = {
   },
   applyAccountConfig: ({ cfg, input }) => {
     const rawInput = input as Record<string, unknown>;
-    const casUrl = input.httpUrl?.trim() || undefined;
-    const maestroUrl = input.url?.trim() || undefined;
+    const environmentRaw = readSetupStringField(rawInput, "environment");
+    const environment = environmentRaw ? resolveOmadeusEnvironment(environmentRaw) : undefined;
     const email = readSetupStringField(rawInput, "email");
     const password = input.password?.trim() || undefined;
     const organizationId = readSetupNumberField(rawInput, "organizationId");
@@ -51,8 +52,7 @@ export const omadeusSetupAdapter: ChannelSetupAdapter = {
         omadeus: {
           ...omadeusPrevious,
           enabled: true,
-          ...(casUrl ? { casUrl } : {}),
-          ...(maestroUrl ? { maestroUrl } : {}),
+          ...(environment ? { environment } : {}),
           ...(email ? { email } : {}),
           ...(password ? { password } : {}),
           ...(organizationId ? { organizationId } : {}),

package/src/types.ts

@@ -1,3 +1,5 @@
+import type { OmadeusEnvironment } from "./defaults.js";
+
 // ---------------------------------------------------------------------------
 // Omadeus config shape (stored under channels.omadeus in OpenClaw config)
 // ---------------------------------------------------------------------------
@@ -61,13 +63,14 @@ export type OmadeusInboundPolicy = {
 
 export type OmadeusChannelConfig = {
   enabled?: boolean;
-  casUrl?: string;
-  maestroUrl?: string;
+  environment?: OmadeusEnvironment;
   email?: string;
   password?: string;
   organizationId?: number;
   /** Cached Omadeus session JWT obtained during onboarding/startup. */
   sessionToken?: string;
+  /** Environment the cached sessionToken was minted under (must match `environment`). */
+  sessionTokenEnvironment?: OmadeusEnvironment;
   /** Jaguar chat ingress allowlists and mention rules. */
   inbound?: OmadeusInboundPolicy;
 };
@@ -77,6 +80,7 @@ export type ResolvedOmadeusAccount = {
   name?: string;
   enabled: boolean;
   config: OmadeusChannelConfig;
+  environment: OmadeusEnvironment;
   casUrl: string;
   maestroUrl: string;
   email: string;