@archipelagolab/lobi 1.0.1 → 1.0.6

package/dist/chunk-CPNIXMGX.js

@@ -0,0 +1,127 @@
+import {
+  init_shims
+} from "./chunk-7FLQSTPG.js";
+
+// src/approval-reactions.ts
+init_shims();
+var MATRIX_APPROVAL_REACTION_META = {
+  "allow-once": {
+    emoji: "\u2705",
+    label: "Allow once"
+  },
+  "allow-always": {
+    emoji: "\u267E\uFE0F",
+    label: "Allow always"
+  },
+  deny: {
+    emoji: "\u274C",
+    label: "Deny"
+  }
+};
+var MATRIX_APPROVAL_REACTION_ORDER = [
+  "allow-once",
+  "allow-always",
+  "deny"
+];
+var matrixApprovalReactionTargets = /* @__PURE__ */ new Map();
+function buildReactionTargetKey(roomId, eventId) {
+  const normalizedRoomId = roomId.trim();
+  const normalizedEventId = eventId.trim();
+  if (!normalizedRoomId || !normalizedEventId) {
+    return null;
+  }
+  return `${normalizedRoomId}:${normalizedEventId}`;
+}
+function listMatrixApprovalReactionBindings(allowedDecisions) {
+  const allowed = new Set(allowedDecisions);
+  return MATRIX_APPROVAL_REACTION_ORDER.filter((decision) => allowed.has(decision)).map(
+    (decision) => ({
+      decision,
+      emoji: MATRIX_APPROVAL_REACTION_META[decision].emoji,
+      label: MATRIX_APPROVAL_REACTION_META[decision].label
+    })
+  );
+}
+function buildMatrixApprovalReactionHint(allowedDecisions) {
+  const bindings = listMatrixApprovalReactionBindings(allowedDecisions);
+  if (bindings.length === 0) {
+    return null;
+  }
+  return `React here: ${bindings.map((binding) => `${binding.emoji} ${binding.label}`).join(", ")}`;
+}
+function resolveMatrixApprovalReactionDecision(reactionKey, allowedDecisions) {
+  const normalizedReaction = reactionKey.trim();
+  if (!normalizedReaction) {
+    return null;
+  }
+  const allowed = new Set(allowedDecisions);
+  for (const decision of MATRIX_APPROVAL_REACTION_ORDER) {
+    if (!allowed.has(decision)) {
+      continue;
+    }
+    if (MATRIX_APPROVAL_REACTION_META[decision].emoji === normalizedReaction) {
+      return decision;
+    }
+  }
+  return null;
+}
+function registerMatrixApprovalReactionTarget(params) {
+  const key = buildReactionTargetKey(params.roomId, params.eventId);
+  const approvalId = params.approvalId.trim();
+  const allowedDecisions = Array.from(
+    new Set(
+      params.allowedDecisions.filter(
+        (decision) => decision === "allow-once" || decision === "allow-always" || decision === "deny"
+      )
+    )
+  );
+  if (!key || !approvalId || allowedDecisions.length === 0) {
+    return;
+  }
+  matrixApprovalReactionTargets.set(key, {
+    approvalId,
+    allowedDecisions
+  });
+}
+function unregisterMatrixApprovalReactionTarget(params) {
+  const key = buildReactionTargetKey(params.roomId, params.eventId);
+  if (!key) {
+    return;
+  }
+  matrixApprovalReactionTargets.delete(key);
+}
+function resolveMatrixApprovalReactionTarget(params) {
+  const key = buildReactionTargetKey(params.roomId, params.eventId);
+  if (!key) {
+    return null;
+  }
+  const target = matrixApprovalReactionTargets.get(key);
+  if (!target) {
+    return null;
+  }
+  const decision = resolveMatrixApprovalReactionDecision(
+    params.reactionKey,
+    target.allowedDecisions
+  );
+  if (!decision) {
+    return null;
+  }
+  return {
+    approvalId: target.approvalId,
+    decision
+  };
+}
+function clearMatrixApprovalReactionTargetsForTest() {
+  matrixApprovalReactionTargets.clear();
+}
+
+export {
+  listMatrixApprovalReactionBindings,
+  buildMatrixApprovalReactionHint,
+  resolveMatrixApprovalReactionDecision,
+  registerMatrixApprovalReactionTarget,
+  unregisterMatrixApprovalReactionTarget,
+  resolveMatrixApprovalReactionTarget,
+  clearMatrixApprovalReactionTargetsForTest
+};
+//# sourceMappingURL=chunk-CPNIXMGX.js.map

