@kodelyth/matrix 2026.5.42 → 2026.6.2

package/src/matrix/monitor/location.ts

@@ -1,108 +0,0 @@
-import {
-  normalizeLowercaseStringOrEmpty,
-  normalizeOptionalString,
-} from "klaw/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

@@ -1,119 +0,0 @@
-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

@@ -1,256 +0,0 @@
-import { normalizeLowercaseStringOrEmpty } from "klaw/plugin-sdk/string-coerce-runtime";
-import { escapeRegExp } from "klaw/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

@@ -1,197 +0,0 @@
-import { getSessionBindingService } from "klaw/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

@@ -1,30 +0,0 @@
-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;
-}