@kodelyth/matrix 2026.5.42 → 2026.6.1

package/src/matrix/actions/polls.ts

@@ -1,109 +0,0 @@
-import {
-  buildPollResponseContent,
-  isPollStartType,
-  parsePollStart,
-  type PollStartContent,
-} from "../poll-types.js";
-import { withResolvedRoomAction } from "./client.js";
-import type { MatrixActionClientOpts } from "./types.js";
-
-function normalizeOptionIndexes(indexes: number[]): number[] {
-  const normalized = indexes
-    .map((index) => Math.trunc(index))
-    .filter((index) => Number.isFinite(index) && index > 0);
-  return Array.from(new Set(normalized));
-}
-
-function normalizeOptionIds(optionIds: string[]): string[] {
-  return Array.from(
-    new Set(optionIds.map((optionId) => optionId.trim()).filter((optionId) => optionId.length > 0)),
-  );
-}
-
-function resolveSelectedAnswerIds(params: {
-  optionIds?: string[];
-  optionIndexes?: number[];
-  pollContent: PollStartContent;
-}): { answerIds: string[]; labels: string[]; maxSelections: number } {
-  const parsed = parsePollStart(params.pollContent);
-  if (!parsed) {
-    throw new Error("Matrix poll vote requires a valid poll start event.");
-  }
-
-  const selectedById = normalizeOptionIds(params.optionIds ?? []);
-  const selectedByIndex = normalizeOptionIndexes(params.optionIndexes ?? []).map((index) => {
-    const answer = parsed.answers[index - 1];
-    if (!answer) {
-      throw new Error(
-        `Matrix poll option index ${index} is out of range for a poll with ${parsed.answers.length} options.`,
-      );
-    }
-    return answer.id;
-  });
-
-  const answerIds = normalizeOptionIds([...selectedById, ...selectedByIndex]);
-  if (answerIds.length === 0) {
-    throw new Error("Matrix poll vote requires at least one poll option id or index.");
-  }
-  if (answerIds.length > parsed.maxSelections) {
-    throw new Error(
-      `Matrix poll allows at most ${parsed.maxSelections} selection${parsed.maxSelections === 1 ? "" : "s"}.`,
-    );
-  }
-
-  const answerMap = new Map(parsed.answers.map((answer) => [answer.id, answer.text] as const));
-  const labels = answerIds.map((answerId) => {
-    const label = answerMap.get(answerId);
-    if (!label) {
-      throw new Error(
-        `Matrix poll option id "${answerId}" is not valid for poll ${parsed.question}.`,
-      );
-    }
-    return label;
-  });
-
-  return {
-    answerIds,
-    labels,
-    maxSelections: parsed.maxSelections,
-  };
-}
-
-export async function voteMatrixPoll(
-  roomId: string,
-  pollId: string,
-  opts: MatrixActionClientOpts & {
-    optionId?: string;
-    optionIds?: string[];
-    optionIndex?: number;
-    optionIndexes?: number[];
-  } = {},
-) {
-  return await withResolvedRoomAction(roomId, opts, async (client, resolvedRoom) => {
-    const pollEvent = await client.getEvent(resolvedRoom, pollId);
-    const eventType = typeof pollEvent.type === "string" ? pollEvent.type : "";
-    if (!isPollStartType(eventType)) {
-      throw new Error(`Event ${pollId} is not a Matrix poll start event.`);
-    }
-
-    const { answerIds, labels, maxSelections } = resolveSelectedAnswerIds({
-      optionIds: [...(opts.optionIds ?? []), ...(opts.optionId ? [opts.optionId] : [])],
-      optionIndexes: [
-        ...(opts.optionIndexes ?? []),
-        ...(opts.optionIndex !== undefined ? [opts.optionIndex] : []),
-      ],
-      pollContent: pollEvent.content as PollStartContent,
-    });
-
-    const content = buildPollResponseContent(pollId, answerIds);
-    const eventId = await client.sendEvent(resolvedRoom, "m.poll.response", content);
-    return {
-      eventId: eventId ?? null,
-      roomId: resolvedRoom,
-      pollId,
-      answerIds,
-      labels,
-      maxSelections,
-    };
-  });
-}