package/dist/chunk-CPNIXMGX.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/approval-reactions.ts"],
+  "sourcesContent": ["import type { ExecApprovalReplyDecision } from \"openclaw/plugin-sdk/approval-runtime\";\n\nconst MATRIX_APPROVAL_REACTION_META = {\n  \"allow-once\": {\n    emoji: \"\u2705\",\n    label: \"Allow once\",\n  },\n  \"allow-always\": {\n    emoji: \"\u267E\uFE0F\",\n    label: \"Allow always\",\n  },\n  deny: {\n    emoji: \"\u274C\",\n    label: \"Deny\",\n  },\n} satisfies Record<ExecApprovalReplyDecision, { emoji: string; label: string }>;\n\nconst MATRIX_APPROVAL_REACTION_ORDER = [\n  \"allow-once\",\n  \"allow-always\",\n  \"deny\",\n] as const satisfies readonly ExecApprovalReplyDecision[];\n\nexport type MatrixApprovalReactionBinding = {\n  decision: ExecApprovalReplyDecision;\n  emoji: string;\n  label: string;\n};\n\nexport type MatrixApprovalReactionResolution = {\n  approvalId: string;\n  decision: ExecApprovalReplyDecision;\n};\n\ntype MatrixApprovalReactionTarget = {\n  approvalId: string;\n  allowedDecisions: readonly ExecApprovalReplyDecision[];\n};\n\nconst matrixApprovalReactionTargets = new Map<string, MatrixApprovalReactionTarget>();\n\nfunction buildReactionTargetKey(roomId: string, eventId: string): string | null {\n  const normalizedRoomId = roomId.trim();\n  const normalizedEventId = eventId.trim();\n  if (!normalizedRoomId || !normalizedEventId) {\n    return null;\n  }\n  return `${normalizedRoomId}:${normalizedEventId}`;\n}\n\nexport function listMatrixApprovalReactionBindings(\n  allowedDecisions: readonly ExecApprovalReplyDecision[],\n): MatrixApprovalReactionBinding[] {\n  const allowed = new Set(allowedDecisions);\n  return MATRIX_APPROVAL_REACTION_ORDER.filter((decision) => allowed.has(decision)).map(\n    (decision) => ({\n      decision,\n      emoji: MATRIX_APPROVAL_REACTION_META[decision].emoji,\n      label: MATRIX_APPROVAL_REACTION_META[decision].label,\n    }),\n  );\n}\n\nexport function buildMatrixApprovalReactionHint(\n  allowedDecisions: readonly ExecApprovalReplyDecision[],\n): string | null {\n  const bindings = listMatrixApprovalReactionBindings(allowedDecisions);\n  if (bindings.length === 0) {\n    return null;\n  }\n  return `React here: ${bindings.map((binding) => `${binding.emoji} ${binding.label}`).join(\", \")}`;\n}\n\nexport function resolveMatrixApprovalReactionDecision(\n  reactionKey: string,\n  allowedDecisions: readonly ExecApprovalReplyDecision[],\n): ExecApprovalReplyDecision | null {\n  const normalizedReaction = reactionKey.trim();\n  if (!normalizedReaction) {\n    return null;\n  }\n  const allowed = new Set(allowedDecisions);\n  for (const decision of MATRIX_APPROVAL_REACTION_ORDER) {\n    if (!allowed.has(decision)) {\n      continue;\n    }\n    if (MATRIX_APPROVAL_REACTION_META[decision].emoji === normalizedReaction) {\n      return decision;\n    }\n  }\n  return null;\n}\n\nexport function registerMatrixApprovalReactionTarget(params: {\n  roomId: string;\n  eventId: string;\n  approvalId: string;\n  allowedDecisions: readonly ExecApprovalReplyDecision[];\n}): void {\n  const key = buildReactionTargetKey(params.roomId, params.eventId);\n  const approvalId = params.approvalId.trim();\n  const allowedDecisions = Array.from(\n    new Set(\n      params.allowedDecisions.filter(\n        (decision): decision is ExecApprovalReplyDecision =>\n          decision === \"allow-once\" || decision === \"allow-always\" || decision === \"deny\",\n      ),\n    ),\n  );\n  if (!key || !approvalId || allowedDecisions.length === 0) {\n    return;\n  }\n  matrixApprovalReactionTargets.set(key, {\n    approvalId,\n    allowedDecisions,\n  });\n}\n\nexport function unregisterMatrixApprovalReactionTarget(params: {\n  roomId: string;\n  eventId: string;\n}): void {\n  const key = buildReactionTargetKey(params.roomId, params.eventId);\n  if (!key) {\n    return;\n  }\n  matrixApprovalReactionTargets.delete(key);\n}\n\nexport function resolveMatrixApprovalReactionTarget(params: {\n  roomId: string;\n  eventId: string;\n  reactionKey: string;\n}): MatrixApprovalReactionResolution | null {\n  const key = buildReactionTargetKey(params.roomId, params.eventId);\n  if (!key) {\n    return null;\n  }\n  const target = matrixApprovalReactionTargets.get(key);\n  if (!target) {\n    return null;\n  }\n  const decision = resolveMatrixApprovalReactionDecision(\n    params.reactionKey,\n    target.allowedDecisions,\n  );\n  if (!decision) {\n    return null;\n  }\n  return {\n    approvalId: target.approvalId,\n    decision,\n  };\n}\n\nexport function clearMatrixApprovalReactionTargetsForTest(): void {\n  matrixApprovalReactionTargets.clear();\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/chunk-CSJO73LD.js

@@ -0,0 +1,84 @@
+import {
+  MatrixMediaSizeLimitError,
+  isMatrixMediaSizeLimitError
+} from "./chunk-Z6IVJ6ZW.js";
+import {
+  getMatrixRuntime
+} from "./chunk-FHNEN6IR.js";
+import {
+  init_shims
+} from "./chunk-7FLQSTPG.js";
+
+// src/matrix/monitor/media.ts
+init_shims();
+var MATRIX_MEDIA_DOWNLOAD_IDLE_TIMEOUT_MS = 3e4;
+async function fetchMatrixMediaBuffer(params) {
+  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 });
+  }
+}
+async function fetchEncryptedMediaBuffer(params) {
+  if (!params.client.crypto) {
+    throw new Error("Cannot decrypt media: crypto not enabled");
+  }
+  const decrypted = await params.client.crypto.decryptMedia(
+    params.file,
+    {
+      maxBytes: params.maxBytes,
+      readIdleTimeoutMs: MATRIX_MEDIA_DOWNLOAD_IDLE_TIMEOUT_MS
+    }
+  );
+  if (decrypted.byteLength > params.maxBytes) {
+    throw new MatrixMediaSizeLimitError();
+  }
+  return { buffer: decrypted };
+}
+async function downloadMatrixMedia(params) {
+  let fetched;
+  if (typeof params.sizeBytes === "number" && params.sizeBytes > params.maxBytes) {
+    throw new MatrixMediaSizeLimitError();
+  }
+  if (params.file) {
+    fetched = await fetchEncryptedMediaBuffer({
+      client: params.client,
+      file: params.file,
+      maxBytes: params.maxBytes
+    });
+  } else {
+    fetched = await fetchMatrixMediaBuffer({
+      client: params.client,
+      mxcUrl: params.mxcUrl,
+      maxBytes: params.maxBytes
+    });
+  }
+  if (!fetched) {
+    return null;
+  }
+  const headerType = params.contentType ?? void 0;
+  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]"
+  };
+}
+
+export {
+  downloadMatrixMedia
+};
+//# sourceMappingURL=chunk-CSJO73LD.js.map

