@openclaw/synology-chat 2026.2.22 → 2026.5.1-beta.1

package/src/channel.test.ts

@@ -1,55 +1,56 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-// Mock external dependencies
-vi.mock("openclaw/plugin-sdk", () => ({
-  DEFAULT_ACCOUNT_ID: "default",
-  setAccountEnabledInConfigSection: vi.fn((_opts: any) => ({})),
-  registerPluginHttpRoute: vi.fn(() => vi.fn()),
-  buildChannelConfigSchema: vi.fn((schema: any) => ({ schema })),
-}));
+import { createPluginSetupWizardStatus } from "openclaw/plugin-sdk/plugin-test-runtime";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { ResolvedSynologyChatAccount } from "./types.js";
 
-vi.mock("./client.js", () => ({
-  sendMessage: vi.fn().mockResolvedValue(true),
-  sendFileUrl: vi.fn().mockResolvedValue(true),
-}));
+const securityAccountDefaults: ResolvedSynologyChatAccount = {
+  accountId: "default",
+  enabled: true,
+  token: "t",
+  incomingUrl: "https://nas/incoming",
+  nasHost: "h",
+  webhookPath: "/w",
+  webhookPathSource: "default" as const,
+  dangerouslyAllowNameMatching: false,
+  dangerouslyAllowInheritedWebhookPath: false,
+  dmPolicy: "allowlist" as const,
+  allowedUserIds: [],
+  rateLimitPerMinute: 30,
+  botName: "Bot",
+  allowInsecureSsl: false,
+};
 
-vi.mock("./webhook-handler.js", () => ({
-  createWebhookHandler: vi.fn(() => vi.fn()),
-}));
+function makeSecurityAccount(
+  overrides: Partial<ResolvedSynologyChatAccount> = {},
+): ResolvedSynologyChatAccount {
+  return { ...securityAccountDefaults, ...overrides };
+}
 
-vi.mock("./runtime.js", () => ({
-  getSynologyRuntime: vi.fn(() => ({
-    config: { loadConfig: vi.fn().mockResolvedValue({}) },
-    channel: {
-      reply: {
-        dispatchReplyWithBufferedBlockDispatcher: vi.fn().mockResolvedValue({
-          counts: {},
-        }),
-      },
-    },
-  })),
-}));
+const clientModule = await import("./client.js");
+const gatewayRuntimeModule = await import("./gateway-runtime.js");
+const mockSendMessage = vi.spyOn(clientModule, "sendMessage").mockResolvedValue(true);
+const registerSynologyWebhookRouteMock = vi
+  .spyOn(gatewayRuntimeModule, "registerSynologyWebhookRoute")
+  .mockImplementation(() => vi.fn());
 
