@archipelagolab/lobi 1.0.0

package/src/matrix/monitor/room-info.test.ts

@@ -0,0 +1,201 @@
+import { describe, expect, it, vi } from "vitest";
+import type { MatrixClient } from "../sdk.js";
+import { createMatrixRoomInfoResolver } from "./room-info.js";
+
+type RoomStateHandler = (
+  roomId: string,
+  eventType: string,
+  stateKey: string,
+) => Promise<Record<string, unknown>>;
+
+type RoomInfoClientStub = MatrixClient & {
+  getRoomStateEvent: ReturnType<typeof vi.fn>;
+};
+
+function createRoomStateClient(handler: RoomStateHandler): RoomInfoClientStub {
+  return {
+    getRoomStateEvent: vi.fn(handler),
+  } as unknown as RoomInfoClientStub;
+}
+
+function createClientStub() {
+  return createRoomStateClient(async (roomId, eventType, stateKey) => {
+    if (eventType === "m.room.name") {
+      return { name: `Room ${roomId}` };
+    }
+    if (eventType === "m.room.canonical_alias") {
+      return {
+        alias: `#alias-${roomId}:example.org`,
+        alt_aliases: [`#alt-${roomId}:example.org`],
+      };
+    }
+    if (eventType === "m.room.member") {
+      return { displayname: `Display ${roomId}:${stateKey}` };
+    }
+    return {};
+  });
+}
+
+function createMissingMetadataError() {
+  const err = new Error("M_NOT_FOUND");
+  Object.assign(err, {
+    statusCode: 404,
+    body: { errcode: "M_NOT_FOUND" },
+  });
+  return err;
+}
+
+function getRoomStateCallCount(client: RoomInfoClientStub, eventType: string) {
+  return client.getRoomStateEvent.mock.calls.filter(([, type]) => type === eventType).length;
+}
+
+describe("createMatrixRoomInfoResolver", () => {
+  it("caches room names and member display names, and loads aliases only on demand", async () => {
+    const client = createClientStub();
+    const resolver = createMatrixRoomInfoResolver(client);
+
+    await expect(resolver.getRoomInfo("!room:example.org")).resolves.toEqual({
+      name: "Room !room:example.org",
+      altAliases: [],
+      nameResolved: true,
+      aliasesResolved: false,
+    });
+    await resolver.getRoomInfo("!room:example.org");
+    await expect(
+      resolver.getRoomInfo("!room:example.org", { includeAliases: true }),
+    ).resolves.toEqual({
+      name: "Room !room:example.org",
+      canonicalAlias: "#alias-!room:example.org:example.org",
+      altAliases: ["#alt-!room:example.org:example.org"],
+      nameResolved: true,
+      aliasesResolved: true,
+    });
+    await resolver.getRoomInfo("!room:example.org", { includeAliases: true });
+    await resolver.getMemberDisplayName("!room:example.org", "@alice:example.org");
+    await resolver.getMemberDisplayName("!room:example.org", "@alice:example.org");
+
+    expect(client.getRoomStateEvent).toHaveBeenCalledTimes(3);
+  });
+
+  it("caches fallback user IDs when member display names are missing", async () => {
+    const client = createRoomStateClient(async () => ({}));
+    const resolver = createMatrixRoomInfoResolver(client);
+
+    await expect(
+      resolver.getMemberDisplayName("!room:example.org", "@alice:example.org"),
+    ).resolves.toBe("@alice:example.org");
+    await expect(
+      resolver.getMemberDisplayName("!room:example.org", "@alice:example.org"),
+    ).resolves.toBe("@alice:example.org");
+
+    expect(client.getRoomStateEvent).toHaveBeenCalledTimes(1);
+  });
+
+  it("marks unresolved room metadata when room info lookups fail", async () => {
+    const client = createRoomStateClient(async (_roomId, eventType) => {
+      if (eventType === "m.room.member") {
+        return {};
+      }
+      throw new Error("room info unavailable");
+    });
+    const resolver = createMatrixRoomInfoResolver(client);
+
+    await expect(
+      resolver.getRoomInfo("!room:example.org", { includeAliases: true }),
+    ).resolves.toEqual({
+      altAliases: [],
+      aliasesResolved: false,
+      nameResolved: false,
+    });
+  });
+
+  it("treats missing room metadata as resolved-empty state", async () => {
+    const client = createRoomStateClient(async (_roomId, eventType) => {
+      if (eventType === "m.room.name" || eventType === "m.room.canonical_alias") {
+        throw createMissingMetadataError();
+      }
+      return {};
+    });
+    const resolver = createMatrixRoomInfoResolver(client);
+
+    await expect(
+      resolver.getRoomInfo("!room:example.org", { includeAliases: true }),
+    ).resolves.toEqual({
+      altAliases: [],
+      aliasesResolved: true,
+      nameResolved: true,
+    });
+  });
+
+  it("retries room metadata after a transient lookup failure", async () => {
+    const client = createRoomStateClient(async (_roomId, eventType) => {
+      if (eventType === "m.room.name") {
+        if (getRoomStateCallCount(client, eventType) === 1) {
+          throw new Error("name lookup unavailable");
+        }
+        return { name: "Recovered Room" };
+      }
+      if (eventType === "m.room.canonical_alias") {
+        if (getRoomStateCallCount(client, eventType) === 1) {
+          throw new Error("alias lookup unavailable");
+        }
+        return {
+          alias: "#recovered:example.org",
+          alt_aliases: ["#alt-recovered:example.org"],
+        };
+      }
+      return {};
+    });
+    const resolver = createMatrixRoomInfoResolver(client);
+
+    await expect(
+      resolver.getRoomInfo("!room:example.org", { includeAliases: true }),
+    ).resolves.toEqual({
+      altAliases: [],
+      aliasesResolved: false,
+      nameResolved: false,
+    });
+    await expect(
+      resolver.getRoomInfo("!room:example.org", { includeAliases: true }),
+    ).resolves.toEqual({
+      name: "Recovered Room",
+      canonicalAlias: "#recovered:example.org",
+      altAliases: ["#alt-recovered:example.org"],
+      nameResolved: true,
+      aliasesResolved: true,
+    });
+  });
+
+  it("caches fallback user IDs when member display-name lookups fail", async () => {
+    const client = createRoomStateClient(async () => {
+      throw new Error("member lookup failed");
+    });
+    const resolver = createMatrixRoomInfoResolver(client);
+
+    await expect(
+      resolver.getMemberDisplayName("!room:example.org", "@alice:example.org"),
+    ).resolves.toBe("@alice:example.org");
+    await expect(
+      resolver.getMemberDisplayName("!room:example.org", "@alice:example.org"),
+    ).resolves.toBe("@alice:example.org");
+
+    expect(client.getRoomStateEvent).toHaveBeenCalledTimes(1);
+  });
+
+  it("bounds cached room and member entries", async () => {
+    const client = createClientStub();
+    const resolver = createMatrixRoomInfoResolver(client);
+
+    for (let i = 0; i <= 1024; i += 1) {
+      await resolver.getRoomInfo(`!room-${i}:example.org`);
+    }
+    await resolver.getRoomInfo("!room-0:example.org");
+
+    for (let i = 0; i <= 4096; i += 1) {
+      await resolver.getMemberDisplayName("!room:example.org", `@user-${i}:example.org`);
+    }
+    await resolver.getMemberDisplayName("!room:example.org", "@user-0:example.org");
+
+    expect(client.getRoomStateEvent).toHaveBeenCalledTimes(5124);
+  });
+});