package/dist/chunk-CSJO73LD.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/matrix/monitor/media.ts"],
+  "sourcesContent": ["import { getMatrixRuntime } from \"../../runtime.js\";\nimport { MatrixMediaSizeLimitError, isMatrixMediaSizeLimitError } from \"../media-errors.js\";\nimport type { MatrixClient } from \"../sdk.js\";\n\n// Type for encrypted file info\ntype EncryptedFile = {\n  url: string;\n  key: {\n    kty: string;\n    key_ops: string[];\n    alg: string;\n    k: string;\n    ext: boolean;\n  };\n  iv: string;\n  hashes: Record<string, string>;\n  v: string;\n};\n\nconst MATRIX_MEDIA_DOWNLOAD_IDLE_TIMEOUT_MS = 30_000;\n\nasync function fetchMatrixMediaBuffer(params: {\n  client: MatrixClient;\n  mxcUrl: string;\n  maxBytes: number;\n}): Promise<{ buffer: Buffer } | null> {\n  try {\n    const buffer = await params.client.downloadContent(params.mxcUrl, {\n      maxBytes: params.maxBytes,\n      readIdleTimeoutMs: MATRIX_MEDIA_DOWNLOAD_IDLE_TIMEOUT_MS,\n    });\n    return { buffer };\n  } catch (err) {\n    if (isMatrixMediaSizeLimitError(err)) {\n      throw err;\n    }\n    throw new Error(`Matrix media download failed: ${String(err)}`, { cause: err });\n  }\n}\n\n/**\n * Download and decrypt encrypted media from a Matrix room.\n * Uses the Matrix crypto adapter's decryptMedia helper.\n */\nasync function fetchEncryptedMediaBuffer(params: {\n  client: MatrixClient;\n  file: EncryptedFile;\n  maxBytes: number;\n}): Promise<{ buffer: Buffer } | null> {\n  if (!params.client.crypto) {\n    throw new Error(\"Cannot decrypt media: crypto not enabled\");\n  }\n\n  const decrypted = await params.client.crypto.decryptMedia(\n    params.file as Parameters<typeof params.client.crypto.decryptMedia>[0],\n    {\n      maxBytes: params.maxBytes,\n      readIdleTimeoutMs: MATRIX_MEDIA_DOWNLOAD_IDLE_TIMEOUT_MS,\n    },\n  );\n\n  if (decrypted.byteLength > params.maxBytes) {\n    throw new MatrixMediaSizeLimitError();\n  }\n\n  return { buffer: decrypted };\n}\n\nexport async function downloadMatrixMedia(params: {\n  client: MatrixClient;\n  mxcUrl: string;\n  contentType?: string;\n  sizeBytes?: number;\n  maxBytes: number;\n  file?: EncryptedFile;\n  originalFilename?: string;\n}): Promise<{\n  path: string;\n  contentType?: string;\n  placeholder: string;\n} | null> {\n  let fetched: { buffer: Buffer; headerType?: string } | null;\n  if (typeof params.sizeBytes === \"number\" && params.sizeBytes > params.maxBytes) {\n    throw new MatrixMediaSizeLimitError();\n  }\n\n  if (params.file) {\n    // Encrypted media\n    fetched = await fetchEncryptedMediaBuffer({\n      client: params.client,\n      file: params.file,\n      maxBytes: params.maxBytes,\n    });\n  } else {\n    // Unencrypted media\n    fetched = await fetchMatrixMediaBuffer({\n      client: params.client,\n      mxcUrl: params.mxcUrl,\n      maxBytes: params.maxBytes,\n    });\n  }\n\n  if (!fetched) {\n    return null;\n  }\n  const headerType = params.contentType ?? undefined;\n  const saved = await getMatrixRuntime().channel.media.saveMediaBuffer(\n    fetched.buffer,\n    headerType,\n    \"inbound\",\n    params.maxBytes,\n    params.originalFilename,\n  );\n  return {\n    path: saved.path,\n    contentType: saved.contentType,\n    placeholder: \"[matrix media]\",\n  };\n}\n"],
+  "mappings": ";;;;;;;;;;;;AAAA;AAmBA,IAAM,wCAAwC;AAE9C,eAAe,uBAAuB,QAIC;AACrC,MAAI;AACF,UAAM,SAAS,MAAM,OAAO,OAAO,gBAAgB,OAAO,QAAQ;AAAA,MAChE,UAAU,OAAO;AAAA,MACjB,mBAAmB;AAAA,IACrB,CAAC;AACD,WAAO,EAAE,OAAO;AAAA,EAClB,SAAS,KAAK;AACZ,QAAI,4BAA4B,GAAG,GAAG;AACpC,YAAM;AAAA,IACR;AACA,UAAM,IAAI,MAAM,iCAAiC,OAAO,GAAG,CAAC,IAAI,EAAE,OAAO,IAAI,CAAC;AAAA,EAChF;AACF;AAMA,eAAe,0BAA0B,QAIF;AACrC,MAAI,CAAC,OAAO,OAAO,QAAQ;AACzB,UAAM,IAAI,MAAM,0CAA0C;AAAA,EAC5D;AAEA,QAAM,YAAY,MAAM,OAAO,OAAO,OAAO;AAAA,IAC3C,OAAO;AAAA,IACP;AAAA,MACE,UAAU,OAAO;AAAA,MACjB,mBAAmB;AAAA,IACrB;AAAA,EACF;AAEA,MAAI,UAAU,aAAa,OAAO,UAAU;AAC1C,UAAM,IAAI,0BAA0B;AAAA,EACtC;AAEA,SAAO,EAAE,QAAQ,UAAU;AAC7B;AAEA,eAAsB,oBAAoB,QAYhC;AACR,MAAI;AACJ,MAAI,OAAO,OAAO,cAAc,YAAY,OAAO,YAAY,OAAO,UAAU;AAC9E,UAAM,IAAI,0BAA0B;AAAA,EACtC;AAEA,MAAI,OAAO,MAAM;AAEf,cAAU,MAAM,0BAA0B;AAAA,MACxC,QAAQ,OAAO;AAAA,MACf,MAAM,OAAO;AAAA,MACb,UAAU,OAAO;AAAA,IACnB,CAAC;AAAA,EACH,OAAO;AAEL,cAAU,MAAM,uBAAuB;AAAA,MACrC,QAAQ,OAAO;AAAA,MACf,QAAQ,OAAO;AAAA,MACf,UAAU,OAAO;AAAA,IACnB,CAAC;AAAA,EACH;AAEA,MAAI,CAAC,SAAS;AACZ,WAAO;AAAA,EACT;AACA,QAAM,aAAa,OAAO,eAAe;AACzC,QAAM,QAAQ,MAAM,iBAAiB,EAAE,QAAQ,MAAM;AAAA,IACnD,QAAQ;AAAA,IACR;AAAA,IACA;AAAA,IACA,OAAO;AAAA,IACP,OAAO;AAAA,EACT;AACA,SAAO;AAAA,IACL,MAAM,MAAM;AAAA,IACZ,aAAa,MAAM;AAAA,IACnB,aAAa;AAAA,EACf;AACF;",
+  "names": []
+}

