@openclaw/nextcloud-talk 2026.3.13 → 2026.5.2-beta.1

package/src/policy.test.ts

@@ -1,138 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { resolveNextcloudTalkAllowlistMatch, resolveNextcloudTalkGroupAllow } from "./policy.js";
-
-describe("nextcloud-talk policy", () => {
-  describe("resolveNextcloudTalkAllowlistMatch", () => {
-    it("allows wildcard", () => {
-      expect(
-        resolveNextcloudTalkAllowlistMatch({
-          allowFrom: ["*"],
-          senderId: "user-id",
-        }).allowed,
-      ).toBe(true);
-    });
-
-    it("allows sender id match with normalization", () => {
-      expect(
-        resolveNextcloudTalkAllowlistMatch({
-          allowFrom: ["nc:User-Id"],
-          senderId: "user-id",
-        }),
-      ).toEqual({ allowed: true, matchKey: "user-id", matchSource: "id" });
-    });
-
-    it("blocks when sender id does not match", () => {
-      expect(
-        resolveNextcloudTalkAllowlistMatch({
-          allowFrom: ["allowed"],
-          senderId: "other",
-        }).allowed,
-      ).toBe(false);
-    });
-  });
-
-  describe("resolveNextcloudTalkGroupAllow", () => {
-    it("blocks disabled policy", () => {
-      expect(
-        resolveNextcloudTalkGroupAllow({
-          groupPolicy: "disabled",
-          outerAllowFrom: ["owner"],
-          innerAllowFrom: ["room-user"],
-          senderId: "owner",
-        }),
-      ).toEqual({
-        allowed: false,
-        outerMatch: { allowed: false },
-        innerMatch: { allowed: false },
-      });
-    });
-
-    it("allows open policy", () => {
-      expect(
-        resolveNextcloudTalkGroupAllow({
-          groupPolicy: "open",
-          outerAllowFrom: [],
-          innerAllowFrom: [],
-          senderId: "owner",
-        }),
-      ).toEqual({
-        allowed: true,
-        outerMatch: { allowed: true },
-        innerMatch: { allowed: true },
-      });
-    });
-
-    it("blocks allowlist mode when both outer and inner allowlists are empty", () => {
-      expect(
-        resolveNextcloudTalkGroupAllow({
-          groupPolicy: "allowlist",
-          outerAllowFrom: [],
-          innerAllowFrom: [],
-          senderId: "owner",
-        }),
-      ).toEqual({
-        allowed: false,
-        outerMatch: { allowed: false },
-        innerMatch: { allowed: false },
-      });
-    });
-
-    it("requires inner match when only room-specific allowlist is configured", () => {
-      expect(
-        resolveNextcloudTalkGroupAllow({
-          groupPolicy: "allowlist",
-          outerAllowFrom: [],
-          innerAllowFrom: ["room-user"],
-          senderId: "room-user",
-        }),
-      ).toEqual({
-        allowed: true,
-        outerMatch: { allowed: false },
-        innerMatch: { allowed: true, matchKey: "room-user", matchSource: "id" },
-      });
-    });
-
-    it("blocks when outer allowlist misses even if inner allowlist matches", () => {
-      expect(
-        resolveNextcloudTalkGroupAllow({
-          groupPolicy: "allowlist",
-          outerAllowFrom: ["team-owner"],
-          innerAllowFrom: ["room-user"],
-          senderId: "room-user",
-        }),
-      ).toEqual({
-        allowed: false,
-        outerMatch: { allowed: false },
-        innerMatch: { allowed: true, matchKey: "room-user", matchSource: "id" },
-      });
-    });
-
-    it("allows when both outer and inner allowlists match", () => {
-      expect(
-        resolveNextcloudTalkGroupAllow({
-          groupPolicy: "allowlist",
-          outerAllowFrom: ["team-owner"],
-          innerAllowFrom: ["room-user"],
-          senderId: "team-owner",
-        }),
-      ).toEqual({
-        allowed: false,
-        outerMatch: { allowed: true, matchKey: "team-owner", matchSource: "id" },
-        innerMatch: { allowed: false },
-      });
-
-      expect(
-        resolveNextcloudTalkGroupAllow({
-          groupPolicy: "allowlist",
-          outerAllowFrom: ["shared-user"],
-          innerAllowFrom: ["shared-user"],
-          senderId: "shared-user",
-        }),
-      ).toEqual({
-        allowed: true,
-        outerMatch: { allowed: true, matchKey: "shared-user", matchSource: "id" },
-        innerMatch: { allowed: true, matchKey: "shared-user", matchSource: "id" },
-      });
-    });
-  });
-});

package/src/replay-guard.test.ts