-vi.mock("zod", () => ({
-  z: {
-    object: vi.fn(() => ({
-      passthrough: vi.fn(() => ({ _type: "zod-schema" })),
-    })),
-  },
+vi.mock("./webhook-handler.js", () => ({
+  createWebhookHandler: vi.fn(() => vi.fn()),
 }));
 
-const { createSynologyChatPlugin } = await import("./channel.js");
+const { createSynologyChatPlugin, synologyChatPlugin } = await import("./channel.js");
+const getSynologyChatSetupStatus = createPluginSetupWizardStatus(synologyChatPlugin);
 
 describe("createSynologyChatPlugin", () => {
-  it("returns a plugin object with all required sections", () => {
-    const plugin = createSynologyChatPlugin();
-    expect(plugin.id).toBe("synology-chat");
-    expect(plugin.meta).toBeDefined();
-    expect(plugin.capabilities).toBeDefined();
-    expect(plugin.config).toBeDefined();
-    expect(plugin.security).toBeDefined();
-    expect(plugin.outbound).toBeDefined();
-    expect(plugin.gateway).toBeDefined();
+  beforeEach(() => {
+    vi.stubEnv("SYNOLOGY_CHAT_TOKEN", "");
+    vi.stubEnv("SYNOLOGY_CHAT_INCOMING_URL", "");
+    mockSendMessage.mockClear();
+    registerSynologyWebhookRouteMock.mockClear();
+    mockSendMessage.mockResolvedValue(true);
+    registerSynologyWebhookRouteMock.mockImplementation(() => vi.fn());
+  });
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
   });
 
   describe("meta", () => {
@@ -71,22 +72,96 @@ describe("createSynologyChatPlugin", () => {
   });
 
   describe("config", () => {
-    it("listAccountIds delegates to accounts module", () => {
+    it("listAccountIds includes default and named accounts when configured", () => {
       const plugin = createSynologyChatPlugin();
-      const result = plugin.config.listAccountIds({});
-      expect(Array.isArray(result)).toBe(true);
+      const result = plugin.config.listAccountIds({
+        channels: {
+          "synology-chat": {
+            token: "base-token",
+            accounts: {
+              office: { token: "office-token" },
+            },
+          },
+        },
+      });
+      expect(result).toEqual(["default", "office"]);
     });
 
-    it("resolveAccount returns account config", () => {
-      const cfg = { channels: { "synology-chat": { token: "t1" } } };
+    it("resolveAccount merges account overrides with base config defaults", () => {
+      const cfg = {
+        channels: {
+          "synology-chat": {
+            token: "base-token",
+            incomingUrl: "https://nas/base",
+            nasHost: "nas-base",
+            allowedUserIds: ["base-user"],
+            rateLimitPerMinute: 45,
+            botName: "Base Bot",
+            accounts: {
+              office: {
+                token: "office-token",
+                allowInsecureSsl: true,
+              },
+            },
+          },
+        },
+      };
       const plugin = createSynologyChatPlugin();
-      const account = plugin.config.resolveAccount(cfg, "default");
-      expect(account.accountId).toBe("default");
+      const account = plugin.config.resolveAccount(cfg, "office");
+      expect(account).toMatchObject({
+        accountId: "office",
+        token: "office-token",
+        incomingUrl: "https://nas/base",
+        nasHost: "nas-base",
+        allowedUserIds: ["base-user"],
+        rateLimitPerMinute: 45,
+        botName: "Base Bot",
+        allowInsecureSsl: true,
+      });
     });
 
     it("defaultAccountId returns 'default'", () => {
       const plugin = createSynologyChatPlugin();
-      expect(plugin.config.defaultAccountId({})).toBe("default");
+      expect(plugin.config.defaultAccountId?.({})).toBe("default");
+    });
+
+    it("setup status honors the selected named account", async () => {
+      const status = await getSynologyChatSetupStatus({
+        cfg: {
+          channels: {
+            "synology-chat": {
+              accounts: {
+                ops: {
+                  token: "ops-token",
+                  incomingUrl: "https://nas/ops",
+                },
+                work: {
+                  token: "work-token",
+                },
+              },
+            },
+          },
+        },
+        accountOverrides: {
+          "synology-chat": "work",
+        },
+      });
+
+      expect(status.configured).toBe(false);
+      expect(status.statusLines).toEqual([
+        "Synology Chat: needs token + incoming webhook",
+        "Accounts: 2",
+      ]);
+    });
+
+    it("formats allowFrom entries through the shared adapter", () => {
+      const plugin = createSynologyChatPlugin();
+      expect(
+        plugin.config.formatAllowFrom?.({
+          cfg: {},
+          allowFrom: ["  USER1  ", 42],
+        }),
+      ).toEqual(["user1", "42"]);
     });
   });
 
@@ -100,6 +175,9 @@ describe("createSynologyChatPlugin", () => {
         incomingUrl: "u",
         nasHost: "h",
         webhookPath: "/w",
+        webhookPathSource: "default" as const,
+        dangerouslyAllowNameMatching: false,
+        dangerouslyAllowInheritedWebhookPath: false,
         dmPolicy: "allowlist" as const,
         allowedUserIds: ["user1"],
         rateLimitPerMinute: 30,
@@ -107,97 +185,158 @@ describe("createSynologyChatPlugin", () => {
         allowInsecureSsl: true,
       };
       const result = plugin.security.resolveDmPolicy({ cfg: {}, account });
+      if (!result) {
+        throw new Error("resolveDmPolicy returned null");
+      }
       expect(result.policy).toBe("allowlist");
       expect(result.allowFrom).toEqual(["user1"]);
-      expect(typeof result.normalizeEntry).toBe("function");
-      expect(result.normalizeEntry("  USER1  ")).toBe("user1");
+      expect(result.normalizeEntry?.("  USER1  ")).toBe("user1");
     });
   });
 
   describe("pairing", () => {
-    it("has notifyApproval and normalizeAllowEntry", () => {
+    it("normalizes entries and notifies approved users", async () => {
       const plugin = createSynologyChatPlugin();
       expect(plugin.pairing.idLabel).toBe("synologyChatUserId");
-      expect(typeof plugin.pairing.normalizeAllowEntry).toBe("function");
-      expect(plugin.pairing.normalizeAllowEntry("  USER1  ")).toBe("user1");
-      expect(typeof plugin.pairing.notifyApproval).toBe("function");
+      const normalize = plugin.pairing.normalizeAllowEntry;
+      const notifyApproval = plugin.pairing.notifyApproval;
+      if (!normalize || !notifyApproval) {
+        throw new Error("synology-chat pairing helpers unavailable");
+      }
+      expect(normalize("  USER1  ")).toBe("user1");
+
+      await notifyApproval({
+        cfg: {
+          channels: {
+            "synology-chat": {
+              token: "t",
+              incomingUrl: "https://nas/incoming",
+              allowInsecureSsl: true,
+            },
+          },
+        },
+        id: "USER1",
+      });
+
+      expect(mockSendMessage).toHaveBeenCalledWith(
+        "https://nas/incoming",
+        "OpenClaw: your access has been approved.",
+        "USER1",
+        true,
+      );
     });
   });
 
   describe("security.collectWarnings", () => {
+    function makeSharedWebhookConfig(alertsOverrides: Record<string, unknown> = {}) {
+      return {
+        channels: {
+          "synology-chat": {
+            token: "base-token",
+            webhookPath: "/webhook/shared",
+            accounts: {
+              alerts: {
+                token: "alerts-token",
+                incomingUrl: "https://nas/alerts",
+                dmPolicy: "allowlist",
+                allowedUserIds: ["123"],
+                ...alertsOverrides,
+              },
+            },
+          },
+        },
+      };
+    }
+
     it("warns when token is missing", () => {
       const plugin = createSynologyChatPlugin();
-      const account = {
-        accountId: "default",
-        enabled: true,
-        token: "",
-        incomingUrl: "https://nas/incoming",
-        nasHost: "h",
-        webhookPath: "/w",
-        dmPolicy: "allowlist" as const,
-        allowedUserIds: [],
-        rateLimitPerMinute: 30,
-        botName: "Bot",
-        allowInsecureSsl: false,
-      };
-      const warnings = plugin.security.collectWarnings({ account });
+      const account = makeSecurityAccount({ token: "" });
+      const warnings = plugin.security.collectWarnings({ cfg: {}, account });
       expect(warnings.some((w: string) => w.includes("token"))).toBe(true);
     });
 
     it("warns when allowInsecureSsl is true", () => {
       const plugin = createSynologyChatPlugin();
-      const account = {
-        accountId: "default",
-        enabled: true,
-        token: "t",
-        incomingUrl: "https://nas/incoming",
-        nasHost: "h",
-        webhookPath: "/w",
-        dmPolicy: "allowlist" as const,
-        allowedUserIds: [],
-        rateLimitPerMinute: 30,
-        botName: "Bot",
-        allowInsecureSsl: true,
-      };
-      const warnings = plugin.security.collectWarnings({ account });
+      const account = makeSecurityAccount({ allowInsecureSsl: true });
+      const warnings = plugin.security.collectWarnings({ cfg: {}, account });
       expect(warnings.some((w: string) => w.includes("SSL"))).toBe(true);
     });
 
+    it("warns when dangerous name matching is enabled", () => {
+      const plugin = createSynologyChatPlugin();
+      const account = makeSecurityAccount({ dangerouslyAllowNameMatching: true });
+      const warnings = plugin.security.collectWarnings({ cfg: {}, account });
+      expect(warnings.some((w: string) => w.includes("dangerouslyAllowNameMatching"))).toBe(true);
+    });
+
+    it("warns when inherited shared webhookPath is dangerously re-enabled", () => {
+      const plugin = createSynologyChatPlugin();
+      const account = makeSecurityAccount({
+        accountId: "alerts",
+        webhookPathSource: "inherited-base",
+        dangerouslyAllowInheritedWebhookPath: true,
+      });
+      const warnings = plugin.security.collectWarnings({ cfg: {}, account });
+      expect(
+        warnings.some((w: string) => w.includes("dangerouslyAllowInheritedWebhookPath=true")),
+      ).toBe(true);
+    });
+
     it("warns when dmPolicy is open", () => {
       const plugin = createSynologyChatPlugin();
-      const account = {
-        accountId: "default",
-        enabled: true,
-        token: "t",
-        incomingUrl: "https://nas/incoming",
-        nasHost: "h",
-        webhookPath: "/w",
-        dmPolicy: "open" as const,
-        allowedUserIds: [],
-        rateLimitPerMinute: 30,
-        botName: "Bot",
-        allowInsecureSsl: false,
-      };
-      const warnings = plugin.security.collectWarnings({ account });
+      const account = makeSecurityAccount({ dmPolicy: "open", allowedUserIds: ["*"] });
+      const warnings = plugin.security.collectWarnings({ cfg: {}, account });
       expect(warnings.some((w: string) => w.includes("open"))).toBe(true);
     });
 
-    it("returns no warnings for fully configured account", () => {
+    it("warns when dmPolicy is open and allowedUserIds is empty", () => {
       const plugin = createSynologyChatPlugin();
-      const account = {
-        accountId: "default",
-        enabled: true,
-        token: "t",
-        incomingUrl: "https://nas/incoming",
-        nasHost: "h",
-        webhookPath: "/w",
-        dmPolicy: "allowlist" as const,
-        allowedUserIds: ["user1"],
-        rateLimitPerMinute: 30,
-        botName: "Bot",
-        allowInsecureSsl: false,
+      const account = makeSecurityAccount({ dmPolicy: "open", allowedUserIds: [] });
+      const warnings = plugin.security.collectWarnings({ cfg: {}, account });
+      expect(warnings.some((w: string) => w.includes("empty allowedUserIds"))).toBe(true);
+    });
+
+    it("warns when dmPolicy is allowlist and allowedUserIds is empty", () => {
+      const plugin = createSynologyChatPlugin();
+      const account = makeSecurityAccount();
+      const warnings = plugin.security.collectWarnings({ cfg: {}, account });
+      expect(warnings.some((w: string) => w.includes("empty allowedUserIds"))).toBe(true);
+    });
+
+    it("warns when named multi-account routes inherit a shared webhookPath", () => {
+      const plugin = createSynologyChatPlugin();
+      const cfg = makeSharedWebhookConfig();
+      const account = plugin.config.resolveAccount(cfg, "alerts");
+      const warnings = plugin.security.collectWarnings({ cfg, account });
+      expect(warnings.some((w: string) => w.includes("must set an explicit webhookPath"))).toBe(
+        true,
+      );
+    });
+
+    it("warns when enabled accounts share the same exact webhookPath", () => {
+      const plugin = createSynologyChatPlugin();
+      const base = makeSharedWebhookConfig({ webhookPath: "/webhook/shared" }).channels[
+        "synology-chat"
+      ];
+      const cfg = {
+        channels: {
+          "synology-chat": {
+            ...base,
+            incomingUrl: "https://nas/default",
+            dmPolicy: "allowlist",
+            allowedUserIds: ["123"],
+          },
+        },
       };
-      const warnings = plugin.security.collectWarnings({ account });
+      const account = plugin.config.resolveAccount(cfg, "alerts");
+      const warnings = plugin.security.collectWarnings({ cfg, account });
+      expect(warnings.some((w: string) => w.includes("conflicts on webhookPath"))).toBe(true);
+    });
+
+    it("returns no warnings for fully configured account", () => {
+      const plugin = createSynologyChatPlugin();
+      const account = makeSecurityAccount({ allowedUserIds: ["user1"] });
+      const warnings = plugin.security.collectWarnings({ cfg: {}, account });
       expect(warnings).toHaveLength(0);
     });
   });
@@ -222,9 +361,10 @@ describe("createSynologyChatPlugin", () => {
   describe("directory", () => {
     it("returns empty stubs", async () => {
       const plugin = createSynologyChatPlugin();
-      expect(await plugin.directory.self()).toBeNull();
-      expect(await plugin.directory.listPeers()).toEqual([]);
-      expect(await plugin.directory.listGroups()).toEqual([]);
+      const params = { cfg: {}, runtime: {} as never };
+      expect(await plugin.directory.self?.(params)).toBeNull();
+      expect(await plugin.directory.listPeers?.(params)).toEqual([]);
+      expect(await plugin.directory.listGroups?.(params)).toEqual([]);
     });
   });
 
@@ -232,9 +372,9 @@ describe("createSynologyChatPlugin", () => {
     it("returns formatting hints", () => {
       const plugin = createSynologyChatPlugin();
       const hints = plugin.agentPrompt.messageToolHints();
-      expect(Array.isArray(hints)).toBe(true);
-      expect(hints.length).toBeGreaterThan(5);
-      expect(hints.some((h: string) => h.includes("<URL|display text>"))).toBe(true);
+      expect(hints).toContain("### Synology Chat Formatting");
+      expect(hints).toContain("**Links**: Use `<URL|display text>` to create clickable links.");
+      expect(hints).toContain("- No buttons, cards, or interactive elements");
     });
   });
 
@@ -243,18 +383,10 @@ describe("createSynologyChatPlugin", () => {
       const plugin = createSynologyChatPlugin();
       await expect(
         plugin.outbound.sendText({
-          account: {
-            accountId: "default",
-            enabled: true,
-            token: "t",
-            incomingUrl: "",
-            nasHost: "h",
-            webhookPath: "/w",
-            dmPolicy: "open",
-            allowedUserIds: [],
-            rateLimitPerMinute: 30,
-            botName: "Bot",
-            allowInsecureSsl: true,
+          cfg: {
+            channels: {
+              "synology-chat": { enabled: true, token: "t", incomingUrl: "" },
+            },
           },
           text: "hello",
           to: "user1",
@@ -265,43 +397,34 @@ describe("createSynologyChatPlugin", () => {
     it("sendText returns OutboundDeliveryResult on success", async () => {
       const plugin = createSynologyChatPlugin();
       const result = await plugin.outbound.sendText({
-        account: {
-          accountId: "default",
-          enabled: true,
-          token: "t",
-          incomingUrl: "https://nas/incoming",
-          nasHost: "h",
-          webhookPath: "/w",
-          dmPolicy: "open",
-          allowedUserIds: [],
-          rateLimitPerMinute: 30,
-          botName: "Bot",
-          allowInsecureSsl: true,
+        cfg: {
+          channels: {
+            "synology-chat": {
+              enabled: true,
+              token: "t",
+              incomingUrl: "https://nas/incoming",
+              allowInsecureSsl: true,
+            },
+          },
         },
         text: "hello",
         to: "user1",
       });
-      expect(result.channel).toBe("synology-chat");
-      expect(result.messageId).toBeDefined();
-      expect(result.chatId).toBe("user1");
+      expect(result).toMatchObject({
+        channel: "synology-chat",
+        chatId: "user1",
+      });
+      expect(result.messageId).toMatch(/^sc-\d+$/);
     });
 
     it("sendMedia throws when missing incomingUrl", async () => {
       const plugin = createSynologyChatPlugin();
       await expect(
         plugin.outbound.sendMedia({
-          account: {
-            accountId: "default",
-            enabled: true,
-            token: "t",
-            incomingUrl: "",
-            nasHost: "h",
-            webhookPath: "/w",
-            dmPolicy: "open",
-            allowedUserIds: [],
-            rateLimitPerMinute: 30,
-            botName: "Bot",
-            allowInsecureSsl: true,
+          cfg: {
+            channels: {
+              "synology-chat": { enabled: true, token: "t", incomingUrl: "" },
+            },
           },
           mediaUrl: "https://example.com/img.png",
           to: "user1",
@@ -311,30 +434,200 @@ describe("createSynologyChatPlugin", () => {
   });
 
   describe("gateway", () => {
-    it("startAccount returns stop function for disabled account", async () => {
-      const plugin = createSynologyChatPlugin();
-      const ctx = {
-        cfg: {
-          channels: { "synology-chat": { enabled: false } },
+    function makeStartAccountCtx(
+      accountConfig: Record<string, unknown>,
+      abortController = new AbortController(),
+    ) {
+      return {
+        abortController,
+        ctx: {
+          cfg: {
+            channels: { "synology-chat": accountConfig },
+          },
+          accountId: "default",
+          log: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+          abortSignal: abortController.signal,
+        },
+      };
+    }
+
+    function makeNamedStartAccountCtx(
+      accountOverrides: Record<string, unknown>,
+      abortController = new AbortController(),
+    ) {
+      return {
+        abortController,
+        ctx: {
+          cfg: {
+            channels: {
+              "synology-chat": {
+                enabled: true,
+                token: "default-token",
+                incomingUrl: "https://nas/default",
+                webhookPath: "/webhook/synology-shared",
+                dmPolicy: "allowlist",
+                allowedUserIds: ["123"],
+                accounts: {
+                  alerts: {
+                    enabled: true,
+                    token: "alerts-token",
+                    incomingUrl: "https://nas/alerts",
+                    ...accountOverrides,
+                  },
+                },
+              },
+            },
+          },
+          accountId: "alerts",
+          log: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+          abortSignal: abortController.signal,
         },
-        accountId: "default",
-        log: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
       };
-      const result = await plugin.gateway.startAccount(ctx);
-      expect(typeof result.stop).toBe("function");
+    }
+
+    async function expectPendingStartAccountPromise(
+      result: Promise<unknown>,
+      abortController: AbortController,
+    ) {
+      expect(result).toBeInstanceOf(Promise);
+      let settled = false;
+      void result.then(
+        () => {
+          settled = true;
+        },
+        () => {
+          settled = true;
+        },
+      );
+      await Promise.resolve();
+      expect(settled).toBe(false);
+      abortController.abort();
+      await result;
+    }
+
+    async function expectPendingStartAccount(accountConfig: Record<string, unknown>) {
+      const plugin = createSynologyChatPlugin();
+      const { ctx, abortController } = makeStartAccountCtx(accountConfig);
+      const result = plugin.gateway.startAccount(ctx);
+      await expectPendingStartAccountPromise(result, abortController);
+    }
+
+    it("startAccount returns pending promise for disabled account", async () => {
+      await expectPendingStartAccount({ enabled: false });
+    });
+
+    it("startAccount returns pending promise for account without token", async () => {
+      await expectPendingStartAccount({ enabled: true });
     });
 
-    it("startAccount returns stop function for account without token", async () => {
+    it("startAccount refuses allowlist accounts with empty allowedUserIds", async () => {
+      const registerMock = registerSynologyWebhookRouteMock;
+      registerMock.mockClear();
       const plugin = createSynologyChatPlugin();
-      const ctx = {
+      const { ctx, abortController } = makeStartAccountCtx({
+        enabled: true,
+        token: "t",
+        incomingUrl: "https://nas/incoming",
+        dmPolicy: "allowlist",
+        allowedUserIds: [],
+      });
+
+      const result = plugin.gateway.startAccount(ctx);
+      await expectPendingStartAccountPromise(result, abortController);
+      expect(ctx.log.warn).toHaveBeenCalledWith(expect.stringContaining("empty allowedUserIds"));
+      expect(registerMock).not.toHaveBeenCalled();
+    });
+
+    it("startAccount refuses open accounts with empty allowedUserIds", async () => {
+      const registerMock = registerSynologyWebhookRouteMock;
+      registerMock.mockClear();
+      const plugin = createSynologyChatPlugin();
+      const { ctx, abortController } = makeStartAccountCtx({
+        enabled: true,
+        token: "t",
+        incomingUrl: "https://nas/incoming",
+        dmPolicy: "open",
+        allowedUserIds: [],
+      });
+
+      const result = plugin.gateway.startAccount(ctx);
+      await expectPendingStartAccountPromise(result, abortController);
+      expect(ctx.log.warn).toHaveBeenCalledWith(
+        expect.stringContaining("dmPolicy=open but empty allowedUserIds"),
+      );
+      expect(registerMock).not.toHaveBeenCalled();
+    });
+
+    it("startAccount refuses named accounts without explicit webhookPath in multi-account setups", async () => {
+      const registerMock = registerSynologyWebhookRouteMock;
+      const plugin = createSynologyChatPlugin();
+      const { ctx, abortController } = makeNamedStartAccountCtx({
+        dmPolicy: "allowlist",
+        allowedUserIds: ["123"],
+      });
+
+      const result = plugin.gateway.startAccount(ctx);
+      await expectPendingStartAccountPromise(result, abortController);
+      expect(ctx.log.warn).toHaveBeenCalledWith(
+        expect.stringContaining("must set an explicit webhookPath"),
+      );
+      expect(registerMock).not.toHaveBeenCalled();
+    });
+
+    it("startAccount refuses duplicate exact webhook paths across accounts", async () => {
+      const registerMock = registerSynologyWebhookRouteMock;
+      const plugin = createSynologyChatPlugin();
+      const { ctx, abortController } = makeNamedStartAccountCtx({
+        webhookPath: "/webhook/synology-shared",
+        dmPolicy: "open",
+        allowedUserIds: ["*"],
+      });
+
+      const result = plugin.gateway.startAccount(ctx);
+      await expectPendingStartAccountPromise(result, abortController);
+      expect(ctx.log.warn).toHaveBeenCalledWith(
+        expect.stringContaining("conflicts on webhookPath"),
+      );
+      expect(registerMock).not.toHaveBeenCalled();
+    });
+
+    it("re-registers same account/path through the route registrar", async () => {
+      const unregisterFirst = vi.fn();
+      const unregisterSecond = vi.fn();
+      const registerMock = registerSynologyWebhookRouteMock;
+      registerMock.mockReturnValueOnce(unregisterFirst).mockReturnValueOnce(unregisterSecond);
+
+      const plugin = createSynologyChatPlugin();
+      const abortFirst = new AbortController();
+      const abortSecond = new AbortController();
+      const makeCtx = (abortCtrl: AbortController) => ({
         cfg: {
-          channels: { "synology-chat": { enabled: true } },
+          channels: {
+            "synology-chat": {
+              enabled: true,
+              token: "t",
+              incomingUrl: "https://nas/incoming",
+              webhookPath: "/webhook/synology",
+              dmPolicy: "allowlist",
+              allowedUserIds: ["123"],
+            },
+          },
         },
         accountId: "default",
         log: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
-      };
-      const result = await plugin.gateway.startAccount(ctx);
-      expect(typeof result.stop).toBe("function");
+        abortSignal: abortCtrl.signal,
+      });
+
+      const firstPromise = plugin.gateway.startAccount(makeCtx(abortFirst));
+      const secondPromise = plugin.gateway.startAccount(makeCtx(abortSecond));
+
+      expect(registerMock).toHaveBeenCalledTimes(2);
+      expect(unregisterFirst).not.toHaveBeenCalled();
+      expect(unregisterSecond).not.toHaveBeenCalled();
+
+      abortFirst.abort();
+      abortSecond.abort();
+      await Promise.allSettled([firstPromise, secondPromise]);
     });
   });
 });