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

package/src/inbound-turn.ts

@@ -0,0 +1,171 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
+import { sendMessage } from "./client.js";
+import type { SynologyInboundMessage } from "./inbound-context.js";
+import { getSynologyRuntime } from "./runtime.js";
+import { buildSynologyChatInboundSessionKey } from "./session-key.js";
+import type { ResolvedSynologyChatAccount } from "./types.js";
+
+const CHANNEL_ID = "synology-chat";
+
+type SynologyChannelLog = {
+  info?: (...args: unknown[]) => void;
+};
+
+function resolveSynologyChatInboundRoute(params: {
+  cfg: OpenClawConfig;
+  account: ResolvedSynologyChatAccount;
+  userId: string;
+}) {
+  const rt = getSynologyRuntime();
+  const route = rt.channel.routing.resolveAgentRoute({
+    cfg: params.cfg,
+    channel: CHANNEL_ID,
+    accountId: params.account.accountId,
+    peer: {
+      kind: "direct",
+      id: params.userId,
+    },
+  });
+  return {
+    rt,
+    route,
+    sessionKey: buildSynologyChatInboundSessionKey({
+      agentId: route.agentId,
+      accountId: params.account.accountId,
+      userId: params.userId,
+      identityLinks: params.cfg.session?.identityLinks,
+    }),
+  };
+}
+
+async function deliverSynologyChatReply(params: {
+  account: ResolvedSynologyChatAccount;
+  sendUserId: string;
+  payload: { text?: string; body?: string };
+}): Promise<void> {
+  const text = params.payload.text ?? params.payload.body;
+  if (!text) {
+    return;
+  }
+  await sendMessage(
+    params.account.incomingUrl,
+    text,
+    params.sendUserId,
+    params.account.allowInsecureSsl,
+  );
+}
+
+export async function dispatchSynologyChatInboundTurn(params: {
+  account: ResolvedSynologyChatAccount;
+  msg: SynologyInboundMessage;
+  log?: SynologyChannelLog;
+}): Promise<null> {
+  const rt = getSynologyRuntime();
+  const currentCfg = rt.config.current() as OpenClawConfig;
+
+  // The Chat API user_id (for sending) may differ from the webhook
+  // user_id (used for sessions/pairing). Use chatUserId for API calls.
+  const sendUserId = params.msg.chatUserId ?? params.msg.from;
+  const resolved = resolveSynologyChatInboundRoute({
+    cfg: currentCfg,
+    account: params.account,
+    userId: params.msg.from,
+  });
+
+  await resolved.rt.channel.turn.run({
+    channel: CHANNEL_ID,
+    accountId: params.account.accountId,
+    raw: params.msg,
+    adapter: {
+      ingest: (msg) => ({
+        id: `${params.account.accountId}:${msg.from}`,
+        timestamp: Date.now(),
+        rawText: msg.body,
+        textForAgent: msg.body,
+        textForCommands: msg.body,
+        raw: msg,
+      }),
+      resolveTurn: (input) => {
+        const chatKind =
+          params.msg.chatType === "group" || params.msg.chatType === "channel"
+            ? params.msg.chatType
+            : "direct";
+        const msgCtx = resolved.rt.channel.turn.buildContext({
+          channel: CHANNEL_ID,
+          accountId: params.account.accountId,
+          timestamp: input.timestamp,
+          from: `synology-chat:${params.msg.from}`,
+          sender: {
+            id: params.msg.from,
+            name: params.msg.senderName,
+          },
+          conversation: {
+            kind: chatKind,
+            id: params.msg.from,
+            label: params.msg.senderName || params.msg.from,
+            routePeer: {
+              kind: "direct",
+              id: params.msg.from,
+            },
+          },
+          route: {
+            agentId: resolved.route.agentId,
+            accountId: params.account.accountId,
+            routeSessionKey: resolved.sessionKey,
+            dispatchSessionKey: resolved.sessionKey,
+          },
+          reply: {
+            to: `synology-chat:${params.msg.from}`,
+            originatingTo: `synology-chat:${params.msg.from}`,
+          },
+          message: {
+            rawBody: input.rawText,
+            commandBody: input.textForCommands,
+            bodyForAgent: input.textForAgent,
+            envelopeFrom: params.msg.senderName,
+          },
+          extra: {
+            ChatType: params.msg.chatType,
+            CommandAuthorized: params.msg.commandAuthorized,
+          },
+        });
+        const storePath = resolved.rt.channel.session.resolveStorePath(currentCfg.session?.store, {
+          agentId: resolved.route.agentId,
+        });
+        return {
+          cfg: currentCfg,
+          channel: CHANNEL_ID,
+          accountId: params.account.accountId,
+          agentId: resolved.route.agentId,
+          routeSessionKey: resolved.route.sessionKey,
+          storePath,
+          ctxPayload: msgCtx,
+          recordInboundSession: resolved.rt.channel.session.recordInboundSession,
+          dispatchReplyWithBufferedBlockDispatcher:
+            resolved.rt.channel.reply.dispatchReplyWithBufferedBlockDispatcher,
+          delivery: {
+            deliver: async (payload) => {
+              await deliverSynologyChatReply({
+                account: params.account,
+                sendUserId,
+                payload,
+              });
+            },
+          },
+          dispatcherOptions: {
+            onReplyStart: () => {
+              params.log?.info?.(`Agent reply started for ${params.msg.from}`);
+            },
+          },
+          record: {
+            onRecordError: (err) => {
+              params.log?.info?.(`Session metadata update failed for ${params.msg.from}`, err);
+            },
+          },
+        };
+      },
+    },
+  });
+
+  return null;
+}