@@ -1,70 +0,0 @@
-import { mkdtemp, rm } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { createNextcloudTalkReplayGuard } from "./replay-guard.js";
-
-const tempDirs: string[] = [];
-
-afterEach(async () => {
-  while (tempDirs.length > 0) {
-    const dir = tempDirs.pop();
-    if (dir) {
-      await rm(dir, { recursive: true, force: true });
-    }
-  }
-});
-
-async function makeTempDir(): Promise<string> {
-  const dir = await mkdtemp(path.join(os.tmpdir(), "nextcloud-talk-replay-"));
-  tempDirs.push(dir);
-  return dir;
-}
-
-describe("createNextcloudTalkReplayGuard", () => {
-  it("persists replay decisions across guard instances", async () => {
-    const stateDir = await makeTempDir();
-
-    const firstGuard = createNextcloudTalkReplayGuard({ stateDir });
-    const firstAttempt = await firstGuard.shouldProcessMessage({
-      accountId: "account-a",
-      roomToken: "room-1",
-      messageId: "msg-1",
-    });
-    const replayAttempt = await firstGuard.shouldProcessMessage({
-      accountId: "account-a",
-      roomToken: "room-1",
-      messageId: "msg-1",
-    });
-
-    const secondGuard = createNextcloudTalkReplayGuard({ stateDir });
-    const restartReplayAttempt = await secondGuard.shouldProcessMessage({
-      accountId: "account-a",
-      roomToken: "room-1",
-      messageId: "msg-1",
-    });
-
-    expect(firstAttempt).toBe(true);
-    expect(replayAttempt).toBe(false);
-    expect(restartReplayAttempt).toBe(false);
-  });
-
-  it("scopes replay state by account namespace", async () => {
-    const stateDir = await makeTempDir();
-    const guard = createNextcloudTalkReplayGuard({ stateDir });
-
-    const accountAFirst = await guard.shouldProcessMessage({
-      accountId: "account-a",
-      roomToken: "room-1",
-      messageId: "msg-9",
-    });
-    const accountBFirst = await guard.shouldProcessMessage({
-      accountId: "account-b",
-      roomToken: "room-1",
-      messageId: "msg-9",
-    });
-
-    expect(accountAFirst).toBe(true);
-    expect(accountBFirst).toBe(true);
-  });
-});

package/src/send.test.ts

@@ -1,98 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import {
-  createSendCfgThreadingRuntime,
-  expectProvidedCfgSkipsRuntimeLoad,
-  expectRuntimeCfgFallback,
-} from "../../test-utils/send-config.js";
-
-const hoisted = vi.hoisted(() => ({
-  loadConfig: vi.fn(),
-  resolveMarkdownTableMode: vi.fn(() => "preserve"),
-  convertMarkdownTables: vi.fn((text: string) => text),
-  record: vi.fn(),
-  resolveNextcloudTalkAccount: vi.fn(() => ({
-    accountId: "default",
-    baseUrl: "https://nextcloud.example.com",
-    secret: "secret-value", // pragma: allowlist secret
-  })),
-  generateNextcloudTalkSignature: vi.fn(() => ({
-    random: "r",
-    signature: "s",
-  })),
-}));
-
-vi.mock("./runtime.js", () => ({
-  getNextcloudTalkRuntime: () => createSendCfgThreadingRuntime(hoisted),
-}));
-
-vi.mock("./accounts.js", () => ({
-  resolveNextcloudTalkAccount: hoisted.resolveNextcloudTalkAccount,
-}));
-
-vi.mock("./signature.js", () => ({
-  generateNextcloudTalkSignature: hoisted.generateNextcloudTalkSignature,
-}));
-
-import { sendMessageNextcloudTalk, sendReactionNextcloudTalk } from "./send.js";
-
-describe("nextcloud-talk send cfg threading", () => {
-  const fetchMock = vi.fn<typeof fetch>();
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    fetchMock.mockReset();
-    vi.stubGlobal("fetch", fetchMock);
-  });
-
-  afterEach(() => {
-    vi.unstubAllGlobals();
-  });
-
-  it("uses provided cfg for sendMessage and skips runtime loadConfig", async () => {
-    const cfg = { source: "provided" } as const;
-    fetchMock.mockResolvedValueOnce(
-      new Response(
-        JSON.stringify({
-          ocs: { data: { id: 12345, timestamp: 1_706_000_000 } },
-        }),
-        { status: 200, headers: { "content-type": "application/json" } },
-      ),
-    );
-
-    const result = await sendMessageNextcloudTalk("room:abc123", "hello", {
-      cfg,
-      accountId: "work",
-    });
-
-    expectProvidedCfgSkipsRuntimeLoad({
-      loadConfig: hoisted.loadConfig,
-      resolveAccount: hoisted.resolveNextcloudTalkAccount,
-      cfg,
-      accountId: "work",
-    });
-    expect(fetchMock).toHaveBeenCalledTimes(1);
-    expect(result).toEqual({
-      messageId: "12345",
-      roomToken: "abc123",
-      timestamp: 1_706_000_000,
-    });
-  });
-
-  it("falls back to runtime cfg for sendReaction when cfg is omitted", async () => {
-    const runtimeCfg = { source: "runtime" } as const;
-    hoisted.loadConfig.mockReturnValueOnce(runtimeCfg);
-    fetchMock.mockResolvedValueOnce(new Response("{}", { status: 200 }));
-
-    const result = await sendReactionNextcloudTalk("room:ops", "m-1", "👍", {
-      accountId: "default",
-    });
-
-    expect(result).toEqual({ ok: true });
-    expectRuntimeCfgFallback({
-      loadConfig: hoisted.loadConfig,
-      resolveAccount: hoisted.resolveNextcloudTalkAccount,
-      cfg: runtimeCfg,
-      accountId: "default",
-    });
-  });
-});