@gakr-gakr/matrix 0.1.0

package/src/matrix/monitor/location.ts

@@ -0,0 +1,108 @@
+import {
+  normalizeLowercaseStringOrEmpty,
+  normalizeOptionalString,
+} from "autobot/plugin-sdk/string-coerce-runtime";
+import type { LocationMessageEventContent } from "../sdk.js";
+import { formatLocationText, toLocationContext, type NormalizedLocation } from "./runtime-api.js";
+import { EventType } from "./types.js";
+
+export type MatrixLocationPayload = {
+  text: string;
+  context: ReturnType<typeof toLocationContext>;
+};
+
+type GeoUriParams = {
+  latitude: number;
+  longitude: number;
+  accuracy?: number;
+};
+
+function decodeGeoUriParamValue(value: string): string {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+
+function parseGeoUri(value: string): GeoUriParams | null {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return null;
+  }
+  if (!normalizeLowercaseStringOrEmpty(trimmed).startsWith("geo:")) {
+    return null;
+  }
+  const payload = trimmed.slice(4);
+  const [coordsPart, ...paramParts] = payload.split(";");
+  const coords = coordsPart.split(",");
+  if (coords.length < 2) {
+    return null;
+  }
+  const latitude = Number.parseFloat(coords[0] ?? "");
+  const longitude = Number.parseFloat(coords[1] ?? "");
+  if (!Number.isFinite(latitude) || !Number.isFinite(longitude)) {
+    return null;
+  }
+
+  const params = new Map<string, string>();
+  for (const part of paramParts) {
+    const segment = part.trim();
+    if (!segment) {
+      continue;
+    }
+    const eqIndex = segment.indexOf("=");
+    const rawKey = eqIndex === -1 ? segment : segment.slice(0, eqIndex);
+    const rawValue = eqIndex === -1 ? "" : segment.slice(eqIndex + 1);
+    const key = normalizeLowercaseStringOrEmpty(rawKey);
+    if (!key) {
+      continue;
+    }
+    const valuePart = rawValue.trim();
+    params.set(key, valuePart ? decodeGeoUriParamValue(valuePart) : "");
+  }
+
+  const accuracyRaw = params.get("u");
+  const accuracy = accuracyRaw ? Number.parseFloat(accuracyRaw) : undefined;
+
+  return {
+    latitude,
+    longitude,
+    accuracy: Number.isFinite(accuracy) ? accuracy : undefined,
+  };
+}
+
+export function resolveMatrixLocation(params: {
+  eventType: string;
+  content: LocationMessageEventContent;
+}): MatrixLocationPayload | null {
+  const { eventType, content } = params;
+  const isLocation =
+    eventType === EventType.Location ||
+    (eventType === EventType.RoomMessage && content.msgtype === EventType.Location);
+  if (!isLocation) {
+    return null;
+  }
+  const geoUri = normalizeOptionalString(content.geo_uri) ?? "";
+  if (!geoUri) {
+    return null;
+  }
+  const parsed = parseGeoUri(geoUri);
+  if (!parsed) {
+    return null;
+  }
+  const caption = normalizeOptionalString(content.body) ?? "";
+  const location: NormalizedLocation = {
+    latitude: parsed.latitude,
+    longitude: parsed.longitude,
+    accuracy: parsed.accuracy,
+    caption: caption || undefined,
+    source: "pin",
+    isLive: false,
+  };
+
+  return {
+    text: formatLocationText(location),
+    context: toLocationContext(location),
+  };
+}

package/src/matrix/monitor/media.ts