package/src/matrix/monitor/room-info.ts

@@ -0,0 +1,126 @@
+import { isMatrixNotFoundError } from "../errors.js";
+import type { MatrixClient } from "../sdk.js";
+
+export type MatrixRoomInfo = {
+  name?: string;
+  canonicalAlias?: string;
+  altAliases: string[];
+  nameResolved: boolean;
+  aliasesResolved: boolean;
+};
+
+const MAX_TRACKED_ROOM_INFO = 1024;
+const MAX_TRACKED_MEMBER_DISPLAY_NAMES = 4096;
+
+function rememberBounded<T>(map: Map<string, T>, key: string, value: T, maxEntries: number): void {
+  map.set(key, value);
+  if (map.size > maxEntries) {
+    const oldest = map.keys().next().value;
+    if (typeof oldest === "string") {
+      map.delete(oldest);
+    }
+  }
+}
+
+export function createMatrixRoomInfoResolver(client: MatrixClient) {
+  const roomNameCache = new Map<string, Pick<MatrixRoomInfo, "name" | "nameResolved">>();
+  const roomAliasCache = new Map<
+    string,
+    Pick<MatrixRoomInfo, "canonicalAlias" | "altAliases" | "aliasesResolved">
+  >();
+  const memberDisplayNameCache = new Map<string, string>();
+
+  const getRoomName = async (
+    roomId: string,
+  ): Promise<Pick<MatrixRoomInfo, "name" | "nameResolved">> => {
+    if (roomNameCache.has(roomId)) {
+      return roomNameCache.get(roomId) ?? { nameResolved: false };
+    }
+    let name: string | undefined;
+    let nameResolved = false;
+    try {
+      const nameState = await client.getRoomStateEvent(roomId, "m.room.name", "");
+      nameResolved = true;
+      if (nameState && typeof nameState.name === "string") {
+        name = nameState.name;
+      }
+    } catch (err) {
+      if (isMatrixNotFoundError(err)) {
+        nameResolved = true;
+      }
+    }
+    const info = { name, nameResolved };
+    if (nameResolved) {
+      rememberBounded(roomNameCache, roomId, info, MAX_TRACKED_ROOM_INFO);
+    }
+    return info;
+  };
+
+  const getRoomAliases = async (
+    roomId: string,
+  ): Promise<Pick<MatrixRoomInfo, "canonicalAlias" | "altAliases" | "aliasesResolved">> => {
+    const cached = roomAliasCache.get(roomId);
+    if (cached) {
+      return cached;
+    }
+    let canonicalAlias: string | undefined;
+    let altAliases: string[] = [];
+    let aliasesResolved = false;
+    try {
+      const aliasState = await client.getRoomStateEvent(roomId, "m.room.canonical_alias", "");
+      aliasesResolved = true;
+      if (aliasState && typeof aliasState.alias === "string") {
+        canonicalAlias = aliasState.alias;
+      }
+      const rawAliases = aliasState?.alt_aliases;
+      if (Array.isArray(rawAliases)) {
+        altAliases = rawAliases.filter((entry): entry is string => typeof entry === "string");
+      }
+    } catch (err) {
+      if (isMatrixNotFoundError(err)) {
+        aliasesResolved = true;
+      }
+    }
+    const info = { canonicalAlias, altAliases, aliasesResolved };
+    if (aliasesResolved) {
+      rememberBounded(roomAliasCache, roomId, info, MAX_TRACKED_ROOM_INFO);
+    }
+    return info;
+  };
+
+  const getRoomInfo = async (
+    roomId: string,
+    opts: { includeAliases?: boolean } = {},
+  ): Promise<MatrixRoomInfo> => {
+    const { name, nameResolved } = await getRoomName(roomId);
+    if (!opts.includeAliases) {
+      return { name, altAliases: [], nameResolved, aliasesResolved: false };
+    }
+    const aliases = await getRoomAliases(roomId);
+    return { name, nameResolved, ...aliases };
+  };
+
+  const getMemberDisplayName = async (roomId: string, userId: string): Promise<string> => {
+    const cacheKey = `${roomId}:${userId}`;
+    if (memberDisplayNameCache.has(cacheKey)) {
+      return memberDisplayNameCache.get(cacheKey) ?? userId;
+    }
+    const memberState = await client
+      .getRoomStateEvent(roomId, "m.room.member", userId)
+      .catch(() => null);
+    const displayName =
+      memberState && typeof memberState.displayname === "string" ? memberState.displayname : userId;
+    rememberBounded(
+      memberDisplayNameCache,
+      cacheKey,
+      displayName,
+      MAX_TRACKED_MEMBER_DISPLAY_NAMES,
+    );
+    return displayName;
+  };
+
+  return {
+    getRoomInfo,
+    getMemberDisplayName,
+  };
+}