package/src/matrix/actions/profile.ts

@@ -1,37 +0,0 @@
-import { getMatrixRuntime } from "../../runtime.js";
-import { syncMatrixOwnProfile, type MatrixProfileSyncResult } from "../profile.js";
-import { withResolvedActionClient } from "./client.js";
-import type { MatrixActionClientOpts } from "./types.js";
-
-export async function updateMatrixOwnProfile(
-  opts: MatrixActionClientOpts & {
-    displayName?: string;
-    avatarUrl?: string;
-    avatarPath?: string;
-  } = {},
-): Promise<MatrixProfileSyncResult> {
-  const displayName = opts.displayName?.trim();
-  const avatarUrl = opts.avatarUrl?.trim();
-  const avatarPath = opts.avatarPath?.trim();
-  const runtime = getMatrixRuntime();
-  return await withResolvedActionClient(
-    opts,
-    async (client) => {
-      const userId = await client.getUserId();
-      return await syncMatrixOwnProfile({
-        client,
-        userId,
-        displayName: displayName || undefined,
-        avatarUrl: avatarUrl || undefined,
-        avatarPath: avatarPath || undefined,
-        loadAvatarFromUrl: async (url, maxBytes) => await runtime.media.loadWebMedia(url, maxBytes),
-        loadAvatarFromPath: async (path, maxBytes) =>
-          await runtime.media.loadWebMedia(path, {
-            maxBytes,
-            localRoots: opts.mediaLocalRoots,
-          }),
-      });
-    },
-    "persist",
-  );
-}

package/src/matrix/actions/reactions.ts

@@ -1,59 +0,0 @@
-import {
-  buildMatrixReactionRelationsPath,
-  selectOwnMatrixReactionEventIds,
-  summarizeMatrixReactionEvents,
-} from "../reaction-common.js";
-import { withResolvedRoomAction } from "./client.js";
-import { resolveMatrixActionLimit } from "./limits.js";
-import {
-  type MatrixActionClientOpts,
-  type MatrixRawEvent,
-  type MatrixReactionSummary,
-} from "./types.js";
-
-type ActionClient = NonNullable<MatrixActionClientOpts["client"]>;
-
-async function listMatrixReactionEvents(
-  client: ActionClient,
-  roomId: string,
-  messageId: string,
-  limit: number,
-): Promise<MatrixRawEvent[]> {
-  const res = (await client.doRequest("GET", buildMatrixReactionRelationsPath(roomId, messageId), {
-    dir: "b",
-    limit,
-  })) as { chunk?: MatrixRawEvent[] };
-  return Array.isArray(res.chunk) ? res.chunk : [];
-}
-
-export async function listMatrixReactions(
-  roomId: string,
-  messageId: string,
-  opts: MatrixActionClientOpts & { limit?: number } = {},
-): Promise<MatrixReactionSummary[]> {
-  return await withResolvedRoomAction(roomId, opts, async (client, resolvedRoom) => {
-    const limit = resolveMatrixActionLimit(opts.limit, 100);
-    const chunk = await listMatrixReactionEvents(client, resolvedRoom, messageId, limit);
-    return summarizeMatrixReactionEvents(chunk);
-  });
-}
-
-export async function removeMatrixReactions(
-  roomId: string,
-  messageId: string,
-  opts: MatrixActionClientOpts & { emoji?: string } = {},
-): Promise<{ removed: number }> {
-  return await withResolvedRoomAction(roomId, opts, async (client, resolvedRoom) => {
-    const chunk = await listMatrixReactionEvents(client, resolvedRoom, messageId, 200);
-    const userId = await client.getUserId();
-    if (!userId) {
-      return { removed: 0 };
-    }
-    const toRemove = selectOwnMatrixReactionEventIds(chunk, userId, opts.emoji);
-    if (toRemove.length === 0) {
-      return { removed: 0 };
-    }
-    await Promise.all(toRemove.map((id) => client.redactEvent(resolvedRoom, id)));
-    return { removed: toRemove.length };
-  });
-}