package/dist/chunk-CTKBDSL6.js

@@ -0,0 +1,81 @@
+import {
+  isBunRuntime
+} from "./chunk-TRWT2N6Z.js";
+import {
+  init_shims
+} from "./chunk-7FLQSTPG.js";
+
+// src/matrix/probe.ts
+init_shims();
+import { formatErrorMessage } from "openclaw/plugin-sdk/infra-runtime";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/text-runtime";
+var matrixProbeRuntimeDepsPromise;
+async function loadMatrixProbeRuntimeDeps() {
+  matrixProbeRuntimeDepsPromise ??= import("./src/matrix/probe.runtime.js").then((runtimeModule) => ({
+    createMatrixClient: runtimeModule.createMatrixClient
+  }));
+  return await matrixProbeRuntimeDepsPromise;
+}
+async function probeMatrix(params) {
+  const started = Date.now();
+  const result = {
+    ok: false,
+    status: null,
+    error: null,
+    elapsedMs: 0
+  };
+  if (isBunRuntime()) {
+    return {
+      ...result,
+      error: "Matrix probe requires Node (bun runtime not supported)",
+      elapsedMs: Date.now() - started
+    };
+  }
+  if (!params.homeserver?.trim()) {
+    return {
+      ...result,
+      error: "missing homeserver",
+      elapsedMs: Date.now() - started
+    };
+  }
+  if (!params.accessToken?.trim()) {
+    return {
+      ...result,
+      error: "missing access token",
+      elapsedMs: Date.now() - started
+    };
+  }
+  try {
+    const { createMatrixClient } = await loadMatrixProbeRuntimeDeps();
+    const inputUserId = normalizeOptionalString(params.userId);
+    const client = await createMatrixClient({
+      homeserver: params.homeserver,
+      userId: inputUserId,
+      accessToken: params.accessToken,
+      deviceId: params.deviceId,
+      persistStorage: false,
+      localTimeoutMs: params.timeoutMs,
+      accountId: params.accountId,
+      allowPrivateNetwork: params.allowPrivateNetwork,
+      ssrfPolicy: params.ssrfPolicy,
+      dispatcherPolicy: params.dispatcherPolicy
+    });
+    const userId = await client.getUserId();
+    result.ok = true;
+    result.userId = userId ?? null;
+    result.elapsedMs = Date.now() - started;
+    return result;
+  } catch (err) {
+    return {
+      ...result,
+      status: typeof err === "object" && err && "statusCode" in err ? Number(err.statusCode) : result.status,
+      error: formatErrorMessage(err),
+      elapsedMs: Date.now() - started
+    };
+  }
+}
+
+export {
+  probeMatrix
+};
+//# sourceMappingURL=chunk-CTKBDSL6.js.map