package/src/runtime.ts

@@ -1,20 +1,8 @@
-/**
- * Plugin runtime singleton.
- * Stores the PluginRuntime from api.runtime (set during register()).
- * Used by channel.ts to access dispatch functions.
- */
-
-import type { PluginRuntime } from "openclaw/plugin-sdk";
-
-let runtime: PluginRuntime | null = null;
-
-export function setSynologyRuntime(r: PluginRuntime): void {
-  runtime = r;
-}
-
-export function getSynologyRuntime(): PluginRuntime {
-  if (!runtime) {
-    throw new Error("Synology Chat runtime not initialized - plugin not registered");
-  }
-  return runtime;
-}
+import { createPluginRuntimeStore, type PluginRuntime } from "openclaw/plugin-sdk/runtime-store";
+
+const { setRuntime: setSynologyRuntime, getRuntime: getSynologyRuntime } =
+  createPluginRuntimeStore<PluginRuntime>({
+    pluginId: "synology-chat",
+    errorMessage: "Synology Chat runtime not initialized - plugin not registered",
+  });
+export { getSynologyRuntime, setSynologyRuntime };

package/src/security-audit.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it } from "vitest";
+import { collectSynologyChatSecurityAuditFindings } from "./security-audit.js";
+import type { ResolvedSynologyChatAccount } from "./types.js";
+
+function createAccount(params: {
+  accountId: string;
+  dangerouslyAllowNameMatching?: boolean;
+}): ResolvedSynologyChatAccount {
+  return {
+    accountId: params.accountId,
+    enabled: true,
+    token: "t",
+    incomingUrl: "https://nas.example.com/incoming",
+    nasHost: "https://nas.example.com",
+    webhookPath: "/webapi/entry.cgi",
+    webhookPathSource: "explicit",
+    dangerouslyAllowNameMatching: params.dangerouslyAllowNameMatching ?? false,
+    dangerouslyAllowInheritedWebhookPath: false,
+    dmPolicy: "allowlist",
+    allowedUserIds: [],
+    rateLimitPerMinute: 30,
+    botName: "OpenClaw",
+    allowInsecureSsl: false,
+  };
+}
+
+describe("Synology Chat security audit findings", () => {
+  it.each([
+    {
+      name: "audits base dangerous name matching",
+      accountId: "default",
+      orderedAccountIds: [] as string[],
+      hasExplicitAccountPath: false,
+      expectedMatch: {
+        checkId: "channels.synology-chat.reply.dangerous_name_matching_enabled",
+        severity: "info",
+        title: "Synology Chat dangerous name matching is enabled",
+      },
+    },
+    {
+      name: "audits non-default accounts for dangerous name matching",
+      accountId: "beta",
+      orderedAccountIds: ["alpha", "beta"],
+      hasExplicitAccountPath: true,
+      expectedMatch: {
+        checkId: "channels.synology-chat.reply.dangerous_name_matching_enabled",
+        severity: "info",
+        title: expect.stringContaining("(account: beta)"),
+      },
+    },
+  ])("$name", (testCase) => {
+    const findings = collectSynologyChatSecurityAuditFindings({
+      account: createAccount({
+        accountId: testCase.accountId,
+        dangerouslyAllowNameMatching: true,
+      }),
+      accountId: testCase.accountId,
+      orderedAccountIds: testCase.orderedAccountIds,
+      hasExplicitAccountPath: testCase.hasExplicitAccountPath,
+    });
+
+    expect(findings).toEqual(
+      expect.arrayContaining([expect.objectContaining(testCase.expectedMatch)]),
+    );
+  });
+});