package/src/matrix/monitor/rooms.test.ts

@@ -0,0 +1,121 @@
+import { describe, expect, it } from "vitest";
+import { resolveMatrixRoomConfig } from "./rooms.js";
+
+describe("resolveMatrixRoomConfig", () => {
+  it("matches room IDs and aliases, not names", () => {
+    const rooms = {
+      "!room:example.org": { enabled: true },
+      "#alias:example.org": { enabled: true },
+      "Project Room": { enabled: true },
+    };
+
+    const byId = resolveMatrixRoomConfig({
+      rooms,
+      roomId: "!room:example.org",
+      aliases: [],
+    });
+    expect(byId.allowed).toBe(true);
+    expect(byId.matchKey).toBe("!room:example.org");
+
+    const byAlias = resolveMatrixRoomConfig({
+      rooms,
+      roomId: "!other:example.org",
+      aliases: ["#alias:example.org"],
+    });
+    expect(byAlias.allowed).toBe(true);
+    expect(byAlias.matchKey).toBe("#alias:example.org");
+
+    const byName = resolveMatrixRoomConfig({
+      rooms: { "Project Room": { enabled: true } },
+      roomId: "!different:example.org",
+      aliases: [],
+    });
+    expect(byName.allowed).toBe(false);
+    expect(byName.config).toBeUndefined();
+  });
+
+  describe("matchSource classification", () => {
+    it('returns matchSource="direct" for exact room ID match', () => {
+      const result = resolveMatrixRoomConfig({
+        rooms: { "!room:example.org": { enabled: true } },
+        roomId: "!room:example.org",
+        aliases: [],
+      });
+      expect(result.matchSource).toBe("direct");
+      expect(result.config).toBeDefined();
+    });
+
+    it('returns matchSource="direct" for alias match', () => {
+      const result = resolveMatrixRoomConfig({
+        rooms: { "#alias:example.org": { enabled: true } },
+        roomId: "!room:example.org",
+        aliases: ["#alias:example.org"],
+      });
+      expect(result.matchSource).toBe("direct");
+      expect(result.config).toBeDefined();
+    });
+
+    it('returns matchSource="wildcard" for wildcard match', () => {
+      const result = resolveMatrixRoomConfig({
+        rooms: { "*": { enabled: true } },
+        roomId: "!any:example.org",
+        aliases: [],
+      });
+      expect(result.matchSource).toBe("wildcard");
+      expect(result.config).toBeDefined();
+    });
+
+    it("returns undefined matchSource when no match", () => {
+      const result = resolveMatrixRoomConfig({
+        rooms: { "!other:example.org": { enabled: true } },
+        roomId: "!room:example.org",
+        aliases: [],
+      });
+      expect(result.matchSource).toBeUndefined();
+      expect(result.config).toBeUndefined();
+    });
+
+    it("direct match takes priority over wildcard", () => {
+      const result = resolveMatrixRoomConfig({
+        rooms: {
+          "!room:example.org": { enabled: true, systemPrompt: "room-specific" },
+          "*": { enabled: true, systemPrompt: "generic" },
+        },
+        roomId: "!room:example.org",
+        aliases: [],
+      });
+      expect(result.matchSource).toBe("direct");
+      expect(result.config?.systemPrompt).toBe("room-specific");
+    });
+  });
+
+  describe("DM override safety (matchSource distinction)", () => {
+    // These tests verify the matchSource property that handler.ts uses
+    // to decide whether a configured room should override DM classification.
+    // Only "direct" matches should trigger the override -- never "wildcard".
+
+    it("wildcard config should NOT be usable to override DM classification", () => {
+      const result = resolveMatrixRoomConfig({
+        rooms: { "*": { enabled: true, skills: ["general"] } },
+        roomId: "!dm-room:example.org",
+        aliases: [],
+      });
+      // handler.ts checks: matchSource === "direct" -> this is "wildcard", so no override
+      expect(result.matchSource).not.toBe("direct");
+      expect(result.matchSource).toBe("wildcard");
+    });
+
+    it("explicitly configured room should be usable to override DM classification", () => {
+      const result = resolveMatrixRoomConfig({
+        rooms: {
+          "!configured-room:example.org": { enabled: true },
+          "*": { enabled: true },
+        },
+        roomId: "!configured-room:example.org",
+        aliases: [],
+      });
+      // handler.ts checks: matchSource === "direct" -> this IS "direct", so override is safe
+      expect(result.matchSource).toBe("direct");
+    });
+  });
+});