@@ -0,0 +1,119 @@
+import { getMatrixRuntime } from "../../runtime.js";
+import { MatrixMediaSizeLimitError, isMatrixMediaSizeLimitError } from "../media-errors.js";
+import type { MatrixClient } from "../sdk.js";
+
+// Type for encrypted file info
+type EncryptedFile = {
+  url: string;
+  key: {
+    kty: string;
+    key_ops: string[];
+    alg: string;
+    k: string;
+    ext: boolean;
+  };
+  iv: string;
+  hashes: Record<string, string>;
+  v: string;
+};
+
+const MATRIX_MEDIA_DOWNLOAD_IDLE_TIMEOUT_MS = 30_000;
+
+async function fetchMatrixMediaBuffer(params: {
+  client: MatrixClient;
+  mxcUrl: string;
+  maxBytes: number;
+}): Promise<{ buffer: Buffer } | null> {
+  try {
+    const buffer = await params.client.downloadContent(params.mxcUrl, {
+      maxBytes: params.maxBytes,
+      readIdleTimeoutMs: MATRIX_MEDIA_DOWNLOAD_IDLE_TIMEOUT_MS,
+    });
+    return { buffer };
+  } catch (err) {
+    if (isMatrixMediaSizeLimitError(err)) {
+      throw err;
+    }
+    throw new Error(`Matrix media download failed: ${String(err)}`, { cause: err });
+  }
+}
+
+/**
+ * Download and decrypt encrypted media from a Matrix room.
+ * Uses the Matrix crypto adapter's decryptMedia helper.
+ */
+async function fetchEncryptedMediaBuffer(params: {
+  client: MatrixClient;
+  file: EncryptedFile;
+  maxBytes: number;
+}): Promise<{ buffer: Buffer } | null> {
+  if (!params.client.crypto) {
+    throw new Error("Cannot decrypt media: crypto not enabled");
+  }
+
+  const decrypted = await params.client.crypto.decryptMedia(
+    params.file as Parameters<typeof params.client.crypto.decryptMedia>[0],
+    {
+      maxBytes: params.maxBytes,
+      readIdleTimeoutMs: MATRIX_MEDIA_DOWNLOAD_IDLE_TIMEOUT_MS,
+    },
+  );
+
+  if (decrypted.byteLength > params.maxBytes) {
+    throw new MatrixMediaSizeLimitError();
+  }
+
+  return { buffer: decrypted };
+}
+
+export async function downloadMatrixMedia(params: {
+  client: MatrixClient;
+  mxcUrl: string;
+  contentType?: string;
+  sizeBytes?: number;
+  maxBytes: number;
+  file?: EncryptedFile;
+  originalFilename?: string;
+}): Promise<{
+  path: string;
+  contentType?: string;
+  placeholder: string;
+} | null> {
+  let fetched: { buffer: Buffer; headerType?: string } | null;
+  if (typeof params.sizeBytes === "number" && params.sizeBytes > params.maxBytes) {
+    throw new MatrixMediaSizeLimitError();
+  }
+
+  if (params.file) {
+    // Encrypted media
+    fetched = await fetchEncryptedMediaBuffer({
+      client: params.client,
+      file: params.file,
+      maxBytes: params.maxBytes,
+    });
+  } else {
+    // Unencrypted media
+    fetched = await fetchMatrixMediaBuffer({
+      client: params.client,
+      mxcUrl: params.mxcUrl,
+      maxBytes: params.maxBytes,
+    });
+  }
+
+  if (!fetched) {
+    return null;
+  }
+  const headerType = params.contentType ?? undefined;
+  const saved = await getMatrixRuntime().channel.media.saveMediaBuffer(
+    fetched.buffer,
+    headerType,
+    "inbound",
+    params.maxBytes,
+    params.originalFilename,
+  );
+  return {
+    path: saved.path,
+    contentType: saved.contentType,
+    placeholder: "[matrix media]",
+  };
+}

package/src/matrix/monitor/mentions.ts

