Parse matrix.to links when banning (#609)

Author: H-Shay

src/commands/UnbanBanCommand.ts

@@ -16,7 +16,14 @@ limitations under the License.
 
 import { Mjolnir } from "../Mjolnir";
 import PolicyList from "../models/PolicyList";
-import { extractRequestError, LogLevel, LogService, MatrixGlob, RichReply } from "@vector-im/matrix-bot-sdk";
+import {
+    extractRequestError,
+    LogLevel,
+    LogService,
+    MatrixGlob,
+    RichReply,
+    Permalinks,
+} from "@vector-im/matrix-bot-sdk";
 import { RULE_ROOM, RULE_SERVER, RULE_USER, USER_RULE_TYPES } from "../models/ListRule";
 import { DEFAULT_LIST_EVENT_TYPE } from "./SetDefaultBanListCommand";
 
@@ -51,7 +58,7 @@ export async function parseArguments(
     let list: PolicyList | null = null;
     let force = false;
     while (argumentIndex < 7 && argumentIndex < parts.length) {
-        const arg = parts[argumentIndex++];
+        let arg = parts[argumentIndex++];
         if (!arg) break;
         if (["user", "room", "server"].includes(arg.toLowerCase())) {
             if (arg.toLowerCase() === "user") ruleType = RULE_USER;
@@ -72,6 +79,22 @@ export async function parseArguments(
             }
         }
 
+        if (arg.startsWith("https://matrix.to/#/")) {
+            // it should be a matrix.to link, parse it
+            try {
+                const permParts = Permalinks.parseUrl(arg);
+                if (permParts.userId) {
+                    entity = permParts.userId;
+                    ruleType = RULE_USER;
+                } else if (permParts.roomIdOrAlias) {
+                    entity = permParts.roomIdOrAlias;
+                    ruleType = RULE_ROOM;
+                }
+            } catch (e) {
+                // okay it's not a matrix.to link, run it through the rest of the parser
+            }
+        }
+
         if (entity) break;
     }
 

test/commands/UnbanBanCommandTest.ts

@@ -307,6 +307,51 @@ describe("UnbanBanCommand", () => {
             expect(bits!.list!.listShortcode).toBe("test");
         });
 
+        it("should be able to parse matrix.to links", async () => {
+            const mjolnir = createTestMjolnir();
+            (<any>mjolnir).policyListManager.lists = [{ listShortcode: "test" }];
+            mjolnir.client.sendMessage = (roomId: string, content: any): Promise<string> => {
+                throw new Error("sendMessage should not have been called: " + JSON.stringify(content));
+            };
+
+            const userCommand = "!mjolnir ban test https://matrix.to/#/@bad_user:test.org";
+            const userBits = await parseArguments("!a", createFakeEvent(userCommand), mjolnir, userCommand.split(" "));
+            expect(userBits!.ruleType).toBe(RULE_USER);
+            expect(userBits!.entity).toBe("@bad_user:test.org");
+            expect(userBits!.list).toBeDefined();
+            expect(userBits!.list!.listShortcode).toBe("test");
+            expect(userBits).toBeTruthy();
+            expect(userBits!.reason).toBeFalsy();
+
+            const roomCommand = "!mjolnir ban test https://matrix.to/#/!bummerRoom:test.org";
+            const commandBits = await parseArguments(
+                "!a",
+                createFakeEvent(roomCommand),
+                mjolnir,
+                roomCommand.split(" "),
+            );
+            expect(commandBits!.ruleType).toBe(RULE_ROOM);
+            expect(commandBits!.entity).toBe("!bummerRoom:test.org");
+            expect(commandBits!.list).toBeDefined();
+            expect(commandBits!.list!.listShortcode).toBe("test");
+            expect(commandBits).toBeTruthy();
+            expect(commandBits!.reason).toBeFalsy();
+
+            const aliasCommand = "!mjolnir ban test https://matrix.to/#/#bad-actors:test.org";
+            const aliasBits = await parseArguments(
+                "!a",
+                createFakeEvent(aliasCommand),
+                mjolnir,
+                aliasCommand.split(" "),
+            );
+            expect(aliasBits!.ruleType).toBe(RULE_ROOM);
+            expect(aliasBits!.entity).toBe("#bad-actors:test.org");
+            expect(aliasBits!.list).toBeDefined();
+            expect(aliasBits!.list!.listShortcode).toBe("test");
+            expect(aliasBits).toBeTruthy();
+            expect(aliasBits!.reason).toBeFalsy();
+        });
+
         it("should error if wildcards used without --force", async () => {
             const mjolnir = createTestMjolnir();
             (<any>mjolnir).policyListManager.lists = [{ listShortcode: "test" }];