@archipelagolab/lobi 1.0.0

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

@@ -0,0 +1,197 @@
+import { describe, expect, it, vi } from "vitest";
+import type { RuntimeEnv } from "../../../runtime-api.js";
+import type { CoreConfig, MatrixRoomConfig } from "../../types.js";
+import { resolveMatrixMonitorConfig } from "./config.js";
+
+type MatrixRoomsConfig = Record<string, MatrixRoomConfig>;
+
+function createRuntime() {
+  const runtime: RuntimeEnv = {
+    log: vi.fn(),
+    error: vi.fn(),
+    exit: vi.fn(),
+  };
+  return runtime;
+}
+
+describe("resolveMatrixMonitorConfig", () => {
+  it("canonicalizes resolved user aliases and room keys without keeping stale aliases", async () => {
+    const runtime = createRuntime();
+    const resolveTargets = vi.fn(
+      async ({ inputs, kind }: { inputs: string[]; kind: "user" | "group" }) => {
+        if (kind === "user") {
+          return inputs.map((input) => {
+            if (input === "Bob") {
+              return { input, resolved: true, id: "@bob:example.org" };
+            }
+            if (input === "Dana") {
+              return { input, resolved: true, id: "@dana:example.org" };
+            }
+            return { input, resolved: false };
+          });
+        }
+        return inputs.map((input) =>
+          input === "General"
+            ? { input, resolved: true, id: "!general:example.org" }
+            : { input, resolved: false },
+        );
+      },
+    );
+
+    const roomsConfig: MatrixRoomsConfig = {
+      "*": { enabled: true },
+      "room:!ops:example.org": {
+        enabled: true,
+        users: ["Dana", "user:@Erin:Example.org"],
+      },
+      General: {
+        enabled: true,
+      },
+    };
+
+    const result = await resolveMatrixMonitorConfig({
+      cfg: {} as CoreConfig,
+      accountId: "ops",
+      allowFrom: ["matrix:@Alice:Example.org", "Bob"],
+      groupAllowFrom: ["user:@Carol:Example.org"],
+      roomsConfig,
+      runtime,
+      resolveTargets,
+    });
+
+    expect(result.allowFrom).toEqual(["@alice:example.org", "@bob:example.org"]);
+    expect(result.groupAllowFrom).toEqual(["@carol:example.org"]);
+    expect(result.roomsConfig).toEqual({
+      "*": { enabled: true },
+      "!ops:example.org": {
+        enabled: true,
+        users: ["@dana:example.org", "@erin:example.org"],
+      },
+      "!general:example.org": {
+        enabled: true,
+      },
+    });
+    expect(resolveTargets).toHaveBeenCalledTimes(3);
+    expect(resolveTargets).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({
+        accountId: "ops",
+        kind: "user",
+        inputs: ["Bob"],
+      }),
+    );
+    expect(resolveTargets).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        accountId: "ops",
+        kind: "group",
+        inputs: ["General"],
+      }),
+    );
+    expect(resolveTargets).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        accountId: "ops",
+        kind: "user",
+        inputs: ["Dana"],
+      }),
+    );
+  });
+
+  it("strips config prefixes before lookups and logs unresolved guidance once per section", async () => {
+    const runtime = createRuntime();
+    const resolveTargets = vi.fn(
+      async ({ kind, inputs }: { inputs: string[]; kind: "user" | "group" }) =>
+        inputs.map((input) => ({
+          input,
+          resolved: false,
+          ...(kind === "group" ? { note: `missing ${input}` } : {}),
+        })),
+    );
+
+    const result = await resolveMatrixMonitorConfig({
+      cfg: {} as CoreConfig,
+      accountId: "ops",
+      allowFrom: ["user:Ghost"],
+      groupAllowFrom: ["matrix:@known:example.org"],
+      roomsConfig: {
+        "channel:Project X": {
+          enabled: true,
+          users: ["matrix:Ghost"],
+        },
+      },
+      runtime,
+      resolveTargets,
+    });
+
+    expect(result.allowFrom).toEqual([]);
+    expect(result.groupAllowFrom).toEqual(["@known:example.org"]);
+    expect(result.roomsConfig).toEqual({});
+    expect(resolveTargets).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({
+        accountId: "ops",
+        kind: "user",
+        inputs: ["Ghost"],
+      }),
+    );
+    expect(resolveTargets).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        accountId: "ops",
+        kind: "group",
+        inputs: ["Project X"],
+      }),
+    );
+    expect(resolveTargets).toHaveBeenCalledTimes(2);
+    expect(runtime.log).toHaveBeenCalledWith("matrix dm allowlist unresolved: user:Ghost");
+    expect(runtime.log).toHaveBeenCalledWith(
+      "matrix dm allowlist entries must be full Matrix IDs (example: @user:server). Unresolved entries are ignored.",
+    );
+    expect(runtime.log).toHaveBeenCalledWith("matrix rooms unresolved: channel:Project X");
+    expect(runtime.log).toHaveBeenCalledWith(
+      "matrix rooms must be room IDs or aliases (example: !room:server or #alias:server). Unresolved entries are ignored.",
+    );
+  });
+
+  it("resolves exact room aliases to canonical room ids instead of trusting alias keys directly", async () => {
+    const runtime = createRuntime();
+    const resolveTargets = vi.fn(
+      async ({ kind, inputs }: { inputs: string[]; kind: "user" | "group" }) => {
+        if (kind === "group") {
+          return inputs.map((input) =>
+            input === "#allowed:example.org"
+              ? { input, resolved: true, id: "!allowed-room:example.org" }
+              : { input, resolved: false },
+          );
+        }
+        return [];
+      },
+    );
+
+    const result = await resolveMatrixMonitorConfig({
+      cfg: {} as CoreConfig,
+      accountId: "ops",
+      roomsConfig: {
+        "#allowed:example.org": {
+          enabled: true,
+        },
+      },
+      runtime,
+      resolveTargets,
+    });
+
+    expect(result.roomsConfig).toEqual({
+      "!allowed-room:example.org": {
+        enabled: true,
+      },
+    });
+    expect(resolveTargets).toHaveBeenCalledWith(
+      expect.objectContaining({
+        accountId: "ops",
+        kind: "group",
+        inputs: ["#allowed:example.org"],
+      }),
+    );
+  });
+});