@@ -0,0 +1,256 @@
+import { normalizeLowercaseStringOrEmpty } from "autobot/plugin-sdk/string-coerce-runtime";
+import { escapeRegExp } from "autobot/plugin-sdk/text-utility-runtime";
+import { getMatrixRuntime } from "../../runtime.js";
+import type { RoomMessageEventContent } from "./types.js";
+
+const HTML_ENTITY_REPLACEMENTS: Readonly<Record<string, string>> = {
+  amp: "&",
+  apos: "'",
+  gt: ">",
+  lt: "<",
+  nbsp: " ",
+  quot: '"',
+};
+const MAX_UNICODE_SCALAR_VALUE = 0x10ffff;
+
+function decodeNumericHtmlEntity(match: string, rawValue: string, radix: 10 | 16): string {
+  const codePoint = Number.parseInt(rawValue, radix);
+  if (
+    !Number.isSafeInteger(codePoint) ||
+    codePoint < 0 ||
+    codePoint > MAX_UNICODE_SCALAR_VALUE ||
+    (codePoint >= 0xd800 && codePoint <= 0xdfff)
+  ) {
+    return match;
+  }
+  return String.fromCodePoint(codePoint);
+}
+
+function decodeHtmlEntities(value: string): string {
+  return value.replace(/&(#x?[0-9a-f]+|\w+);/gi, (match, entity: string) => {
+    const normalized = normalizeLowercaseStringOrEmpty(entity);
+    if (normalized.startsWith("#x")) {
+      return decodeNumericHtmlEntity(match, normalized.slice(2), 16);
+    }
+    if (normalized.startsWith("#")) {
+      return decodeNumericHtmlEntity(match, normalized.slice(1), 10);
+    }
+    return HTML_ENTITY_REPLACEMENTS[normalized] ?? match;
+  });
+}
+
+function normalizeVisibleMentionText(value: string): string {
+  return normalizeLowercaseStringOrEmpty(
+    decodeHtmlEntities(
+      value.replace(/<[^>]+>/g, " ").replace(/[\u200b-\u200f\u202a-\u202e\u2060-\u206f]/g, ""),
+    ).replace(/\s+/g, " "),
+  );
+}
+
+function extractVisibleMentionText(value?: string): string {
+  return normalizeVisibleMentionText(value ?? "");
+}
+
+function resolveMatrixUserLocalpart(userId: string): string | null {
+  const trimmed = userId.trim();
+  if (!trimmed.startsWith("@")) {
+    return null;
+  }
+  const colonIndex = trimmed.indexOf(":");
+  if (colonIndex <= 1) {
+    return null;
+  }
+  return trimmed.slice(1, colonIndex).trim() || null;
+}
+
+function resolveMatrixMentionPrefixCandidates(params: {
+  userId?: string | null;
+  displayName?: string | null;
+}): string[] {
+  const candidates: string[] = [];
+  const seen = new Set<string>();
+
+  const append = (candidate?: string | null) => {
+    const trimmed = candidate?.trim();
+    if (!trimmed) {
+      return;
+    }
+    const normalized = normalizeLowercaseStringOrEmpty(trimmed);
+    if (seen.has(normalized)) {
+      return;
+    }
+    seen.add(normalized);
+    candidates.push(trimmed);
+  };
+
+  append(params.userId);
+  const localpart = params.userId ? resolveMatrixUserLocalpart(params.userId) : null;
+  append(localpart ? `@${localpart}` : null);
+  append(params.displayName);
+  append(params.displayName ? `@${params.displayName}` : null);
+
+  return candidates;
+}
+
+function stripMatchedMatrixMentionPrefix(text: string, pattern: RegExp): string | null {
+  const match = text.match(pattern);
+  if (!match) {
+    return null;
+  }
+  return text.slice(match[0].length).trimStart();
+}
+
+function stripNativeMatrixMentionPrefix(text: string, candidate: string): string | null {
+  const pattern = new RegExp(`^\\s*${escapeRegExp(candidate)}(?:\\s*[:,])?(?:\\s+|$)`, "i");
+  return stripMatchedMatrixMentionPrefix(text, pattern);
+}
+
+function stripRegexMatrixMentionPrefix(text: string, pattern: RegExp): string | null {
+  const flags = pattern.flags.replace(/[gy]/g, "");
+  const anchored = new RegExp(`^\\s*(?:${pattern.source})(?:\\s*[:,])?(?:\\s+|$)`, flags);
+  return stripMatchedMatrixMentionPrefix(text, anchored);
+}
+
+export function stripMatrixMentionPrefix(params: {
+  text: string;
+  userId?: string | null;
+  displayName?: string | null;
+  mentionRegexes?: RegExp[];
+}): string {
+  const text = params.text;
+  if (!text) {
+    return text;
+  }
+
+  for (const candidate of resolveMatrixMentionPrefixCandidates(params)) {
+    const stripped = stripNativeMatrixMentionPrefix(text, candidate);
+    if (stripped !== null) {
+      return stripped;
+    }
+  }
+  for (const pattern of params.mentionRegexes ?? []) {
+    const stripped = stripRegexMatrixMentionPrefix(text, pattern);
+    if (stripped !== null) {
+      return stripped;
+    }
+  }
+  return text;
+}
+
+function isVisibleMentionLabel(params: {
+  text: string;
+  userId: string;
+  mentionRegexes: RegExp[];
+  displayName?: string | null;
+}): boolean {
+  const cleaned = extractVisibleMentionText(params.text);
+  if (!cleaned) {
+    return false;
+  }
+  if (params.mentionRegexes.some((pattern) => pattern.test(cleaned))) {
+    return true;
+  }
+  const localpart = resolveMatrixUserLocalpart(params.userId);
+  const candidates = [
+    extractVisibleMentionText(params.userId),
+    localpart ? extractVisibleMentionText(localpart) : null,
+    localpart ? extractVisibleMentionText(`@${localpart}`) : null,
+    params.displayName ? extractVisibleMentionText(params.displayName) : null,
+    params.displayName ? extractVisibleMentionText(`@${params.displayName}`) : null,
+  ].filter((value): value is string => Boolean(value));
+  return candidates.includes(cleaned);
+}
+
+function hasVisibleRoomMention(value?: string): boolean {
+  const cleaned = extractVisibleMentionText(value);
+  return /(^|[^a-z0-9_])@room\b/i.test(cleaned);
+}
+
+/**
+ * Check if formatted_body contains a matrix.to link whose visible label still
+ * looks like a real mention for the given user. Do not trust href alone, since
+ * senders can hide arbitrary matrix.to links behind unrelated link text.
+ * Many Matrix clients (including Element) use HTML links in formatted_body instead of
+ * or in addition to the m.mentions field.
+ */
+function checkFormattedBodyMention(params: {
+  formattedBody?: string;
+  userId: string;
+  displayName?: string | null;
+  mentionRegexes: RegExp[];
+}): boolean {
+  if (!params.formattedBody || !params.userId) {
+    return false;
+  }
+  const anchorPattern = /<a\b[^>]*href=(["'])(https:\/\/matrix\.to\/#[^"']+)\1[^>]*>(.*?)<\/a>/gis;
+  for (const match of params.formattedBody.matchAll(anchorPattern)) {
+    const href = match[2];
+    const visibleLabel = match[3] ?? "";
+    if (!href) {
+      continue;
+    }
+    try {
+      const parsed = new URL(href);
+      const fragmentTarget = decodeURIComponent(parsed.hash.replace(/^#\/?/, "").trim());
+      if (fragmentTarget !== params.userId.trim()) {
+        continue;
+      }
+      if (
+        isVisibleMentionLabel({
+          text: visibleLabel,
+          userId: params.userId,
+          mentionRegexes: params.mentionRegexes,
+          displayName: params.displayName,
+        })
+      ) {
+        return true;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return false;
+}
+
+export function resolveMentions(params: {
+  content: RoomMessageEventContent;
+  userId?: string | null;
+  displayName?: string | null;
+  text?: string;
+  mentionRegexes: RegExp[];
+}) {
+  const mentions = params.content["m.mentions"];
+  const mentionedUsers = Array.isArray(mentions?.user_ids)
+    ? new Set(mentions.user_ids)
+    : new Set<string>();
+  const textMentioned = getMatrixRuntime().channel.mentions.matchesMentionPatterns(
+    params.text ?? "",
+    params.mentionRegexes,
+  );
+  const visibleRoomMention =
+    hasVisibleRoomMention(params.text) || hasVisibleRoomMention(params.content.formatted_body);
+
+  // Check formatted_body for matrix.to mention links (legacy/alternative mention format)
+  const mentionedInFormattedBody = params.userId
+    ? checkFormattedBodyMention({
+        formattedBody: params.content.formatted_body,
+        userId: params.userId,
+        displayName: params.displayName,
+        mentionRegexes: params.mentionRegexes,
+      })
+    : false;
+  // Matrix clients can mention users through m.mentions metadata plus a visible
+  // Matrix URI label in formatted_body. Keep the visible-mention requirement so
+  // hidden metadata-only mentions do not trigger the handler.
+  const metadataBackedUserMention = Boolean(
+    params.userId &&
+    mentionedUsers.has(params.userId) &&
+    (mentionedInFormattedBody || textMentioned),
+  );
+  const metadataBackedRoomMention = Boolean(mentions?.room) && visibleRoomMention;
+  const explicitMention =
+    mentionedInFormattedBody || metadataBackedUserMention || metadataBackedRoomMention;
+
+  const wasMentioned = explicitMention || textMentioned || visibleRoomMention;
+  return { wasMentioned, hasExplicitMention: explicitMention };
+}

package/src/matrix/monitor/reaction-events.ts

@@ -0,0 +1,197 @@
+import { getSessionBindingService } from "autobot/plugin-sdk/session-binding-runtime";
+import {
+  resolveMatrixApprovalReactionTargetWithPersistence,
+  unregisterMatrixApprovalReactionTarget,
+} from "../../approval-reactions.js";
+import type { CoreConfig } from "../../types.js";
+import { resolveMatrixAccountConfig } from "../account-config.js";
+import { extractMatrixReactionAnnotation } from "../reaction-common.js";
+import type { MatrixClient } from "../sdk.js";
+import { resolveMatrixInboundRoute } from "./route.js";
+import type { PluginRuntime } from "./runtime-api.js";
+import { resolveMatrixThreadRootId, resolveMatrixThreadRouting } from "./threads.js";
+import type { MatrixRawEvent, RoomMessageEventContent } from "./types.js";
+
+let approvalReactionAuthPromise:
+  | Promise<typeof import("../../approval-reaction-auth.js")>
+  | undefined;
+let execApprovalResolverPromise:
+  | Promise<typeof import("../../exec-approval-resolver.js")>
+  | undefined;
+
+function loadApprovalReactionAuth(): Promise<typeof import("../../approval-reaction-auth.js")> {
+  approvalReactionAuthPromise ??= import("../../approval-reaction-auth.js");
+  return approvalReactionAuthPromise;
+}
+
+function loadExecApprovalResolver(): Promise<typeof import("../../exec-approval-resolver.js")> {
+  execApprovalResolverPromise ??= import("../../exec-approval-resolver.js");
+  return execApprovalResolverPromise;
+}
+
+export type MatrixReactionNotificationMode = "off" | "own";
+
+export function resolveMatrixReactionNotificationMode(params: {
+  cfg: CoreConfig;
+  accountId: string;
+}): MatrixReactionNotificationMode {
+  const matrixConfig = params.cfg.channels?.matrix;
+  const accountConfig = resolveMatrixAccountConfig({
+    cfg: params.cfg,
+    accountId: params.accountId,
+  });
+  return accountConfig.reactionNotifications ?? matrixConfig?.reactionNotifications ?? "own";
+}
+
+async function maybeResolveMatrixApprovalReaction(params: {
+  cfg: CoreConfig;
+  accountId: string;
+  senderId: string;
+  target: Awaited<ReturnType<typeof resolveMatrixApprovalReactionTargetWithPersistence>>;
+  targetEventId: string;
+  roomId: string;
+  logVerboseMessage: (message: string) => void;
+}): Promise<boolean> {
+  if (!params.target) {
+    return false;
+  }
+  const approvalKind = params.target.approvalId.startsWith("plugin:") ? "plugin" : "exec";
+  const { isMatrixApprovalReactionAuthorizedSender } = await loadApprovalReactionAuth();
+  if (!isMatrixApprovalReactionAuthorizedSender({ ...params, approvalKind })) {
+    return false;
+  }
+  const { isApprovalNotFoundError, resolveMatrixApproval } = await loadExecApprovalResolver();
+  try {
+    await resolveMatrixApproval({
+      cfg: params.cfg,
+      approvalId: params.target.approvalId,
+      decision: params.target.decision,
+      senderId: params.senderId,
+    });
+    params.logVerboseMessage(
+      `matrix: approval reaction resolved id=${params.target.approvalId} sender=${params.senderId} decision=${params.target.decision}`,
+    );
+    return true;
+  } catch (err) {
+    if (isApprovalNotFoundError(err)) {
+      unregisterMatrixApprovalReactionTarget({
+        roomId: params.roomId,
+        eventId: params.targetEventId,
+      });
+      params.logVerboseMessage(
+        `matrix: approval reaction ignored for expired approval id=${params.target.approvalId} sender=${params.senderId}`,
+      );
+      return true;
+    }
+    params.logVerboseMessage(
+      `matrix: approval reaction failed id=${params.target.approvalId} sender=${params.senderId}: ${String(err)}`,
+    );
+    return true;
+  }
+}
+
+export async function handleInboundMatrixReaction(params: {
+  client: MatrixClient;
+  core: PluginRuntime;
+  cfg: CoreConfig;
+  accountId: string;
+  roomId: string;
+  event: MatrixRawEvent;
+  senderId: string;
+  senderLabel: string;
+  selfUserId: string;
+  isDirectMessage: boolean;
+  logVerboseMessage: (message: string) => void;
+}): Promise<void> {
+  const reaction = extractMatrixReactionAnnotation(params.event.content);
+  if (!reaction?.eventId) {
+    return;
+  }
+  if (params.senderId === params.selfUserId) {
+    return;
+  }
+  const approvalTarget = await resolveMatrixApprovalReactionTargetWithPersistence({
+    roomId: params.roomId,
+    eventId: reaction.eventId,
+    reactionKey: reaction.key,
+  });
+  if (
+    await maybeResolveMatrixApprovalReaction({
+      cfg: params.cfg,
+      accountId: params.accountId,
+      senderId: params.senderId,
+      target: approvalTarget,
+      targetEventId: reaction.eventId,
+      roomId: params.roomId,
+      logVerboseMessage: params.logVerboseMessage,
+    })
+  ) {
+    return;
+  }
+  const notificationMode = resolveMatrixReactionNotificationMode({
+    cfg: params.cfg,
+    accountId: params.accountId,
+  });
+  if (notificationMode === "off") {
+    return;
+  }
+
+  const targetEvent = await params.client.getEvent(params.roomId, reaction.eventId).catch((err) => {
+    params.logVerboseMessage(
+      `matrix: failed resolving reaction target room=${params.roomId} id=${reaction.eventId}: ${String(err)}`,
+    );
+    return null;
+  });
+  const targetSender =
+    targetEvent && typeof targetEvent.sender === "string" ? targetEvent.sender.trim() : "";
+  if (!targetSender) {
+    return;
+  }
+  if (notificationMode === "own" && targetSender !== params.selfUserId) {
+    return;
+  }
+
+  const targetContent =
+    targetEvent && targetEvent.content && typeof targetEvent.content === "object"
+      ? (targetEvent.content as RoomMessageEventContent)
+      : undefined;
+  const threadRootId = targetContent
+    ? resolveMatrixThreadRootId({
+        event: targetEvent as MatrixRawEvent,
+        content: targetContent,
+      })
+    : undefined;
+  const accountConfig = resolveMatrixAccountConfig({
+    cfg: params.cfg,
+    accountId: params.accountId,
+  });
+  const thread = resolveMatrixThreadRouting({
+    isDirectMessage: params.isDirectMessage,
+    threadReplies: accountConfig.threadReplies ?? "inbound",
+    dmThreadReplies: accountConfig.dm?.threadReplies,
+    messageId: reaction.eventId,
+    threadRootId,
+  });
+  const { route, runtimeBindingId } = resolveMatrixInboundRoute({
+    cfg: params.cfg,
+    accountId: params.accountId,
+    roomId: params.roomId,
+    senderId: params.senderId,
+    isDirectMessage: params.isDirectMessage,
+    dmSessionScope: accountConfig.dm?.sessionScope ?? "per-user",
+    threadId: thread.threadId,
+    eventTs: params.event.origin_server_ts,
+    resolveAgentRoute: params.core.channel.routing.resolveAgentRoute,
+  });
+  if (runtimeBindingId) {
+    getSessionBindingService().touch(runtimeBindingId, params.event.origin_server_ts);
+  }
+  const text = `Matrix reaction added: ${reaction.key} by ${params.senderLabel} on msg ${reaction.eventId}`;
+  params.core.system.enqueueSystemEvent(text, {
+    sessionKey: route.sessionKey,
+    contextKey: `matrix:reaction:add:${params.roomId}:${reaction.eventId}:${params.senderId}:${reaction.key}`,
+  });
+  params.logVerboseMessage(
+    `matrix: reaction event enqueued room=${params.roomId} target=${reaction.eventId} sender=${params.senderId} emoji=${reaction.key}`,
+  );
+}

package/src/matrix/monitor/recent-invite.ts

@@ -0,0 +1,30 @@
+import type { MatrixRoomConfig } from "../../types.js";
+import type { MatrixRoomInfo } from "./room-info.js";
+import { resolveMatrixRoomConfig } from "./rooms.js";
+
+export function shouldPromoteRecentInviteRoom(params: {
+  roomId: string;
+  roomInfo: Pick<
+    MatrixRoomInfo,
+    "name" | "canonicalAlias" | "altAliases" | "nameResolved" | "aliasesResolved"
+  >;
+  rooms?: Record<string, MatrixRoomConfig>;
+}): boolean {
+  if (!params.roomInfo.nameResolved || !params.roomInfo.aliasesResolved) {
+    return false;
+  }
+
+  const roomAliases = [params.roomInfo.canonicalAlias ?? "", ...params.roomInfo.altAliases].filter(
+    Boolean,
+  );
+  if ((params.roomInfo.name?.trim() ?? "") || roomAliases.length > 0) {
+    return false;
+  }
+
+  const roomConfig = resolveMatrixRoomConfig({
+    rooms: params.rooms,
+    roomId: params.roomId,
+    aliases: roomAliases,
+  });
+  return roomConfig.matchSource === undefined;
+}