package/dist/chunk-CTKBDSL6.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/matrix/probe.ts"],
+  "sourcesContent": ["import { formatErrorMessage, type PinnedDispatcherPolicy } from \"openclaw/plugin-sdk/infra-runtime\";\nimport { normalizeOptionalString } from \"openclaw/plugin-sdk/text-runtime\";\nimport type { SsrFPolicy } from \"../runtime-api.js\";\nimport type { BaseProbeResult } from \"../runtime-api.js\";\nimport { isBunRuntime } from \"./client/runtime.js\";\n\ntype MatrixProbeRuntimeDeps = Pick<typeof import(\"./probe.runtime.js\"), \"createMatrixClient\">;\n\nlet matrixProbeRuntimeDepsPromise: Promise<MatrixProbeRuntimeDeps> | undefined;\n\nasync function loadMatrixProbeRuntimeDeps(): Promise<MatrixProbeRuntimeDeps> {\n  matrixProbeRuntimeDepsPromise ??= import(\"./probe.runtime.js\").then((runtimeModule) => ({\n    createMatrixClient: runtimeModule.createMatrixClient,\n  }));\n  return await matrixProbeRuntimeDepsPromise;\n}\n\nexport type MatrixProbe = BaseProbeResult & {\n  status?: number | null;\n  elapsedMs: number;\n  userId?: string | null;\n};\n\nexport async function probeMatrix(params: {\n  homeserver: string;\n  accessToken: string;\n  userId?: string;\n  deviceId?: string;\n  timeoutMs?: number;\n  accountId?: string | null;\n  allowPrivateNetwork?: boolean;\n  ssrfPolicy?: SsrFPolicy;\n  dispatcherPolicy?: PinnedDispatcherPolicy;\n}): Promise<MatrixProbe> {\n  const started = Date.now();\n  const result: MatrixProbe = {\n    ok: false,\n    status: null,\n    error: null,\n    elapsedMs: 0,\n  };\n  if (isBunRuntime()) {\n    return {\n      ...result,\n      error: \"Matrix probe requires Node (bun runtime not supported)\",\n      elapsedMs: Date.now() - started,\n    };\n  }\n  if (!params.homeserver?.trim()) {\n    return {\n      ...result,\n      error: \"missing homeserver\",\n      elapsedMs: Date.now() - started,\n    };\n  }\n  if (!params.accessToken?.trim()) {\n    return {\n      ...result,\n      error: \"missing access token\",\n      elapsedMs: Date.now() - started,\n    };\n  }\n  try {\n    const { createMatrixClient } = await loadMatrixProbeRuntimeDeps();\n    const inputUserId = normalizeOptionalString(params.userId);\n    const client = await createMatrixClient({\n      homeserver: params.homeserver,\n      userId: inputUserId,\n      accessToken: params.accessToken,\n      deviceId: params.deviceId,\n      persistStorage: false,\n      localTimeoutMs: params.timeoutMs,\n      accountId: params.accountId,\n      allowPrivateNetwork: params.allowPrivateNetwork,\n      ssrfPolicy: params.ssrfPolicy,\n      dispatcherPolicy: params.dispatcherPolicy,\n    });\n    // The client wrapper resolves user ID via whoami when needed.\n    const userId = await client.getUserId();\n    result.ok = true;\n    result.userId = userId ?? null;\n\n    result.elapsedMs = Date.now() - started;\n    return result;\n  } catch (err) {\n    return {\n      ...result,\n      status:\n        typeof err === \"object\" && err && \"statusCode\" in err\n          ? Number((err as { statusCode?: number }).statusCode)\n          : result.status,\n      error: formatErrorMessage(err),\n      elapsedMs: Date.now() - started,\n    };\n  }\n}\n"],
+  "mappings": ";;;;;;;;AAAA;AAAA,SAAS,0BAAuD;AAChE,SAAS,+BAA+B;AAOxC,IAAI;AAEJ,eAAe,6BAA8D;AAC3E,oCAAkC,OAAO,+BAAoB,EAAE,KAAK,CAAC,mBAAmB;AAAA,IACtF,oBAAoB,cAAc;AAAA,EACpC,EAAE;AACF,SAAO,MAAM;AACf;AAQA,eAAsB,YAAY,QAUT;AACvB,QAAM,UAAU,KAAK,IAAI;AACzB,QAAM,SAAsB;AAAA,IAC1B,IAAI;AAAA,IACJ,QAAQ;AAAA,IACR,OAAO;AAAA,IACP,WAAW;AAAA,EACb;AACA,MAAI,aAAa,GAAG;AAClB,WAAO;AAAA,MACL,GAAG;AAAA,MACH,OAAO;AAAA,MACP,WAAW,KAAK,IAAI,IAAI;AAAA,IAC1B;AAAA,EACF;AACA,MAAI,CAAC,OAAO,YAAY,KAAK,GAAG;AAC9B,WAAO;AAAA,MACL,GAAG;AAAA,MACH,OAAO;AAAA,MACP,WAAW,KAAK,IAAI,IAAI;AAAA,IAC1B;AAAA,EACF;AACA,MAAI,CAAC,OAAO,aAAa,KAAK,GAAG;AAC/B,WAAO;AAAA,MACL,GAAG;AAAA,MACH,OAAO;AAAA,MACP,WAAW,KAAK,IAAI,IAAI;AAAA,IAC1B;AAAA,EACF;AACA,MAAI;AACF,UAAM,EAAE,mBAAmB,IAAI,MAAM,2BAA2B;AAChE,UAAM,cAAc,wBAAwB,OAAO,MAAM;AACzD,UAAM,SAAS,MAAM,mBAAmB;AAAA,MACtC,YAAY,OAAO;AAAA,MACnB,QAAQ;AAAA,MACR,aAAa,OAAO;AAAA,MACpB,UAAU,OAAO;AAAA,MACjB,gBAAgB;AAAA,MAChB,gBAAgB,OAAO;AAAA,MACvB,WAAW,OAAO;AAAA,MAClB,qBAAqB,OAAO;AAAA,MAC5B,YAAY,OAAO;AAAA,MACnB,kBAAkB,OAAO;AAAA,IAC3B,CAAC;AAED,UAAM,SAAS,MAAM,OAAO,UAAU;AACtC,WAAO,KAAK;AACZ,WAAO,SAAS,UAAU;AAE1B,WAAO,YAAY,KAAK,IAAI,IAAI;AAChC,WAAO;AAAA,EACT,SAAS,KAAK;AACZ,WAAO;AAAA,MACL,GAAG;AAAA,MACH,QACE,OAAO,QAAQ,YAAY,OAAO,gBAAgB,MAC9C,OAAQ,IAAgC,UAAU,IAClD,OAAO;AAAA,MACb,OAAO,mBAAmB,GAAG;AAAA,MAC7B,WAAW,KAAK,IAAI,IAAI;AAAA,IAC1B;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/chunk-CY6WHUCW.js

@@ -0,0 +1,54 @@
+import {
+  init_shims
+} from "./chunk-7FLQSTPG.js";
+
+// src/matrix/sdk/idb-persistence-lock.ts
+init_shims();
+var MATRIX_IDB_PERSIST_INTERVAL_MS = 6e4;
+var IDB_SNAPSHOT_LOCK_STALE_MS = 5 * 6e4;
+var IDB_SNAPSHOT_LOCK_RETRY_BASE = {
+  factor: 2,
+  minTimeout: 50,
+  maxTimeout: 5e3,
+  randomize: true
+};
+function computeRetryDelayMs(retries, attempt) {
+  return Math.min(
+    retries.maxTimeout,
+    Math.max(retries.minTimeout, retries.minTimeout * retries.factor ** attempt)
+  );
+}
+function computeMinimumRetryWindowMs(retries) {
+  let total = 0;
+  const attempts = Math.max(1, retries.retries + 1);
+  for (let attempt = 0; attempt < attempts - 1; attempt += 1) {
+    total += computeRetryDelayMs(retries, attempt);
+  }
+  return total;
+}
+function resolveRetriesForMinimumWindowMs(retries, minimumWindowMs) {
+  const resolved = {
+    ...retries,
+    retries: 0
+  };
+  while (computeMinimumRetryWindowMs(resolved) < minimumWindowMs) {
+    resolved.retries += 1;
+  }
+  return resolved;
+}
+var MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS = {
+  // Wait longer than one periodic persist interval so a concurrent restore
+  // or large snapshot dump finishes instead of forcing warn-and-continue.
+  retries: resolveRetriesForMinimumWindowMs(
+    IDB_SNAPSHOT_LOCK_RETRY_BASE,
+    MATRIX_IDB_PERSIST_INTERVAL_MS
+  ),
+  stale: IDB_SNAPSHOT_LOCK_STALE_MS
+};
+
+export {
+  MATRIX_IDB_PERSIST_INTERVAL_MS,
+  computeMinimumRetryWindowMs,
+  MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS
+};
+//# sourceMappingURL=chunk-CY6WHUCW.js.map