package/src/matrix/actions/room.ts

@@ -1,71 +0,0 @@
-import { resolveMatrixRoomId } from "../send.js";
-import { withResolvedActionClient, withResolvedRoomAction } from "./client.js";
-import { EventType, type MatrixActionClientOpts } from "./types.js";
-
-export async function getMatrixMemberInfo(
-  userId: string,
-  opts: MatrixActionClientOpts & { roomId?: string } = {},
-) {
-  return await withResolvedActionClient(opts, async (client) => {
-    const roomId = opts.roomId ? await resolveMatrixRoomId(client, opts.roomId) : undefined;
-    const profile = await client.getUserProfile(userId);
-    // Membership and power levels are not included in profile calls; fetch state separately if needed.
-    return {
-      userId,
-      profile: {
-        displayName: profile?.displayname ?? null,
-        avatarUrl: profile?.avatar_url ?? null,
-      },
-      membership: null, // Would need separate room state query
-      powerLevel: null, // Would need separate power levels state query
-      displayName: profile?.displayname ?? null,
-      roomId: roomId ?? null,
-    };
-  });
-}
-
-export async function getMatrixRoomInfo(roomId: string, opts: MatrixActionClientOpts = {}) {
-  return await withResolvedRoomAction(roomId, opts, async (client, resolvedRoom) => {
-    let name: string | null = null;
-    let topic: string | null = null;
-    let canonicalAlias: string | null = null;
-    let memberCount: number | null = null;
-
-    try {
-      const nameState = await client.getRoomStateEvent(resolvedRoom, "m.room.name", "");
-      name = typeof nameState?.name === "string" ? nameState.name : null;
-    } catch {
-      // ignore
-    }
-
-    try {
-      const topicState = await client.getRoomStateEvent(resolvedRoom, EventType.RoomTopic, "");
-      topic = typeof topicState?.topic === "string" ? topicState.topic : null;
-    } catch {
-      // ignore
-    }
-
-    try {
-      const aliasState = await client.getRoomStateEvent(resolvedRoom, "m.room.canonical_alias", "");
-      canonicalAlias = typeof aliasState?.alias === "string" ? aliasState.alias : null;
-    } catch {
-      // ignore
-    }
-
-    try {
-      const members = await client.getJoinedRoomMembers(resolvedRoom);
-      memberCount = members.length;
-    } catch {
-      // ignore
-    }
-
-    return {
-      roomId: resolvedRoom,
-      name,
-      topic,
-      canonicalAlias,
-      altAliases: [], // Would need separate query
-      memberCount,
-    };
-  });
-}

package/src/matrix/actions/summary.ts

