@openclaw/matrix 2026.3.1 → 2026.3.7

package/src/matrix/send.test.ts

@@ -1,4 +1,4 @@
-import type { PluginRuntime } from "openclaw/plugin-sdk";
+import type { PluginRuntime } from "openclaw/plugin-sdk/matrix";
 import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
 import { setMatrixRuntime } from "../runtime.js";
 
@@ -24,12 +24,17 @@ vi.mock("@vector-im/matrix-bot-sdk", () => ({
   RustSdkCryptoStorageProvider: vi.fn(),
 }));
 
+vi.mock("./send-queue.js", () => ({
+  enqueueSend: async <T>(_roomId: string, fn: () => Promise<T>) => await fn(),
+}));
+
 const loadWebMediaMock = vi.fn().mockResolvedValue({
   buffer: Buffer.from("media"),
   fileName: "photo.png",
   contentType: "image/png",
   kind: "image",
 });
+const runtimeLoadConfigMock = vi.fn(() => ({}));
 const mediaKindFromMimeMock = vi.fn(() => "image");
 const isVoiceCompatibleAudioMock = vi.fn(() => false);
 const getImageMetadataMock = vi.fn().mockResolvedValue(null);
@@ -37,7 +42,7 @@ const resizeToJpegMock = vi.fn();
 
 const runtimeStub = {
   config: {
-    loadConfig: () => ({}),
+    loadConfig: runtimeLoadConfigMock,
   },
   media: {
     loadWebMedia: loadWebMediaMock as unknown as PluginRuntime["media"]["loadWebMedia"],
@@ -61,6 +66,7 @@ const runtimeStub = {
 } as unknown as PluginRuntime;
 
 let sendMessageMatrix: typeof import("./send.js").sendMessageMatrix;
+let resolveMediaMaxBytes: typeof import("./send/client.js").resolveMediaMaxBytes;
 
 const makeClient = () => {
   const sendMessage = vi.fn().mockResolvedValue("evt1");
@@ -76,11 +82,14 @@ const makeClient = () => {
 beforeAll(async () => {
   setMatrixRuntime(runtimeStub);
   ({ sendMessageMatrix } = await import("./send.js"));
+  ({ resolveMediaMaxBytes } = await import("./send/client.js"));
 });
 
 describe("sendMessageMatrix media", () => {
   beforeEach(() => {
     vi.clearAllMocks();
+    runtimeLoadConfigMock.mockReset();
+    runtimeLoadConfigMock.mockReturnValue({});
     mediaKindFromMimeMock.mockReturnValue("image");
     isVoiceCompatibleAudioMock.mockReturnValue(false);
     setMatrixRuntime(runtimeStub);
@@ -210,6 +219,8 @@ describe("sendMessageMatrix media", () => {
 describe("sendMessageMatrix threads", () => {
   beforeEach(() => {
     vi.clearAllMocks();
+    runtimeLoadConfigMock.mockReset();
+    runtimeLoadConfigMock.mockReturnValue({});
     setMatrixRuntime(runtimeStub);
   });
 
@@ -236,3 +247,80 @@ describe("sendMessageMatrix threads", () => {
     });
   });
 });
+
+describe("sendMessageMatrix cfg threading", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    runtimeLoadConfigMock.mockReset();
+    runtimeLoadConfigMock.mockReturnValue({
+      channels: {
+        matrix: {
+          mediaMaxMb: 7,
+        },
+      },
+    });
+    setMatrixRuntime(runtimeStub);
+  });
+
+  it("does not call runtime loadConfig when cfg is provided", async () => {
+    const { client } = makeClient();
+    const providedCfg = {
+      channels: {
+        matrix: {
+          mediaMaxMb: 4,
+        },
+      },
+    };
+
+    await sendMessageMatrix("room:!room:example", "hello cfg", {
+      client,
+      cfg: providedCfg as any,
+    });
+
+    expect(runtimeLoadConfigMock).not.toHaveBeenCalled();
+  });
+
+  it("falls back to runtime loadConfig when cfg is omitted", async () => {
+    const { client } = makeClient();
+
+    await sendMessageMatrix("room:!room:example", "hello runtime", { client });
+
+    expect(runtimeLoadConfigMock).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("resolveMediaMaxBytes cfg threading", () => {
+  beforeEach(() => {
+    runtimeLoadConfigMock.mockReset();
+    runtimeLoadConfigMock.mockReturnValue({
+      channels: {
+        matrix: {
+          mediaMaxMb: 9,
+        },
+      },
+    });
+    setMatrixRuntime(runtimeStub);
+  });
+
+  it("uses provided cfg and skips runtime loadConfig", () => {
+    const providedCfg = {
+      channels: {
+        matrix: {
+          mediaMaxMb: 3,
+        },
+      },
+    };
+
+    const maxBytes = resolveMediaMaxBytes(undefined, providedCfg as any);
+
+    expect(maxBytes).toBe(3 * 1024 * 1024);
+    expect(runtimeLoadConfigMock).not.toHaveBeenCalled();
+  });
+
+  it("falls back to runtime loadConfig when cfg is omitted", () => {
+    const maxBytes = resolveMediaMaxBytes();
+
+    expect(maxBytes).toBe(9 * 1024 * 1024);
+    expect(runtimeLoadConfigMock).toHaveBeenCalledTimes(1);
+  });
+});

package/src/matrix/send.ts

@@ -1,5 +1,5 @@
 import type { MatrixClient } from "@vector-im/matrix-bot-sdk";
-import type { PollInput } from "openclaw/plugin-sdk";
+import type { PollInput } from "openclaw/plugin-sdk/matrix";
 import { getMatrixRuntime } from "../runtime.js";
 import { buildPollStartContent, M_POLL_START } from "./poll-types.js";
 import { enqueueSend } from "./send-queue.js";
@@ -47,11 +47,12 @@ export async function sendMessageMatrix(
     client: opts.client,
     timeoutMs: opts.timeoutMs,
     accountId: opts.accountId,
+    cfg: opts.cfg,
   });
+  const cfg = opts.cfg ?? getCore().config.loadConfig();
   try {
     const roomId = await resolveMatrixRoomId(client, to);
     return await enqueueSend(roomId, async () => {
-      const cfg = getCore().config.loadConfig();
       const tableMode = getCore().channel.text.resolveMarkdownTableMode({
         cfg,
         channel: "matrix",
@@ -81,7 +82,7 @@ export async function sendMessageMatrix(
 
       let lastMessageId = "";
       if (opts.mediaUrl) {
-        const maxBytes = resolveMediaMaxBytes(opts.accountId);
+        const maxBytes = resolveMediaMaxBytes(opts.accountId, cfg);
         const media = await getCore().media.loadWebMedia(opts.mediaUrl, maxBytes);
         const uploaded = await uploadMediaMaybeEncrypted(client, roomId, media.buffer, {
           contentType: media.contentType,
@@ -91,7 +92,7 @@ export async function sendMessageMatrix(
           buffer: media.buffer,
           contentType: media.contentType,
           fileName: media.fileName,
-          kind: media.kind,
+          kind: media.kind ?? "unknown",
         });
         const baseMsgType = resolveMatrixMsgType(media.contentType, media.fileName);
         const { useVoice } = resolveMatrixVoiceDecision({
@@ -171,6 +172,7 @@ export async function sendPollMatrix(
     client: opts.client,
     timeoutMs: opts.timeoutMs,
     accountId: opts.accountId,
+    cfg: opts.cfg,
   });
 
   try {

package/src/onboarding.ts

@@ -1,13 +1,19 @@
-import type { DmPolicy } from "openclaw/plugin-sdk";
+import type { DmPolicy } from "openclaw/plugin-sdk/matrix";
 import {
   addWildcardAllowFrom,
+  buildSingleChannelSecretPromptState,
+  formatResolvedUnresolvedNote,
   formatDocsLink,
+  hasConfiguredSecretInput,
   mergeAllowFromEntries,
+  promptSingleChannelSecretInput,
   promptChannelAccessConfig,
+  setTopLevelChannelGroupPolicy,
+  type SecretInput,
   type ChannelOnboardingAdapter,
   type ChannelOnboardingDmPolicy,
   type WizardPrompter,
-} from "openclaw/plugin-sdk";
+} from "openclaw/plugin-sdk/matrix";
 import { listMatrixDirectoryGroupsLive } from "./directory-live.js";
 import { resolveMatrixAccount } from "./matrix/accounts.js";
 import { ensureMatrixSdkInstalled, isMatrixSdkAvailable } from "./matrix/deps.js";
@@ -139,17 +145,12 @@ async function promptMatrixAllowFrom(params: {
 }
 
 function setMatrixGroupPolicy(cfg: CoreConfig, groupPolicy: "open" | "allowlist" | "disabled") {
-  return {
-    ...cfg,
-    channels: {
-      ...cfg.channels,
-      matrix: {
-        ...cfg.channels?.matrix,
-        enabled: true,
-        groupPolicy,
-      },
-    },
-  };
+  return setTopLevelChannelGroupPolicy({
+    cfg,
+    channel: "matrix",
+    groupPolicy,
+    enabled: true,
+  }) as CoreConfig;
 }
 
 function setMatrixGroupRooms(cfg: CoreConfig, roomKeys: string[]) {
@@ -265,22 +266,24 @@ export const matrixOnboardingAdapter: ChannelOnboardingAdapter = {
     ).trim();
 
     let accessToken = existing.accessToken ?? "";
-    let password = existing.password ?? "";
+    let password: SecretInput | undefined = existing.password;
     let userId = existing.userId ?? "";
+    const existingPasswordConfigured = hasConfiguredSecretInput(existing.password);
+    const passwordConfigured = () => hasConfiguredSecretInput(password);
 
-    if (accessToken || password) {
+    if (accessToken || passwordConfigured()) {
       const keep = await prompter.confirm({
         message: "Matrix credentials already configured. Keep them?",
         initialValue: true,
       });
       if (!keep) {
         accessToken = "";
-        password = "";
+        password = undefined;
         userId = "";
       }
     }
 
-    if (!accessToken && !password) {
+    if (!accessToken && !passwordConfigured()) {
       // Ask auth method FIRST before asking for user ID
       const authMode = await prompter.select({
         message: "Matrix auth method",
@@ -321,12 +324,31 @@ export const matrixOnboardingAdapter: ChannelOnboardingAdapter = {
             },
           }),
         ).trim();
-        password = String(
-          await prompter.text({
-            message: "Matrix password",
-            validate: (value) => (value?.trim() ? undefined : "Required"),
-          }),
-        ).trim();
+        const passwordPromptState = buildSingleChannelSecretPromptState({
+          accountConfigured: Boolean(existingPasswordConfigured),
+          hasConfigToken: existingPasswordConfigured,
+          allowEnv: true,
+          envValue: envPassword,
+        });
+        const passwordResult = await promptSingleChannelSecretInput({
+          cfg: next,
+          prompter,
+          providerHint: "matrix",
+          credentialLabel: "password",
+          accountConfigured: passwordPromptState.accountConfigured,
+          canUseEnv: passwordPromptState.canUseEnv,
+          hasConfigToken: passwordPromptState.hasConfigToken,
+          envPrompt: "MATRIX_PASSWORD detected. Use env var?",
+          keepPrompt: "Matrix password already configured. Keep it?",
+          inputPrompt: "Matrix password",
+          preferredEnvVar: "MATRIX_PASSWORD",
+        });
+        if (passwordResult.action === "set") {
+          password = passwordResult.value;
+        }
+        if (passwordResult.action === "use-env") {
+          password = undefined;
+        }
       }
     }
 
@@ -353,7 +375,7 @@ export const matrixOnboardingAdapter: ChannelOnboardingAdapter = {
           homeserver,
           userId: userId || undefined,
           accessToken: accessToken || undefined,
-          password: password || undefined,
+          password: password,
           deviceName: deviceName || undefined,
           encryption: enableEncryption || undefined,
         },
@@ -408,18 +430,12 @@ export const matrixOnboardingAdapter: ChannelOnboardingAdapter = {
               }
             }
             roomKeys = [...resolvedIds, ...unresolved.map((entry) => entry.trim()).filter(Boolean)];
-            if (resolvedIds.length > 0 || unresolved.length > 0) {
-              await prompter.note(
-                [
-                  resolvedIds.length > 0 ? `Resolved: ${resolvedIds.join(", ")}` : undefined,
-                  unresolved.length > 0
-                    ? `Unresolved (kept as typed): ${unresolved.join(", ")}`
-                    : undefined,
-                ]
-                  .filter(Boolean)
-                  .join("\n"),
-                "Matrix rooms",
-              );
+            const resolution = formatResolvedUnresolvedNote({
+              resolved: resolvedIds,
+              unresolved,
+            });
+            if (resolution) {
+              await prompter.note(resolution, "Matrix rooms");
             }
           } catch (err) {
             await prompter.note(

package/src/outbound.test.ts

@@ -0,0 +1,159 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk/matrix";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  sendMessageMatrix: vi.fn(),
+  sendPollMatrix: vi.fn(),
+}));
+
+vi.mock("./matrix/send.js", () => ({
+  sendMessageMatrix: mocks.sendMessageMatrix,
+  sendPollMatrix: mocks.sendPollMatrix,
+}));
+
+vi.mock("./runtime.js", () => ({
+  getMatrixRuntime: () => ({
+    channel: {
+      text: {
+        chunkMarkdownText: (text: string) => [text],
+      },
+    },
+  }),
+}));
+
+import { matrixOutbound } from "./outbound.js";
+
+describe("matrixOutbound cfg threading", () => {
+  beforeEach(() => {
+    mocks.sendMessageMatrix.mockReset();
+    mocks.sendPollMatrix.mockReset();
+    mocks.sendMessageMatrix.mockResolvedValue({ messageId: "evt-1", roomId: "!room:example" });
+    mocks.sendPollMatrix.mockResolvedValue({ eventId: "$poll", roomId: "!room:example" });
+  });
+
+  it("passes resolved cfg to sendMessageMatrix for text sends", async () => {
+    const cfg = {
+      channels: {
+        matrix: {
+          accessToken: "resolved-token",
+        },
+      },
+    } as OpenClawConfig;
+
+    await matrixOutbound.sendText!({
+      cfg,
+      to: "room:!room:example",
+      text: "hello",
+      accountId: "default",
+      threadId: "$thread",
+      replyToId: "$reply",
+    });
+
+    expect(mocks.sendMessageMatrix).toHaveBeenCalledWith(
+      "room:!room:example",
+      "hello",
+      expect.objectContaining({
+        cfg,
+        accountId: "default",
+        threadId: "$thread",
+        replyToId: "$reply",
+      }),
+    );
+  });
+
+  it("passes resolved cfg to sendMessageMatrix for media sends", async () => {
+    const cfg = {
+      channels: {
+        matrix: {
+          accessToken: "resolved-token",
+        },
+      },
+    } as OpenClawConfig;
+
+    await matrixOutbound.sendMedia!({
+      cfg,
+      to: "room:!room:example",
+      text: "caption",
+      mediaUrl: "file:///tmp/cat.png",
+      accountId: "default",
+    });
+
+    expect(mocks.sendMessageMatrix).toHaveBeenCalledWith(
+      "room:!room:example",
+      "caption",
+      expect.objectContaining({
+        cfg,
+        mediaUrl: "file:///tmp/cat.png",
+      }),
+    );
+  });
+
+  it("passes resolved cfg through injected deps.sendMatrix", async () => {
+    const cfg = {
+      channels: {
+        matrix: {
+          accessToken: "resolved-token",
+        },
+      },
+    } as OpenClawConfig;
+    const sendMatrix = vi.fn(async () => ({
+      messageId: "evt-injected",
+      roomId: "!room:example",
+    }));
+
+    await matrixOutbound.sendText!({
+      cfg,
+      to: "room:!room:example",
+      text: "hello via deps",
+      deps: { sendMatrix },
+      accountId: "default",
+      threadId: "$thread",
+      replyToId: "$reply",
+    });
+
+    expect(sendMatrix).toHaveBeenCalledWith(
+      "room:!room:example",
+      "hello via deps",
+      expect.objectContaining({
+        cfg,
+        accountId: "default",
+        threadId: "$thread",
+        replyToId: "$reply",
+      }),
+    );
+  });
+
+  it("passes resolved cfg to sendPollMatrix", async () => {
+    const cfg = {
+      channels: {
+        matrix: {
+          accessToken: "resolved-token",
+        },
+      },
+    } as OpenClawConfig;
+
+    await matrixOutbound.sendPoll!({
+      cfg,
+      to: "room:!room:example",
+      poll: {
+        question: "Snack?",
+        options: ["Pizza", "Sushi"],
+      },
+      accountId: "default",
+      threadId: "$thread",
+    });
+
+    expect(mocks.sendPollMatrix).toHaveBeenCalledWith(
+      "room:!room:example",
+      expect.objectContaining({
+        question: "Snack?",
+        options: ["Pizza", "Sushi"],
+      }),
+      expect.objectContaining({
+        cfg,
+        accountId: "default",
+        threadId: "$thread",
+      }),
+    );
+  });
+});

package/src/outbound.ts

@@ -1,4 +1,4 @@
-import type { ChannelOutboundAdapter } from "openclaw/plugin-sdk";
+import type { ChannelOutboundAdapter } from "openclaw/plugin-sdk/matrix";
 import { sendMessageMatrix, sendPollMatrix } from "./matrix/send.js";
 import { getMatrixRuntime } from "./runtime.js";
 
@@ -7,11 +7,12 @@ export const matrixOutbound: ChannelOutboundAdapter = {
   chunker: (text, limit) => getMatrixRuntime().channel.text.chunkMarkdownText(text, limit),
   chunkerMode: "markdown",
   textChunkLimit: 4000,
-  sendText: async ({ to, text, deps, replyToId, threadId, accountId }) => {
+  sendText: async ({ cfg, to, text, deps, replyToId, threadId, accountId }) => {
     const send = deps?.sendMatrix ?? sendMessageMatrix;
     const resolvedThreadId =
       threadId !== undefined && threadId !== null ? String(threadId) : undefined;
     const result = await send(to, text, {
+      cfg,
       replyToId: replyToId ?? undefined,
       threadId: resolvedThreadId,
       accountId: accountId ?? undefined,
@@ -22,11 +23,12 @@ export const matrixOutbound: ChannelOutboundAdapter = {
       roomId: result.roomId,
     };
   },
-  sendMedia: async ({ to, text, mediaUrl, deps, replyToId, threadId, accountId }) => {
+  sendMedia: async ({ cfg, to, text, mediaUrl, deps, replyToId, threadId, accountId }) => {
     const send = deps?.sendMatrix ?? sendMessageMatrix;
     const resolvedThreadId =
       threadId !== undefined && threadId !== null ? String(threadId) : undefined;
     const result = await send(to, text, {
+      cfg,
       mediaUrl,
       replyToId: replyToId ?? undefined,
       threadId: resolvedThreadId,
@@ -38,10 +40,11 @@ export const matrixOutbound: ChannelOutboundAdapter = {
       roomId: result.roomId,
     };
   },
-  sendPoll: async ({ to, poll, threadId, accountId }) => {
+  sendPoll: async ({ cfg, to, poll, threadId, accountId }) => {
     const resolvedThreadId =
       threadId !== undefined && threadId !== null ? String(threadId) : undefined;
     const result = await sendPollMatrix(to, poll, {
+      cfg,
       threadId: resolvedThreadId,
       accountId: accountId ?? undefined,
     });

package/src/resolve-targets.test.ts

@@ -1,4 +1,4 @@
-import type { ChannelDirectoryEntry } from "openclaw/plugin-sdk";
+import type { ChannelDirectoryEntry } from "openclaw/plugin-sdk/matrix";
 import { describe, expect, it, vi, beforeEach } from "vitest";
 import { listMatrixDirectoryGroupsLive, listMatrixDirectoryPeersLive } from "./directory-live.js";
 import { resolveMatrixTargets } from "./resolve-targets.js";

package/src/resolve-targets.ts

@@ -1,9 +1,10 @@
+import { mapAllowlistResolutionInputs } from "openclaw/plugin-sdk/compat";
 import type {
   ChannelDirectoryEntry,
   ChannelResolveKind,
   ChannelResolveResult,
   RuntimeEnv,
-} from "openclaw/plugin-sdk";
+} from "openclaw/plugin-sdk/matrix";
 import { listMatrixDirectoryGroupsLive, listMatrixDirectoryPeersLive } from "./directory-live.js";
 
 function findExactDirectoryMatches(
@@ -71,56 +72,54 @@ export async function resolveMatrixTargets(params: {
   kind: ChannelResolveKind;
   runtime?: RuntimeEnv;
 }): Promise<ChannelResolveResult[]> {
-  const results: ChannelResolveResult[] = [];
-  for (const input of params.inputs) {
-    const trimmed = input.trim();
-    if (!trimmed) {
-      results.push({ input, resolved: false, note: "empty input" });
-      continue;
-    }
-    if (params.kind === "user") {
-      if (trimmed.startsWith("@") && trimmed.includes(":")) {
-        results.push({ input, resolved: true, id: trimmed });
-        continue;
+  return await mapAllowlistResolutionInputs({
+    inputs: params.inputs,
+    mapInput: async (input): Promise<ChannelResolveResult> => {
+      const trimmed = input.trim();
+      if (!trimmed) {
+        return { input, resolved: false, note: "empty input" };
+      }
+      if (params.kind === "user") {
+        if (trimmed.startsWith("@") && trimmed.includes(":")) {
+          return { input, resolved: true, id: trimmed };
+        }
+        try {
+          const matches = await listMatrixDirectoryPeersLive({
+            cfg: params.cfg,
+            query: trimmed,
+            limit: 5,
+          });
+          const best = pickBestUserMatch(matches, trimmed);
+          return {
+            input,
+            resolved: Boolean(best?.id),
+            id: best?.id,
+            name: best?.name,
+            note: best ? undefined : describeUserMatchFailure(matches, trimmed),
+          };
+        } catch (err) {
+          params.runtime?.error?.(`matrix resolve failed: ${String(err)}`);
+          return { input, resolved: false, note: "lookup failed" };
+        }
       }
       try {
-        const matches = await listMatrixDirectoryPeersLive({
+        const matches = await listMatrixDirectoryGroupsLive({
           cfg: params.cfg,
           query: trimmed,
           limit: 5,
         });
-        const best = pickBestUserMatch(matches, trimmed);
-        results.push({
+        const best = pickBestGroupMatch(matches, trimmed);
+        return {
           input,
           resolved: Boolean(best?.id),
           id: best?.id,
           name: best?.name,
-          note: best ? undefined : describeUserMatchFailure(matches, trimmed),
-        });
+          note: matches.length > 1 ? "multiple matches; chose first" : undefined,
+        };
       } catch (err) {
         params.runtime?.error?.(`matrix resolve failed: ${String(err)}`);
-        results.push({ input, resolved: false, note: "lookup failed" });
+        return { input, resolved: false, note: "lookup failed" };
       }
-      continue;
-    }
-    try {
-      const matches = await listMatrixDirectoryGroupsLive({
-        cfg: params.cfg,
-        query: trimmed,
-        limit: 5,
-      });
-      const best = pickBestGroupMatch(matches, trimmed);
-      results.push({
-        input,
-        resolved: Boolean(best?.id),
-        id: best?.id,
-        name: best?.name,
-        note: matches.length > 1 ? "multiple matches; chose first" : undefined,
-      });
-    } catch (err) {
-      params.runtime?.error?.(`matrix resolve failed: ${String(err)}`);
-      results.push({ input, resolved: false, note: "lookup failed" });
-    }
-  }
-  return results;
+    },
+  });
 }

package/src/runtime.ts

@@ -1,4 +1,4 @@
-import type { PluginRuntime } from "openclaw/plugin-sdk";
+import type { PluginRuntime } from "openclaw/plugin-sdk/matrix";
 
 let runtime: PluginRuntime | null = null;
 

package/src/secret-input.ts

@@ -0,0 +1,13 @@
+import {
+  buildSecretInputSchema,
+  hasConfiguredSecretInput,
+  normalizeResolvedSecretInputString,
+  normalizeSecretInputString,
+} from "openclaw/plugin-sdk/matrix";
+
+export {
+  buildSecretInputSchema,
+  hasConfiguredSecretInput,
+  normalizeResolvedSecretInputString,
+  normalizeSecretInputString,
+};

package/src/tool-actions.ts

@@ -5,7 +5,7 @@ import {
   readNumberParam,
   readReactionParams,
   readStringParam,
-} from "openclaw/plugin-sdk";
+} from "openclaw/plugin-sdk/matrix";
 import {
   deleteMatrixMessage,
   editMatrixMessage,