package/src/matrix/monitor/config.ts

@@ -0,0 +1,303 @@
+import { resolveMatrixTargets } from "../../resolve-targets.js";
+import type { CoreConfig, MatrixRoomConfig } from "../../types.js";
+import { isMatrixQualifiedUserId } from "../target-ids.js";
+import { normalizeMatrixUserId } from "./allowlist.js";
+import {
+  addAllowlistUserEntriesFromConfigEntry,
+  buildAllowlistResolutionSummary,
+  canonicalizeAllowlistWithResolvedIds,
+  patchAllowlistUsersInConfigEntries,
+  summarizeMapping,
+  type RuntimeEnv,
+} from "./runtime-api.js";
+
+type MatrixRoomsConfig = Record<string, MatrixRoomConfig>;
+type ResolveMatrixTargetsFn = typeof resolveMatrixTargets;
+
+function normalizeMatrixUserLookupEntry(raw: string): string {
+  return raw
+    .replace(/^matrix:/i, "")
+    .replace(/^user:/i, "")
+    .trim();
+}
+
+function normalizeMatrixRoomLookupEntry(raw: string): string {
+  return raw
+    .replace(/^matrix:/i, "")
+    .replace(/^(room|channel):/i, "")
+    .trim();
+}
+
+function filterResolvedMatrixAllowlistEntries(entries: string[]): string[] {
+  return entries.filter((entry) => {
+    const trimmed = entry.trim();
+    if (!trimmed) {
+      return false;
+    }
+    if (trimmed === "*") {
+      return true;
+    }
+    return isMatrixQualifiedUserId(normalizeMatrixUserLookupEntry(trimmed));
+  });
+}
+
+function sanitizeMatrixRoomUserAllowlists(entries: MatrixRoomsConfig): MatrixRoomsConfig {
+  const nextEntries: MatrixRoomsConfig = { ...entries };
+  for (const [roomKey, roomConfig] of Object.entries(entries)) {
+    const users = roomConfig?.users;
+    if (!Array.isArray(users)) {
+      continue;
+    }
+    nextEntries[roomKey] = {
+      ...roomConfig,
+      users: filterResolvedMatrixAllowlistEntries(users.map(String)),
+    };
+  }
+  return nextEntries;
+}
+
+async function resolveMatrixMonitorUserEntries(params: {
+  cfg: CoreConfig;
+  accountId?: string | null;
+  entries: Array<string | number>;
+  runtime: RuntimeEnv;
+  resolveTargets: ResolveMatrixTargetsFn;
+}) {
+  const directMatches: Array<{ input: string; resolved: boolean; id?: string }> = [];
+  const pending: Array<{ input: string; query: string }> = [];
+
+  for (const entry of params.entries) {
+    const input = String(entry).trim();
+    if (!input) {
+      continue;
+    }
+    const query = normalizeMatrixUserLookupEntry(input);
+    if (!query || query === "*") {
+      continue;
+    }
+    if (isMatrixQualifiedUserId(query)) {
+      directMatches.push({
+        input,
+        resolved: true,
+        id: normalizeMatrixUserId(query),
+      });
+      continue;
+    }
+    pending.push({ input, query });
+  }
+
+  const pendingResolved =
+    pending.length === 0
+      ? []
+      : await params.resolveTargets({
+          cfg: params.cfg,
+          accountId: params.accountId,
+          inputs: pending.map((entry) => entry.query),
+          kind: "user",
+          runtime: params.runtime,
+        });
+
+  pendingResolved.forEach((entry, index) => {
+    const source = pending[index];
+    if (!source) {
+      return;
+    }
+    directMatches.push({
+      input: source.input,
+      resolved: entry.resolved,
+      id: entry.id ? normalizeMatrixUserId(entry.id) : undefined,
+    });
+  });
+
+  return buildAllowlistResolutionSummary(directMatches);
+}
+
+async function resolveMatrixMonitorUserAllowlist(params: {
+  cfg: CoreConfig;
+  accountId?: string | null;
+  label: string;
+  list?: Array<string | number>;
+  runtime: RuntimeEnv;
+  resolveTargets: ResolveMatrixTargetsFn;
+}): Promise<string[]> {
+  const allowList = (params.list ?? []).map(String);
+  if (allowList.length === 0) {
+    return allowList;
+  }
+
+  const resolution = await resolveMatrixMonitorUserEntries({
+    cfg: params.cfg,
+    accountId: params.accountId,
+    entries: allowList,
+    runtime: params.runtime,
+    resolveTargets: params.resolveTargets,
+  });
+  const canonicalized = canonicalizeAllowlistWithResolvedIds({
+    existing: allowList,
+    resolvedMap: resolution.resolvedMap,
+  });
+
+  summarizeMapping(params.label, resolution.mapping, resolution.unresolved, params.runtime);
+  if (resolution.unresolved.length > 0) {
+    params.runtime.log?.(
+      `${params.label} entries must be full Matrix IDs (example: @user:server). Unresolved entries are ignored.`,
+    );
+  }
+
+  return filterResolvedMatrixAllowlistEntries(canonicalized);
+}
+
+async function resolveMatrixMonitorRoomsConfig(params: {
+  cfg: CoreConfig;
+  accountId?: string | null;
+  roomsConfig?: MatrixRoomsConfig;
+  runtime: RuntimeEnv;
+  resolveTargets: ResolveMatrixTargetsFn;
+}): Promise<MatrixRoomsConfig | undefined> {
+  const roomsConfig = params.roomsConfig;
+  if (!roomsConfig || Object.keys(roomsConfig).length === 0) {
+    return roomsConfig;
+  }
+
+  const mapping: string[] = [];
+  const unresolved: string[] = [];
+  const nextRooms: MatrixRoomsConfig = {};
+  if (roomsConfig["*"]) {
+    nextRooms["*"] = roomsConfig["*"];
+  }
+
+  const pending: Array<{ input: string; query: string; config: MatrixRoomConfig }> = [];
+  for (const [entry, roomConfig] of Object.entries(roomsConfig)) {
+    if (entry === "*") {
+      continue;
+    }
+    const input = entry.trim();
+    if (!input) {
+      continue;
+    }
+    const cleaned = normalizeMatrixRoomLookupEntry(input);
+    if (!cleaned) {
+      unresolved.push(entry);
+      continue;
+    }
+    if (cleaned.startsWith("!") && cleaned.includes(":")) {
+      if (!nextRooms[cleaned]) {
+        nextRooms[cleaned] = roomConfig;
+      }
+      if (cleaned !== input) {
+        mapping.push(`${input}→${cleaned}`);
+      }
+      continue;
+    }
+    pending.push({ input, query: cleaned, config: roomConfig });
+  }
+
+  if (pending.length > 0) {
+    const resolved = await params.resolveTargets({
+      cfg: params.cfg,
+      accountId: params.accountId,
+      inputs: pending.map((entry) => entry.query),
+      kind: "group",
+      runtime: params.runtime,
+    });
+    resolved.forEach((entry, index) => {
+      const source = pending[index];
+      if (!source) {
+        return;
+      }
+      if (entry.resolved && entry.id) {
+        const roomKey = normalizeMatrixRoomLookupEntry(entry.id);
+        if (!nextRooms[roomKey]) {
+          nextRooms[roomKey] = source.config;
+        }
+        mapping.push(`${source.input}→${roomKey}`);
+      } else {
+        unresolved.push(source.input);
+      }
+    });
+  }
+
+  summarizeMapping("matrix rooms", mapping, unresolved, params.runtime);
+  if (unresolved.length > 0) {
+    params.runtime.log?.(
+      "matrix rooms must be room IDs or aliases (example: !room:server or #alias:server). Unresolved entries are ignored.",
+    );
+  }
+
+  const roomUsers = new Set<string>();
+  for (const roomConfig of Object.values(nextRooms)) {
+    addAllowlistUserEntriesFromConfigEntry(roomUsers, roomConfig);
+  }
+  if (roomUsers.size === 0) {
+    return nextRooms;
+  }
+
+  const resolution = await resolveMatrixMonitorUserEntries({
+    cfg: params.cfg,
+    accountId: params.accountId,
+    entries: Array.from(roomUsers),
+    runtime: params.runtime,
+    resolveTargets: params.resolveTargets,
+  });
+  summarizeMapping("matrix room users", resolution.mapping, resolution.unresolved, params.runtime);
+  if (resolution.unresolved.length > 0) {
+    params.runtime.log?.(
+      "matrix room users entries must be full Matrix IDs (example: @user:server). Unresolved entries are ignored.",
+    );
+  }
+
+  const patched = patchAllowlistUsersInConfigEntries({
+    entries: nextRooms,
+    resolvedMap: resolution.resolvedMap,
+    strategy: "canonicalize",
+  });
+  return sanitizeMatrixRoomUserAllowlists(patched);
+}
+
+export async function resolveMatrixMonitorConfig(params: {
+  cfg: CoreConfig;
+  accountId?: string | null;
+  allowFrom?: Array<string | number>;
+  groupAllowFrom?: Array<string | number>;
+  roomsConfig?: MatrixRoomsConfig;
+  runtime: RuntimeEnv;
+  resolveTargets?: ResolveMatrixTargetsFn;
+}): Promise<{
+  allowFrom: string[];
+  groupAllowFrom: string[];
+  roomsConfig?: MatrixRoomsConfig;
+}> {
+  const resolveTargets = params.resolveTargets ?? resolveMatrixTargets;
+
+  const [allowFrom, groupAllowFrom, roomsConfig] = await Promise.all([
+    resolveMatrixMonitorUserAllowlist({
+      cfg: params.cfg,
+      accountId: params.accountId,
+      label: "matrix dm allowlist",
+      list: params.allowFrom,
+      runtime: params.runtime,
+      resolveTargets,
+    }),
+    resolveMatrixMonitorUserAllowlist({
+      cfg: params.cfg,
+      accountId: params.accountId,
+      label: "matrix group allowlist",
+      list: params.groupAllowFrom,
+      runtime: params.runtime,
+      resolveTargets,
+    }),
+    resolveMatrixMonitorRoomsConfig({
+      cfg: params.cfg,
+      accountId: params.accountId,
+      roomsConfig: params.roomsConfig,
+      runtime: params.runtime,
+      resolveTargets,
+    }),
+  ]);
+
+  return {
+    allowFrom,
+    groupAllowFrom,
+    roomsConfig,
+  };
+}