package/src/security-audit.ts

@@ -0,0 +1,28 @@
+import type { ResolvedSynologyChatAccount } from "./types.js";
+
+export function collectSynologyChatSecurityAuditFindings(params: {
+  accountId?: string | null;
+  account: ResolvedSynologyChatAccount;
+  orderedAccountIds: string[];
+  hasExplicitAccountPath: boolean;
+}) {
+  if (!params.account.dangerouslyAllowNameMatching) {
+    return [];
+  }
+  const accountId = params.accountId?.trim() || params.account.accountId || "default";
+  const accountNote =
+    params.orderedAccountIds.length > 1 || params.hasExplicitAccountPath
+      ? ` (account: ${accountId})`
+      : "";
+  return [
+    {
+      checkId: "channels.synology-chat.reply.dangerous_name_matching_enabled",
+      severity: "info" as const,
+      title: `Synology Chat dangerous name matching is enabled${accountNote}`,
+      detail:
+        "dangerouslyAllowNameMatching=true re-enables mutable username/nickname matching for reply delivery. This is a break-glass compatibility mode, not a hardened default.",
+      remediation:
+        "Prefer stable numeric Synology Chat user IDs for reply delivery, then disable dangerouslyAllowNameMatching.",
+    },
+  ];
+}

package/src/security.ts

@@ -2,33 +2,67 @@
  * Security module: token validation, rate limiting, input sanitization, user allowlist.
  */
 
-import * as crypto from "node:crypto";
+import { safeEqualSecret } from "openclaw/plugin-sdk/security-runtime";
+import {
+  createFixedWindowRateLimiter,
+  type FixedWindowRateLimiter,
+} from "openclaw/plugin-sdk/webhook-ingress";
+
+type DmAuthorizationResult =
+  | { allowed: true }
+  | { allowed: false; reason: "disabled" | "allowlist-empty" | "not-allowlisted" };
 
 /**
  * Validate webhook token using constant-time comparison.
- * Prevents timing attacks that could leak token bytes.
+ * Reject empty tokens explicitly; use shared constant-time comparison otherwise.
  */
 export function validateToken(received: string, expected: string): boolean {
-  if (!received || !expected) return false;
-
-  // Use HMAC to normalize lengths before comparison,
-  // preventing timing side-channel on token length.
-  const key = "openclaw-token-cmp";
-  const a = crypto.createHmac("sha256", key).update(received).digest();
-  const b = crypto.createHmac("sha256", key).update(expected).digest();
-
-  return crypto.timingSafeEqual(a, b);
+  if (!received || !expected) {
+    return false;
+  }
+  return safeEqualSecret(received, expected);
 }
 
 /**
  * Check if a user ID is in the allowed list.
- * Empty allowlist = allow all users.
+ * Allowlist mode must be explicit; empty lists should not match any user.
  */
 export function checkUserAllowed(userId: string, allowedUserIds: string[]): boolean {
-  if (allowedUserIds.length === 0) return true;
+  if (allowedUserIds.length === 0) {
+    return false;
+  }
+  if (allowedUserIds.includes("*")) {
+    return true;
+  }
   return allowedUserIds.includes(userId);
 }
 
