@kodelyth/synology-chat 2026.5.39 → 2026.5.42

package/src/channel.integration.test.ts

@@ -0,0 +1,204 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  buildChannelInboundEventContextMock,
+  dispatchReplyWithBufferedBlockDispatcher,
+  finalizeInboundContextMock,
+  registerPluginHttpRouteMock,
+  resolveAgentRouteMock,
+  setSynologyRuntimeConfigForTest,
+} from "./channel.test-mocks.js";
+import { makeFormBody, makeReq, makeRes } from "./test-http-utils.js";
+
+type _RegisteredRoute = {
+  path: string;
+  accountId: string;
+  handler: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+};
+
+let createSynologyChatPlugin: typeof import("./channel.js").createSynologyChatPlugin;
+
+function makeStartContext<T>(cfg: T, accountId: string, abortSignal: AbortSignal) {
+  setSynologyRuntimeConfigForTest(cfg);
+  return {
+    cfg,
+    accountId,
+    log: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+    abortSignal,
+  };
+}
+
+function requireRecord(value: unknown, label: string): Record<string, unknown> {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`expected ${label} to be a record`);
+  }
+  return value as Record<string, unknown>;
+}
+
+function requireMockCall<TArgs extends unknown[]>(
+  mock: { mock: { calls: TArgs[] } },
+  index: number,
+  label: string,
+): TArgs {
+  const call = mock.mock.calls[index];
+  if (!call) {
+    throw new Error(`expected ${label}`);
+  }
+  return call;
+}
+
+describe("Synology channel wiring integration", () => {
+  beforeAll(async () => {
+    ({ createSynologyChatPlugin } = await import("./channel.js"));
+  });
+
+  beforeEach(() => {
+    registerPluginHttpRouteMock.mockClear();
+    dispatchReplyWithBufferedBlockDispatcher.mockClear();
+    buildChannelInboundEventContextMock.mockClear();
+    finalizeInboundContextMock.mockClear();
+    resolveAgentRouteMock.mockClear();
+    setSynologyRuntimeConfigForTest({});
+  });
+
+  it("registers real webhook handler with resolved account config and enforces allowlist", async () => {
+    const plugin = createSynologyChatPlugin();
+    const abortController = new AbortController();
+    const cfg = {
+      channels: {
+        "synology-chat": {
+          enabled: true,
+          accounts: {
+            alerts: {
+              enabled: true,
+              token: "valid-token",
+              incomingUrl: "https://nas.example.com/incoming",
+              webhookPath: "/webhook/synology-alerts",
+              dmPolicy: "allowlist",
+              allowedUserIds: ["456"],
+            },
+          },
+        },
+      },
+    };
+
+    const started = plugin.gateway.startAccount(
+      makeStartContext(cfg, "alerts", abortController.signal),
+    );
+    expect(registerPluginHttpRouteMock).toHaveBeenCalledTimes(1);
+
+    const firstCall = registerPluginHttpRouteMock.mock.calls[0];
+    if (!firstCall) {
+      throw new Error("Expected registerPluginHttpRoute to be called");
+    }
+    const registered = firstCall[0];
+    expect(registered.path).toBe("/webhook/synology-alerts");
+    expect(registered.accountId).toBe("alerts");
+
+    const req = makeReq(
+      "POST",
+      makeFormBody({
+        token: "valid-token",
+        user_id: "123",
+        username: "unauthorized-user",
+        text: "Hello",
+      }),
+    );
+    const res = makeRes();
+    await registered.handler(req, res);
+
+    expect(res.status).toBe(403);
+    expect(res.body).toContain("not authorized");
+    expect(dispatchReplyWithBufferedBlockDispatcher).not.toHaveBeenCalled();
+    abortController.abort();
+    await started;
+  });
+
+  it("isolates same user_id across different accounts", async () => {
+    const plugin = createSynologyChatPlugin();
+    const alphaAbortController = new AbortController();
+    const betaAbortController = new AbortController();
+    const cfg = {
+      channels: {
+        "synology-chat": {
+          enabled: true,
+          accounts: {
+            alpha: {
+              enabled: true,
+              token: "token-alpha",
+              incomingUrl: "https://nas.example.com/incoming-alpha",
+              webhookPath: "/webhook/synology-alpha",
+              dmPolicy: "open",
+              allowedUserIds: ["*"],
+            },
+            beta: {
+              enabled: true,
+              token: "token-beta",
+              incomingUrl: "https://nas.example.com/incoming-beta",
+              webhookPath: "/webhook/synology-beta",
+              dmPolicy: "open",
+              allowedUserIds: ["*"],
+            },
+          },
+        },
+      },
+      session: {
+        dmScope: "main" as const,
+      },
+    };
+
+    const alphaStarted = plugin.gateway.startAccount(
+      makeStartContext(cfg, "alpha", alphaAbortController.signal),
+    );
+    const betaStarted = plugin.gateway.startAccount(
+      makeStartContext(cfg, "beta", betaAbortController.signal),
+    );
+
+    expect(registerPluginHttpRouteMock).toHaveBeenCalledTimes(2);
+    const [alphaRoute] = requireMockCall(registerPluginHttpRouteMock, 0, "alpha Synology route");
+    const [betaRoute] = requireMockCall(registerPluginHttpRouteMock, 1, "beta Synology route");
+
+    const alphaReq = makeReq(
+      "POST",
+      makeFormBody({
+        token: "token-alpha",
+        user_id: "123",
+        username: "alice",
+        text: "alpha secret",
+      }),
+    );
+    const alphaRes = makeRes();
+    await alphaRoute.handler(alphaReq, alphaRes);
+
+    const betaReq = makeReq(
+      "POST",
+      makeFormBody({
+        token: "token-beta",
+        user_id: "123",
+        username: "bob",
+        text: "beta secret",
+      }),
+    );
+    const betaRes = makeRes();
+    await betaRoute.handler(betaReq, betaRes);
+
+    expect(alphaRes.status).toBe(204);
+    expect(betaRes.status).toBe(204);
+    expect(dispatchReplyWithBufferedBlockDispatcher).toHaveBeenCalledTimes(2);
+    expect(finalizeInboundContextMock).toHaveBeenCalledTimes(2);
+
+    const [alphaCtx] = requireMockCall(finalizeInboundContextMock, 0, "alpha inbound context");
+    const [betaCtx] = requireMockCall(finalizeInboundContextMock, 1, "beta inbound context");
+    const alphaContext = requireRecord(alphaCtx, "alpha inbound context");
+    expect(alphaContext.AccountId).toBe("alpha");
+    expect(alphaContext.SessionKey).toBe("agent:agent-alpha:synology-chat:alpha:direct:123");
+    const betaContext = requireRecord(betaCtx, "beta inbound context");
+    expect(betaContext.AccountId).toBe("beta");
+    expect(betaContext.SessionKey).toBe("agent:agent-beta:synology-chat:beta:direct:123");
+
+    alphaAbortController.abort();
+    betaAbortController.abort();
+    await alphaStarted;
+    await betaStarted;
+  });
+});