package/dist/chunk-CY6WHUCW.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/matrix/sdk/idb-persistence-lock.ts"],
+  "sourcesContent": ["import type { FileLockOptions } from \"openclaw/plugin-sdk/infra-runtime\";\n\nexport const MATRIX_IDB_PERSIST_INTERVAL_MS = 60_000;\n\nconst IDB_SNAPSHOT_LOCK_STALE_MS = 5 * 60_000;\nconst IDB_SNAPSHOT_LOCK_RETRY_BASE = {\n  factor: 2,\n  minTimeout: 50,\n  maxTimeout: 5_000,\n  randomize: true,\n} satisfies Omit<FileLockOptions[\"retries\"], \"retries\">;\n\nfunction computeRetryDelayMs(retries: FileLockOptions[\"retries\"], attempt: number): number {\n  return Math.min(\n    retries.maxTimeout,\n    Math.max(retries.minTimeout, retries.minTimeout * retries.factor ** attempt),\n  );\n}\n\nexport function computeMinimumRetryWindowMs(retries: FileLockOptions[\"retries\"]): number {\n  let total = 0;\n  const attempts = Math.max(1, retries.retries + 1);\n  for (let attempt = 0; attempt < attempts - 1; attempt += 1) {\n    total += computeRetryDelayMs(retries, attempt);\n  }\n  return total;\n}\n\nfunction resolveRetriesForMinimumWindowMs(\n  retries: Omit<FileLockOptions[\"retries\"], \"retries\">,\n  minimumWindowMs: number,\n): FileLockOptions[\"retries\"] {\n  const resolved: FileLockOptions[\"retries\"] = {\n    ...retries,\n    retries: 0,\n  };\n  while (computeMinimumRetryWindowMs(resolved) < minimumWindowMs) {\n    resolved.retries += 1;\n  }\n  return resolved;\n}\n\nexport const MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS: FileLockOptions = {\n  // Wait longer than one periodic persist interval so a concurrent restore\n  // or large snapshot dump finishes instead of forcing warn-and-continue.\n  retries: resolveRetriesForMinimumWindowMs(\n    IDB_SNAPSHOT_LOCK_RETRY_BASE,\n    MATRIX_IDB_PERSIST_INTERVAL_MS,\n  ),\n  stale: IDB_SNAPSHOT_LOCK_STALE_MS,\n};\n"],
+  "mappings": ";;;;;AAAA;AAEO,IAAM,iCAAiC;AAE9C,IAAM,6BAA6B,IAAI;AACvC,IAAM,+BAA+B;AAAA,EACnC,QAAQ;AAAA,EACR,YAAY;AAAA,EACZ,YAAY;AAAA,EACZ,WAAW;AACb;AAEA,SAAS,oBAAoB,SAAqC,SAAyB;AACzF,SAAO,KAAK;AAAA,IACV,QAAQ;AAAA,IACR,KAAK,IAAI,QAAQ,YAAY,QAAQ,aAAa,QAAQ,UAAU,OAAO;AAAA,EAC7E;AACF;AAEO,SAAS,4BAA4B,SAA6C;AACvF,MAAI,QAAQ;AACZ,QAAM,WAAW,KAAK,IAAI,GAAG,QAAQ,UAAU,CAAC;AAChD,WAAS,UAAU,GAAG,UAAU,WAAW,GAAG,WAAW,GAAG;AAC1D,aAAS,oBAAoB,SAAS,OAAO;AAAA,EAC/C;AACA,SAAO;AACT;AAEA,SAAS,iCACP,SACA,iBAC4B;AAC5B,QAAM,WAAuC;AAAA,IAC3C,GAAG;AAAA,IACH,SAAS;AAAA,EACX;AACA,SAAO,4BAA4B,QAAQ,IAAI,iBAAiB;AAC9D,aAAS,WAAW;AAAA,EACtB;AACA,SAAO;AACT;AAEO,IAAM,mCAAoD;AAAA;AAAA;AAAA,EAG/D,SAAS;AAAA,IACP;AAAA,IACA;AAAA,EACF;AAAA,EACA,OAAO;AACT;",
+  "names": []
+}

package/dist/chunk-D4GYYYMW.js