+/**
+ * Resolve DM authorization for a sender across all DM policy modes.
+ * Keeps policy semantics in one place so webhook/startup behavior stays consistent.
+ */
+export function authorizeUserForDm(
+  userId: string,
+  dmPolicy: "open" | "allowlist" | "disabled",
+  allowedUserIds: string[],
+): DmAuthorizationResult {
+  if (dmPolicy === "disabled") {
+    return { allowed: false, reason: "disabled" };
+  }
+  if (dmPolicy === "open") {
+    return checkUserAllowed(userId, allowedUserIds)
+      ? { allowed: true }
+      : { allowed: false, reason: "not-allowlisted" };
+  }
+  if (allowedUserIds.length === 0) {
+    return { allowed: false, reason: "allowlist-empty" };
+  }
+  if (!checkUserAllowed(userId, allowedUserIds)) {
+    return { allowed: false, reason: "not-allowlisted" };
+  }
+  return { allowed: true };
+}
+
 /**
  * Sanitize user input to prevent prompt injection attacks.
  * Filters known dangerous patterns and truncates long messages.
@@ -58,55 +92,35 @@ export function sanitizeInput(text: string): string {
  * Sliding window rate limiter per user ID.
  */
 export class RateLimiter {
-  private requests: Map<string, number[]> = new Map();
-  private limit: number;
-  private windowMs: number;
-  private lastCleanup = 0;
-  private cleanupIntervalMs: number;
+  private readonly limiter: FixedWindowRateLimiter;
+  private readonly limit: number;
 
-  constructor(limit = 30, windowSeconds = 60) {
+  constructor(limit = 30, windowSeconds = 60, maxTrackedUsers = 5_000) {
     this.limit = limit;
-    this.windowMs = windowSeconds * 1000;
-    this.cleanupIntervalMs = this.windowMs * 5; // cleanup every 5 windows
+    this.limiter = createFixedWindowRateLimiter({
+      windowMs: Math.max(1, Math.floor(windowSeconds * 1000)),
+      maxRequests: Math.max(1, Math.floor(limit)),
+      maxTrackedKeys: Math.max(1, Math.floor(maxTrackedUsers)),
+    });
   }
 
   /** Returns true if the request is allowed, false if rate-limited. */
   check(userId: string): boolean {
-    const now = Date.now();
-    const windowStart = now - this.windowMs;
-
-    // Periodic cleanup of stale entries to prevent memory leak
-    if (now - this.lastCleanup > this.cleanupIntervalMs) {
-      this.cleanup(windowStart);
-      this.lastCleanup = now;
-    }
-
-    let timestamps = this.requests.get(userId);
-    if (timestamps) {
-      timestamps = timestamps.filter((ts) => ts > windowStart);
-    } else {
-      timestamps = [];
-    }
+    return !this.limiter.isRateLimited(userId);
+  }
 
-    if (timestamps.length >= this.limit) {
-      this.requests.set(userId, timestamps);
-      return false;
-    }
+  /** Exposed for tests and diagnostics. */
+  size(): number {
+    return this.limiter.size();
+  }
 
-    timestamps.push(now);
-    this.requests.set(userId, timestamps);
-    return true;
+  /** Exposed for tests and account lifecycle cleanup. */
+  clear(): void {
+    this.limiter.clear();
   }
 
-  /** Remove entries with no recent activity. */
-  private cleanup(windowStart: number): void {
-    for (const [userId, timestamps] of this.requests) {
-      const active = timestamps.filter((ts) => ts > windowStart);
-      if (active.length === 0) {
-        this.requests.delete(userId);
-      } else {
-        this.requests.set(userId, active);
-      }
-    }
+  /** Exposed for tests. */
+  maxRequests(): number {
+    return this.limit;
   }
 }

package/src/session-key.ts

@@ -0,0 +1,21 @@
+import { buildAgentSessionKey } from "openclaw/plugin-sdk/routing";
+
+const CHANNEL_ID = "synology-chat";
+
+export function buildSynologyChatInboundSessionKey(params: {
+  agentId: string;
+  accountId: string;
+  userId: string;
+  identityLinks?: Record<string, string[]>;
+}): string {
+  return buildAgentSessionKey({
+    agentId: params.agentId,
+    channel: CHANNEL_ID,
+    accountId: params.accountId,
+    peer: { kind: "direct", id: params.userId },
+    // Synology Chat supports multiple independent accounts on one gateway.
+    // Keep direct-message sessions isolated per account and user.
+    dmScope: "per-account-channel-peer",
+    identityLinks: params.identityLinks,
+  });
+}