@@ -1,88 +0,0 @@
-import { isMatrixNotFoundError } from "../errors.js";
-import { resolveMatrixMessageAttachment, resolveMatrixMessageBody } from "../media-text.js";
-import { fetchMatrixPollMessageSummary } from "../poll-summary.js";
-import type { MatrixClient } from "../sdk.js";
-import {
-  EventType,
-  type MatrixMessageSummary,
-  type MatrixRawEvent,
-  type RoomMessageEventContent,
-  type RoomPinnedEventsEventContent,
-} from "./types.js";
-
-export function summarizeMatrixRawEvent(event: MatrixRawEvent): MatrixMessageSummary {
-  const content = event.content as RoomMessageEventContent;
-  const relates = content["m.relates_to"];
-  let relType: string | undefined;
-  let eventId: string | undefined;
-  if (relates) {
-    if ("rel_type" in relates) {
-      relType = relates.rel_type;
-      eventId = relates.event_id;
-    } else if ("m.in_reply_to" in relates) {
-      eventId = relates["m.in_reply_to"]?.event_id;
-    }
-  }
-  const relatesTo =
-    relType || eventId
-      ? {
-          relType,
-          eventId,
-        }
-      : undefined;
-  return {
-    eventId: event.event_id,
-    sender: event.sender,
-    body: resolveMatrixMessageBody({
-      body: content.body,
-      filename: content.filename,
-      msgtype: content.msgtype,
-    }),
-    msgtype: content.msgtype,
-    attachment: resolveMatrixMessageAttachment({
-      body: content.body,
-      filename: content.filename,
-      msgtype: content.msgtype,
-    }),
-    timestamp: event.origin_server_ts,
-    relatesTo,
-  };
-}
-
-export async function readPinnedEvents(client: MatrixClient, roomId: string): Promise<string[]> {
-  try {
-    const content = (await client.getRoomStateEvent(
-      roomId,
-      EventType.RoomPinnedEvents,
-      "",
-    )) as RoomPinnedEventsEventContent;
-    const pinned = content.pinned;
-    return pinned.filter((id) => id.trim().length > 0);
-  } catch (err: unknown) {
-    if (isMatrixNotFoundError(err)) {
-      return [];
-    }
-    throw err;
-  }
-}
-
-export async function fetchEventSummary(
-  client: MatrixClient,
-  roomId: string,
-  eventId: string,
-): Promise<MatrixMessageSummary | null> {
-  try {
-    const raw = (await client.getEvent(roomId, eventId)) as unknown as MatrixRawEvent;
-    if (raw.unsigned?.redacted_because) {
-      return null;
-    }
-    const pollSummary = await fetchMatrixPollMessageSummary(client, roomId, raw);
-    if (pollSummary) {
-      return pollSummary;
-    }
-    return summarizeMatrixRawEvent(raw);
-  } catch {
-    // Event not found, redacted, or inaccessible - return null
-    return null;
-  }
-}

package/src/matrix/actions/types.ts

@@ -1,63 +0,0 @@
-import type { CoreConfig } from "../../types.js";
-import { MATRIX_REACTION_EVENT_TYPE } from "../reaction-common.js";
-import type { MatrixClient, MessageEventContent } from "../sdk.js";
-export type { MatrixRawEvent } from "../sdk.js";
-export type { MatrixReactionSummary } from "../reaction-common.js";
-
-export const EventType = {
-  RoomMessage: "m.room.message",
-  RoomPinnedEvents: "m.room.pinned_events",
-  RoomTopic: "m.room.topic",
-  Reaction: MATRIX_REACTION_EVENT_TYPE,
-} as const;
-
-export type RoomMessageEventContent = MessageEventContent & {
-  msgtype: string;
-  body: string;
-  "m.new_content"?: RoomMessageEventContent;
-  "m.relates_to"?: {
-    rel_type?: string;
-    event_id?: string;
-    "m.in_reply_to"?: { event_id?: string };
-  };
-};
-
-export type RoomPinnedEventsEventContent = {
-  pinned: string[];
-};
-
-export type MatrixActionClientOpts = {
-  client?: MatrixClient;
-  cfg?: CoreConfig;
-  mediaLocalRoots?: readonly string[];
-  timeoutMs?: number;
-  accountId?: string | null;
-  readiness?: "none" | "prepared" | "started";
-};
-
-export type MatrixMessageSummary = {
-  eventId?: string;
-  sender?: string;
-  body?: string;
-  msgtype?: string;
-  attachment?: MatrixMessageAttachmentSummary;
-  timestamp?: number;
-  relatesTo?: {
-    relType?: string;
-    eventId?: string;
-    key?: string;
-  };
-};
-
-export type MatrixMessageAttachmentKind = "audio" | "file" | "image" | "sticker" | "video";
-
-export type MatrixMessageAttachmentSummary = {
-  kind: MatrixMessageAttachmentKind;
-  caption?: string;
-  filename?: string;
-};
-
-export type MatrixActionClient = {
-  client: MatrixClient;
-  stopOnDone: boolean;
-};