@@ -0,0 +1,155 @@
+import {
+  markdownToMatrixHtml,
+  renderMarkdownToMatrixHtmlWithMentions,
+  resolveMatrixMentionsInMarkdown
+} from "./chunk-M4VQPIF4.js";
+import {
+  MsgType,
+  RelationType
+} from "./chunk-JGIZPU2Y.js";
+import {
+  getMatrixRuntime
+} from "./chunk-ZGAUVPAB.js";
+import {
+  init_shims
+} from "./chunk-G4TIS2SC.js";
+
+// src/matrix/send/formatting.ts
+init_shims();
+var getCore = () => getMatrixRuntime();
+async function renderMatrixFormattedContent(params) {
+  const markdown = params.markdown ?? "";
+  if (params.includeMentions === false) {
+    const html2 = markdownToMatrixHtml(markdown).trimEnd();
+    return { html: html2 || void 0 };
+  }
+  const { html, mentions } = await renderMarkdownToMatrixHtmlWithMentions({
+    markdown,
+    client: params.client
+  });
+  return { html, mentions };
+}
+function buildTextContent(body, relation, opts = {}) {
+  const msgtype = opts.msgtype ?? MsgType.Text;
+  return relation ? {
+    msgtype,
+    body,
+    "m.relates_to": relation
+  } : {
+    msgtype,
+    body
+  };
+}
+async function enrichMatrixFormattedContent(params) {
+  const { html, mentions } = await renderMatrixFormattedContent({
+    client: params.client,
+    markdown: params.markdown,
+    includeMentions: params.includeMentions
+  });
+  if (mentions) {
+    params.content["m.mentions"] = mentions;
+  } else {
+    delete params.content["m.mentions"];
+  }
+  if (!html) {
+    delete params.content.format;
+    delete params.content.formatted_body;
+    return;
+  }
+  params.content.format = "org.matrix.custom.html";
+  params.content.formatted_body = html;
+}
+async function resolveMatrixMentionsForBody(params) {
+  return await resolveMatrixMentionsInMarkdown({
+    markdown: params.body ?? "",
+    client: params.client
+  });
+}
+function normalizeMentionUserIds(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.trim().length > 0) : [];
+}
+function extractMatrixMentions(content) {
+  const rawMentions = content?.["m.mentions"];
+  if (!rawMentions || typeof rawMentions !== "object") {
+    return {};
+  }
+  const mentions = rawMentions;
+  const normalized = {};
+  const userIds = normalizeMentionUserIds(mentions.user_ids);
+  if (userIds.length > 0) {
+    normalized.user_ids = userIds;
+  }
+  if (mentions.room === true) {
+    normalized.room = true;
+  }
+  return normalized;
+}
+function diffMatrixMentions(current, previous) {
+  const previousUserIds = new Set(previous.user_ids ?? []);
+  const newUserIds = (current.user_ids ?? []).filter((userId) => !previousUserIds.has(userId));
+  const delta = {};
+  if (newUserIds.length > 0) {
+    delta.user_ids = newUserIds;
+  }
+  if (current.room && !previous.room) {
+    delta.room = true;
+  }
+  return delta;
+}
+function buildReplyRelation(replyToId) {
+  const trimmed = replyToId?.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  return { "m.in_reply_to": { event_id: trimmed } };
+}
+function buildThreadRelation(threadId, replyToId) {
+  const trimmed = threadId.trim();
+  return {
+    rel_type: RelationType.Thread,
+    event_id: trimmed,
+    is_falling_back: true,
+    "m.in_reply_to": { event_id: replyToId?.trim() || trimmed }
+  };
+}
+function resolveMatrixMsgType(contentType, _fileName) {
+  const kind = getCore().media.mediaKindFromMime(contentType ?? "");
+  switch (kind) {
+    case "image":
+      return MsgType.Image;
+    case "audio":
+      return MsgType.Audio;
+    case "video":
+      return MsgType.Video;
+    default:
+      return MsgType.File;
+  }
+}
+function resolveMatrixVoiceDecision(opts) {
+  if (!opts.wantsVoice) {
+    return { useVoice: false };
+  }
+  if (isMatrixVoiceCompatibleAudio(opts)) {
+    return { useVoice: true };
+  }
+  return { useVoice: false };
+}
+function isMatrixVoiceCompatibleAudio(opts) {
+  return getCore().media.isVoiceCompatibleAudio({
+    contentType: opts.contentType,
+    fileName: opts.fileName
+  });
+}
+
+export {
+  buildTextContent,
+  enrichMatrixFormattedContent,
+  resolveMatrixMentionsForBody,
+  extractMatrixMentions,
+  diffMatrixMentions,
+  buildReplyRelation,
+  buildThreadRelation,
+  resolveMatrixMsgType,
+  resolveMatrixVoiceDecision
+};
+//# sourceMappingURL=chunk-D4GYYYMW.js.map

package/dist/chunk-D4GYYYMW.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/matrix/send/formatting.ts"],
+  "sourcesContent": ["import { getMatrixRuntime } from \"../../runtime.js\";\nimport {\n  markdownToMatrixHtml,\n  resolveMatrixMentionsInMarkdown,\n  renderMarkdownToMatrixHtmlWithMentions,\n  type MatrixMentions,\n} from \"../format.js\";\nimport type { MatrixClient } from \"../sdk.js\";\nimport {\n  MsgType,\n  RelationType,\n  type MatrixFormattedContent,\n  type MatrixMediaMsgType,\n  type MatrixRelation,\n  type MatrixReplyRelation,\n  type MatrixTextContent,\n  type MatrixTextMsgType,\n  type MatrixThreadRelation,\n} from \"./types.js\";\n\nconst getCore = () => getMatrixRuntime();\n\nasync function renderMatrixFormattedContent(params: {\n  client: MatrixClient;\n  markdown?: string | null;\n  includeMentions?: boolean;\n}): Promise<{ html?: string; mentions?: MatrixMentions }> {\n  const markdown = params.markdown ?? \"\";\n  if (params.includeMentions === false) {\n    const html = markdownToMatrixHtml(markdown).trimEnd();\n    return { html: html || undefined };\n  }\n  const { html, mentions } = await renderMarkdownToMatrixHtmlWithMentions({\n    markdown,\n    client: params.client,\n  });\n  return { html, mentions };\n}\n\nexport function buildTextContent(\n  body: string,\n  relation?: MatrixRelation,\n  opts: {\n    msgtype?: MatrixTextMsgType;\n  } = {},\n): MatrixTextContent {\n  const msgtype = opts.msgtype ?? MsgType.Text;\n  return relation\n    ? {\n        msgtype,\n        body,\n        \"m.relates_to\": relation,\n      }\n    : {\n        msgtype,\n        body,\n      };\n}\n\nexport async function enrichMatrixFormattedContent(params: {\n  client: MatrixClient;\n  content: MatrixFormattedContent;\n  markdown?: string | null;\n  includeMentions?: boolean;\n}): Promise<void> {\n  const { html, mentions } = await renderMatrixFormattedContent({\n    client: params.client,\n    markdown: params.markdown,\n    includeMentions: params.includeMentions,\n  });\n  if (mentions) {\n    params.content[\"m.mentions\"] = mentions;\n  } else {\n    delete params.content[\"m.mentions\"];\n  }\n  if (!html) {\n    delete params.content.format;\n    delete params.content.formatted_body;\n    return;\n  }\n  params.content.format = \"org.matrix.custom.html\";\n  params.content.formatted_body = html;\n}\n\nexport async function resolveMatrixMentionsForBody(params: {\n  client: MatrixClient;\n  body: string;\n}): Promise<MatrixMentions> {\n  return await resolveMatrixMentionsInMarkdown({\n    markdown: params.body ?? \"\",\n    client: params.client,\n  });\n}\n\nfunction normalizeMentionUserIds(value: unknown): string[] {\n  return Array.isArray(value)\n    ? value.filter((entry): entry is string => typeof entry === \"string\" && entry.trim().length > 0)\n    : [];\n}\n\nexport function extractMatrixMentions(\n  content: Record<string, unknown> | undefined,\n): MatrixMentions {\n  const rawMentions = content?.[\"m.mentions\"];\n  if (!rawMentions || typeof rawMentions !== \"object\") {\n    return {};\n  }\n  const mentions = rawMentions as { room?: unknown; user_ids?: unknown };\n  const normalized: MatrixMentions = {};\n  const userIds = normalizeMentionUserIds(mentions.user_ids);\n  if (userIds.length > 0) {\n    normalized.user_ids = userIds;\n  }\n  if (mentions.room === true) {\n    normalized.room = true;\n  }\n  return normalized;\n}\n\nexport function diffMatrixMentions(\n  current: MatrixMentions,\n  previous: MatrixMentions,\n): MatrixMentions {\n  const previousUserIds = new Set(previous.user_ids ?? []);\n  const newUserIds = (current.user_ids ?? []).filter((userId) => !previousUserIds.has(userId));\n  const delta: MatrixMentions = {};\n  if (newUserIds.length > 0) {\n    delta.user_ids = newUserIds;\n  }\n  if (current.room && !previous.room) {\n    delta.room = true;\n  }\n  return delta;\n}\n\nexport function buildReplyRelation(replyToId?: string): MatrixReplyRelation | undefined {\n  const trimmed = replyToId?.trim();\n  if (!trimmed) {\n    return undefined;\n  }\n  return { \"m.in_reply_to\": { event_id: trimmed } };\n}\n\nexport function buildThreadRelation(threadId: string, replyToId?: string): MatrixThreadRelation {\n  const trimmed = threadId.trim();\n  return {\n    rel_type: RelationType.Thread,\n    event_id: trimmed,\n    is_falling_back: true,\n    \"m.in_reply_to\": { event_id: replyToId?.trim() || trimmed },\n  };\n}\n\nexport function resolveMatrixMsgType(contentType?: string, _fileName?: string): MatrixMediaMsgType {\n  const kind = getCore().media.mediaKindFromMime(contentType ?? \"\");\n  switch (kind) {\n    case \"image\":\n      return MsgType.Image;\n    case \"audio\":\n      return MsgType.Audio;\n    case \"video\":\n      return MsgType.Video;\n    default:\n      return MsgType.File;\n  }\n}\n\nexport function resolveMatrixVoiceDecision(opts: {\n  wantsVoice: boolean;\n  contentType?: string;\n  fileName?: string;\n}): { useVoice: boolean } {\n  if (!opts.wantsVoice) {\n    return { useVoice: false };\n  }\n  if (isMatrixVoiceCompatibleAudio(opts)) {\n    return { useVoice: true };\n  }\n  return { useVoice: false };\n}\n\nfunction isMatrixVoiceCompatibleAudio(opts: { contentType?: string; fileName?: string }): boolean {\n  // Matrix currently shares the core voice compatibility policy.\n  // Keep this wrapper as the seam if Matrix policy diverges later.\n  return getCore().media.isVoiceCompatibleAudio({\n    contentType: opts.contentType,\n    fileName: opts.fileName,\n  });\n}\n"],
+  "mappings": "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",
+  "names": ["html"]
+}