package/src/channel.test-mocks.ts

@@ -0,0 +1,176 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { Mock } from "vitest";
+import { vi } from "vitest";
+
+type RegisteredRoute = {
+  path: string;
+  accountId: string;
+  handler: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+};
+
+export const registerPluginHttpRouteMock: Mock<(params: RegisteredRoute) => () => void> = vi.fn(
+  () => vi.fn(),
+);
+
+export const dispatchReplyWithBufferedBlockDispatcher: Mock<
+  () => Promise<{ counts: Record<string, number> }>
+> = vi.fn().mockResolvedValue({ counts: {} });
+export const finalizeInboundContextMock: Mock<
+  (ctx: Record<string, unknown>) => Record<string, unknown>
+> = vi.fn((ctx) => ctx);
+export const buildChannelInboundEventContextMock: Mock<
+  (params: {
+    channel: string;
+    accountId?: string;
+    timestamp?: number;
+    from: string;
+    sender: { id: string; name?: string };
+    conversation: { kind: string; label?: string };
+    route: {
+      accountId?: string;
+      routeSessionKey: string;
+      dispatchSessionKey?: string;
+    };
+    reply: { to: string; originatingTo: string };
+    message: {
+      rawBody: string;
+      bodyForAgent?: string;
+      commandBody?: string;
+    };
+    extra?: Record<string, unknown>;
+  }) => Record<string, unknown>
+> = vi.fn((params) =>
+  finalizeInboundContextMock({
+    Body: params.message.rawBody,
+    BodyForAgent: params.message.bodyForAgent ?? params.message.rawBody,
+    RawBody: params.message.rawBody,
+    CommandBody: params.message.commandBody ?? params.message.rawBody,
+    From: params.from,
+    To: params.reply.to,
+    SessionKey: params.route.dispatchSessionKey ?? params.route.routeSessionKey,
+    AccountId: params.route.accountId ?? params.accountId,
+    OriginatingChannel: params.channel,
+    OriginatingTo: params.reply.originatingTo,
+    ChatType: params.conversation.kind,
+    SenderName: params.sender.name,
+    SenderId: params.sender.id,
+    Provider: params.channel,
+    Surface: params.channel,
+    ConversationLabel: params.conversation.label,
+    Timestamp: params.timestamp,
+    ...params.extra,
+  }),
+);
+export const resolveAgentRouteMock: Mock<
+  (params: { accountId?: string }) => { agentId: string; sessionKey: string; accountId: string }
+> = vi.fn((params) => {
+  const accountId = params.accountId?.trim() || "default";
+  return {
+    agentId: `agent-${accountId}`,
+    sessionKey: `agent:agent-${accountId}:main`,
+    accountId,
+  };
+});
+let mockRuntimeConfig: unknown = {};
+
+export function setSynologyRuntimeConfigForTest(cfg: unknown): void {
+  mockRuntimeConfig = cfg;
+}
+
+async function readRequestBodyWithLimitForTest(req: IncomingMessage): Promise<string> {
+  return await new Promise<string>((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    req.on("data", (chunk) => {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    });
+    req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+    req.on("error", reject);
+  });
+}
+
+vi.mock("klaw/plugin-sdk/setup", async () => {
+  const actual = await vi.importActual<object>("klaw/plugin-sdk/setup");
+  return {
+    ...actual,
+    DEFAULT_ACCOUNT_ID: "default",
+  };
+});
+
+vi.mock("klaw/plugin-sdk/channel-config-schema", async () => {
+  const actual = await vi.importActual<object>("klaw/plugin-sdk/channel-config-schema");
+  return {
+    ...actual,
+    buildChannelConfigSchema: vi.fn((schema: unknown) => ({ schema })),
+  };
+});
+
+vi.mock("klaw/plugin-sdk/webhook-ingress", async () => {
+  const actual = await vi.importActual<object>("klaw/plugin-sdk/webhook-ingress");
+  return {
+    ...actual,
+    registerPluginHttpRoute: registerPluginHttpRouteMock,
+    readRequestBodyWithLimit: vi.fn(readRequestBodyWithLimitForTest),
+    isRequestBodyLimitError: vi.fn(() => false),
+    requestBodyErrorToText: vi.fn(() => "Request body too large"),
+    createFixedWindowRateLimiter: vi.fn(() => ({
+      isRateLimited: vi.fn(() => false),
+      size: vi.fn(() => 0),
+      clear: vi.fn(),
+    })),
+  };
+});
+
+vi.mock("./client.js", () => ({
+  sendMessage: vi.fn().mockResolvedValue(true),
+  sendFileUrl: vi.fn().mockResolvedValue(true),
+  resolveLegacyWebhookNameToChatUserId: vi.fn().mockResolvedValue(undefined),
+}));
+
+vi.mock("./runtime.js", () => ({
+  getSynologyRuntime: vi.fn(() => ({
+    config: { current: vi.fn(() => mockRuntimeConfig) },
+    channel: {
+      routing: {
+        resolveAgentRoute: resolveAgentRouteMock,
+      },
+      reply: {
+        finalizeInboundContext: finalizeInboundContextMock,
+        dispatchReplyWithBufferedBlockDispatcher,
+      },
+      session: {
+        resolveStorePath: vi.fn(() => "/tmp/klaw/synology-chat-sessions.json"),
+        recordInboundSession: vi.fn(async () => undefined),
+      },
+      turn: {
+        run: vi.fn(async (params) => {
+          const input = await params.adapter.ingest(params.raw);
+          if (!input) {
+            return { admission: { kind: "drop", reason: "ingest-null" }, dispatched: false };
+          }
+          const resolved = await params.adapter.resolveTurn(input, {
+            kind: "message",
+            canStartAgentTurn: true,
+          });
+          const dispatchResult = await resolved.dispatchReplyWithBufferedBlockDispatcher({
+            ctx: resolved.ctxPayload,
+            cfg: mockRuntimeConfig,
+            dispatcherOptions: {
+              ...resolved.dispatcherOptions,
+              deliver: resolved.delivery.deliver,
+              onError: resolved.delivery.onError,
+            },
+          });
+          return {
+            admission: { kind: "dispatch" },
+            dispatched: true,
+            dispatchResult,
+            ctxPayload: resolved.ctxPayload,
+            routeSessionKey: resolved.routeSessionKey,
+          };
+        }),
+        buildContext: buildChannelInboundEventContextMock,
+      },
+    },
+  })),
+  setSynologyRuntime: vi.fn(),
+}));