package/src/matrix/monitor/context-summary.ts

@@ -0,0 +1,43 @@
+import {
+  formatMatrixMessageText,
+  resolveMatrixMessageAttachment,
+  resolveMatrixMessageBody,
+} from "../media-text.js";
+import {
+  formatPollAsText,
+  isPollStartType,
+  parsePollStartContent,
+  type PollStartContent,
+} from "../poll-types.js";
+import type { MatrixRawEvent } from "./types.js";
+
+export function trimMatrixMaybeString(value: unknown): string | undefined {
+  if (typeof value !== "string") {
+    return undefined;
+  }
+  const trimmed = value.trim();
+  return trimmed || undefined;
+}
+
+export function summarizeMatrixMessageContextEvent(event: MatrixRawEvent): string | undefined {
+  if (isPollStartType(event.type)) {
+    const pollSummary = parsePollStartContent(event.content as PollStartContent);
+    if (pollSummary) {
+      return formatPollAsText(pollSummary);
+    }
+  }
+
+  const content = event.content as { body?: unknown; filename?: unknown; msgtype?: unknown };
+  return formatMatrixMessageText({
+    body: resolveMatrixMessageBody({
+      body: trimMatrixMaybeString(content.body),
+      filename: trimMatrixMaybeString(content.filename),
+      msgtype: trimMatrixMaybeString(content.msgtype),
+    }),
+    attachment: resolveMatrixMessageAttachment({
+      body: trimMatrixMaybeString(content.body),
+      filename: trimMatrixMaybeString(content.filename),
+      msgtype: trimMatrixMaybeString(content.msgtype),
+    }),
+  });
+}