package/dist/chunk-D64CZG54.js

@@ -0,0 +1,78 @@
+import {
+  getMatrixRuntime
+} from "./chunk-ZGAUVPAB.js";
+import {
+  init_shims
+} from "./chunk-G4TIS2SC.js";
+
+// src/matrix/monitor/auto-join.ts
+init_shims();
+import { normalizeStringifiedOptionalString } from "openclaw/plugin-sdk/text-runtime";
+function registerMatrixAutoJoin(params) {
+  const { client, accountConfig, runtime } = params;
+  const core = getMatrixRuntime();
+  const logVerbose = (message) => {
+    if (!core.logging.shouldLogVerbose()) {
+      return;
+    }
+    runtime.log?.(message);
+  };
+  const autoJoin = accountConfig.autoJoin ?? "off";
+  const rawAllowlist = (accountConfig.autoJoinAllowlist ?? []).map((entry) => normalizeStringifiedOptionalString(entry)).filter((entry) => Boolean(entry));
+  const autoJoinAllowlist = new Set(rawAllowlist);
+  const allowedRoomIds = new Set(rawAllowlist.filter((entry) => entry.startsWith("!")));
+  const allowedAliases = rawAllowlist.filter((entry) => entry.startsWith("#"));
+  const resolvedAliasRoomIds = /* @__PURE__ */ new Map();
+  if (autoJoin === "off") {
+    return;
+  }
+  if (autoJoin === "always") {
+    logVerbose("matrix: auto-join enabled for all invites");
+  } else {
+    logVerbose("matrix: auto-join enabled for allowlist invites");
+  }
+  const resolveAllowedAliasRoomId = async (alias) => {
+    if (resolvedAliasRoomIds.has(alias)) {
+      return resolvedAliasRoomIds.get(alias) ?? null;
+    }
+    const resolved = await params.client.resolveRoom(alias);
+    if (resolved) {
+      resolvedAliasRoomIds.set(alias, resolved);
+    }
+    return resolved;
+  };
+  const resolveAllowedAliasRoomIds = async () => {
+    const resolved = await Promise.all(
+      allowedAliases.map(async (alias) => {
+        try {
+          return await resolveAllowedAliasRoomId(alias);
+        } catch (err) {
+          runtime.error?.(`matrix: failed resolving allowlisted alias ${alias}: ${String(err)}`);
+          return null;
+        }
+      })
+    );
+    return resolved.filter((roomId) => Boolean(roomId));
+  };
+  client.on("room.invite", async (roomId, _inviteEvent) => {
+    if (autoJoin === "allowlist") {
+      const allowedAliasRoomIds = await resolveAllowedAliasRoomIds();
+      const allowed = autoJoinAllowlist.has("*") || allowedRoomIds.has(roomId) || allowedAliasRoomIds.some((resolvedRoomId) => resolvedRoomId === roomId);
+      if (!allowed) {
+        logVerbose(`matrix: invite ignored (not in allowlist) room=${roomId}`);
+        return;
+      }
+    }
+    try {
+      await client.joinRoom(roomId);
+      logVerbose(`matrix: joined room ${roomId}`);
+    } catch (err) {
+      runtime.error?.(`matrix: failed to join room ${roomId}: ${String(err)}`);
+    }
+  });
+}
+
+export {
+  registerMatrixAutoJoin
+};
+//# sourceMappingURL=chunk-D64CZG54.js.map