package/src/matrix/monitor/rooms.ts

@@ -0,0 +1,52 @@
+import type { MatrixRoomConfig } from "../../types.js";
+import { buildChannelKeyCandidates, resolveChannelEntryMatch } from "./runtime-api.js";
+
+export type MatrixRoomConfigResolved = {
+  allowed: boolean;
+  allowlistConfigured: boolean;
+  config?: MatrixRoomConfig;
+  matchKey?: string;
+  matchSource?: "direct" | "wildcard";
+};
+
+function readLegacyRoomAllowAlias(room: MatrixRoomConfig | undefined): boolean | undefined {
+  const rawRoom = room as Record<string, unknown> | undefined;
+  return typeof rawRoom?.allow === "boolean" ? rawRoom.allow : undefined;
+}
+
+export function resolveMatrixRoomConfig(params: {
+  rooms?: Record<string, MatrixRoomConfig>;
+  roomId: string;
+  aliases: string[];
+}): MatrixRoomConfigResolved {
+  const rooms = params.rooms ?? {};
+  const keys = Object.keys(rooms);
+  const allowlistConfigured = keys.length > 0;
+  const candidates = buildChannelKeyCandidates(
+    params.roomId,
+    `room:${params.roomId}`,
+    ...params.aliases,
+  );
+  const {
+    entry: matched,
+    key: matchedKey,
+    wildcardEntry,
+    wildcardKey,
+  } = resolveChannelEntryMatch({
+    entries: rooms,
+    keys: candidates,
+    wildcardKey: "*",
+  });
+  const resolved = matched ?? wildcardEntry;
+  const legacyAllow = readLegacyRoomAllowAlias(resolved);
+  const allowed = resolved ? resolved.enabled !== false && legacyAllow !== false : false;
+  const matchKey = matchedKey ?? wildcardKey;
+  const matchSource = matched ? "direct" : wildcardEntry ? "wildcard" : undefined;
+  return {
+    allowed,
+    allowlistConfigured,
+    config: resolved,
+    matchKey,
+    matchSource,
+  };
+}