@openclaw/nextcloud-talk 2026.3.12 → 2026.5.1-beta.2

package/src/onboarding.ts

@@ -1,302 +0,0 @@
-import {
-  formatDocsLink,
-  hasConfiguredSecretInput,
-  mapAllowFromEntries,
-  mergeAllowFromEntries,
-  patchScopedAccountConfig,
-  runSingleChannelSecretStep,
-  resolveAccountIdForConfigure,
-  DEFAULT_ACCOUNT_ID,
-  normalizeAccountId,
-  setTopLevelChannelDmPolicyWithAllowFrom,
-  type ChannelOnboardingAdapter,
-  type ChannelOnboardingDmPolicy,
-  type OpenClawConfig,
-  type WizardPrompter,
-} from "openclaw/plugin-sdk/nextcloud-talk";
-import {
-  listNextcloudTalkAccountIds,
-  resolveDefaultNextcloudTalkAccountId,
-  resolveNextcloudTalkAccount,
-} from "./accounts.js";
-import type { CoreConfig, DmPolicy } from "./types.js";
-
-const channel = "nextcloud-talk" as const;
-
-function setNextcloudTalkDmPolicy(cfg: CoreConfig, dmPolicy: DmPolicy): CoreConfig {
-  return setTopLevelChannelDmPolicyWithAllowFrom({
-    cfg,
-    channel: "nextcloud-talk",
-    dmPolicy,
-    getAllowFrom: (inputCfg) =>
-      mapAllowFromEntries(inputCfg.channels?.["nextcloud-talk"]?.allowFrom),
-  }) as CoreConfig;
-}
-
-function setNextcloudTalkAccountConfig(
-  cfg: CoreConfig,
-  accountId: string,
-  updates: Record<string, unknown>,
-): CoreConfig {
-  return patchScopedAccountConfig({
-    cfg,
-    channelKey: channel,
-    accountId,
-    patch: updates,
-  }) as CoreConfig;
-}
-
-async function noteNextcloudTalkSecretHelp(prompter: WizardPrompter): Promise<void> {
-  await prompter.note(
-    [
-      "1) SSH into your Nextcloud server",
-      '2) Run: ./occ talk:bot:install "OpenClaw" "<shared-secret>" "<webhook-url>" --feature reaction',
-      "3) Copy the shared secret you used in the command",
-      "4) Enable the bot in your Nextcloud Talk room settings",
-      "Tip: you can also set NEXTCLOUD_TALK_BOT_SECRET in your env.",
-      `Docs: ${formatDocsLink("/channels/nextcloud-talk", "channels/nextcloud-talk")}`,
-    ].join("\n"),
-    "Nextcloud Talk bot setup",
-  );
-}
-
-async function noteNextcloudTalkUserIdHelp(prompter: WizardPrompter): Promise<void> {
-  await prompter.note(
-    [
-      "1) Check the Nextcloud admin panel for user IDs",
-      "2) Or look at the webhook payload logs when someone messages",
-      "3) User IDs are typically lowercase usernames in Nextcloud",
-      `Docs: ${formatDocsLink("/channels/nextcloud-talk", "channels/nextcloud-talk")}`,
-    ].join("\n"),
-    "Nextcloud Talk user id",
-  );
-}
-
-async function promptNextcloudTalkAllowFrom(params: {
-  cfg: CoreConfig;
-  prompter: WizardPrompter;
-  accountId: string;
-}): Promise<CoreConfig> {
-  const { cfg, prompter, accountId } = params;
-  const resolved = resolveNextcloudTalkAccount({ cfg, accountId });
-  const existingAllowFrom = resolved.config.allowFrom ?? [];
-  await noteNextcloudTalkUserIdHelp(prompter);
-
-  const parseInput = (value: string) =>
-    value
-      .split(/[\n,;]+/g)
-      .map((entry) => entry.trim().toLowerCase())
-      .filter(Boolean);
-
-  let resolvedIds: string[] = [];
-  while (resolvedIds.length === 0) {
-    const entry = await prompter.text({
-      message: "Nextcloud Talk allowFrom (user id)",
-      placeholder: "username",
-      initialValue: existingAllowFrom[0] ? String(existingAllowFrom[0]) : undefined,
-      validate: (value) => (String(value ?? "").trim() ? undefined : "Required"),
-    });
-    resolvedIds = parseInput(String(entry));
-    if (resolvedIds.length === 0) {
-      await prompter.note("Please enter at least one valid user ID.", "Nextcloud Talk allowlist");
-    }
-  }
-
-  const merged = [
-    ...existingAllowFrom.map((item) => String(item).trim().toLowerCase()).filter(Boolean),
-    ...resolvedIds,
-  ];
-  const unique = mergeAllowFromEntries(undefined, merged);
-
-  return setNextcloudTalkAccountConfig(cfg, accountId, {
-    dmPolicy: "allowlist",
-    allowFrom: unique,
-  });
-}
-
-async function promptNextcloudTalkAllowFromForAccount(params: {
-  cfg: CoreConfig;
-  prompter: WizardPrompter;
-  accountId?: string;
-}): Promise<CoreConfig> {
-  const accountId =
-    params.accountId && normalizeAccountId(params.accountId)
-      ? (normalizeAccountId(params.accountId) ?? DEFAULT_ACCOUNT_ID)
-      : resolveDefaultNextcloudTalkAccountId(params.cfg);
-  return promptNextcloudTalkAllowFrom({
-    cfg: params.cfg,
-    prompter: params.prompter,
-    accountId,
-  });
-}
-
-const dmPolicy: ChannelOnboardingDmPolicy = {
-  label: "Nextcloud Talk",
-  channel,
-  policyKey: "channels.nextcloud-talk.dmPolicy",
-  allowFromKey: "channels.nextcloud-talk.allowFrom",
-  getCurrent: (cfg) => cfg.channels?.["nextcloud-talk"]?.dmPolicy ?? "pairing",
-  setPolicy: (cfg, policy) => setNextcloudTalkDmPolicy(cfg as CoreConfig, policy as DmPolicy),
-  promptAllowFrom: promptNextcloudTalkAllowFromForAccount as (params: {
-    cfg: OpenClawConfig;
-    prompter: WizardPrompter;
-    accountId?: string | undefined;
-  }) => Promise<OpenClawConfig>,
-};
-
-export const nextcloudTalkOnboardingAdapter: ChannelOnboardingAdapter = {
-  channel,
-  getStatus: async ({ cfg }) => {
-    const configured = listNextcloudTalkAccountIds(cfg as CoreConfig).some((accountId) => {
-      const account = resolveNextcloudTalkAccount({ cfg: cfg as CoreConfig, accountId });
-      return Boolean(account.secret && account.baseUrl);
-    });
-    return {
-      channel,
-      configured,
-      statusLines: [`Nextcloud Talk: ${configured ? "configured" : "needs setup"}`],
-      selectionHint: configured ? "configured" : "self-hosted chat",
-      quickstartScore: configured ? 1 : 5,
-    };
-  },
-  configure: async ({
-    cfg,
-    prompter,
-    accountOverrides,
-    shouldPromptAccountIds,
-    forceAllowFrom,
-  }) => {
-    const defaultAccountId = resolveDefaultNextcloudTalkAccountId(cfg as CoreConfig);
-    const accountId = await resolveAccountIdForConfigure({
-      cfg,
-      prompter,
-      label: "Nextcloud Talk",
-      accountOverride: accountOverrides["nextcloud-talk"],
-      shouldPromptAccountIds,
-      listAccountIds: listNextcloudTalkAccountIds as (cfg: OpenClawConfig) => string[],
-      defaultAccountId,
-    });
-
-    let next = cfg as CoreConfig;
-    const resolvedAccount = resolveNextcloudTalkAccount({
-      cfg: next,
-      accountId,
-    });
-    const accountConfigured = Boolean(resolvedAccount.secret && resolvedAccount.baseUrl);
-    const allowEnv = accountId === DEFAULT_ACCOUNT_ID;
-    const hasConfigSecret = Boolean(
-      hasConfiguredSecretInput(resolvedAccount.config.botSecret) ||
-      resolvedAccount.config.botSecretFile,
-    );
-
-    let baseUrl = resolvedAccount.baseUrl;
-    if (!baseUrl) {
-      baseUrl = String(
-        await prompter.text({
-          message: "Enter Nextcloud instance URL (e.g., https://cloud.example.com)",
-          validate: (value) => {
-            const v = String(value ?? "").trim();
-            if (!v) {
-              return "Required";
-            }
-            if (!v.startsWith("http://") && !v.startsWith("https://")) {
-              return "URL must start with http:// or https://";
-            }
-            return undefined;
-          },
-        }),
-      ).trim();
-    }
-
-    const secretStep = await runSingleChannelSecretStep({
-      cfg: next,
-      prompter,
-      providerHint: "nextcloud-talk",
-      credentialLabel: "bot secret",
-      accountConfigured,
-      hasConfigToken: hasConfigSecret,
-      allowEnv,
-      envValue: process.env.NEXTCLOUD_TALK_BOT_SECRET,
-      envPrompt: "NEXTCLOUD_TALK_BOT_SECRET detected. Use env var?",
-      keepPrompt: "Nextcloud Talk bot secret already configured. Keep it?",
-      inputPrompt: "Enter Nextcloud Talk bot secret",
-      preferredEnvVar: "NEXTCLOUD_TALK_BOT_SECRET",
-      onMissingConfigured: async () => await noteNextcloudTalkSecretHelp(prompter),
-      applyUseEnv: async (cfg) =>
-        setNextcloudTalkAccountConfig(cfg as CoreConfig, accountId, {
-          baseUrl,
-        }),
-      applySet: async (cfg, value) =>
-        setNextcloudTalkAccountConfig(cfg as CoreConfig, accountId, {
-          baseUrl,
-          botSecret: value,
-        }),
-    });
-    next = secretStep.cfg as CoreConfig;
-
-    if (secretStep.action === "keep" && baseUrl !== resolvedAccount.baseUrl) {
-      next = setNextcloudTalkAccountConfig(next, accountId, {
-        baseUrl,
-      });
-    }
-
-    const existingApiUser = resolvedAccount.config.apiUser?.trim();
-    const existingApiPasswordConfigured = Boolean(
-      hasConfiguredSecretInput(resolvedAccount.config.apiPassword) ||
-      resolvedAccount.config.apiPasswordFile,
-    );
-    const configureApiCredentials = await prompter.confirm({
-      message: "Configure optional Nextcloud Talk API credentials for room lookups?",
-      initialValue: Boolean(existingApiUser && existingApiPasswordConfigured),
-    });
-    if (configureApiCredentials) {
-      const apiUser = String(
-        await prompter.text({
-          message: "Nextcloud Talk API user",
-          initialValue: existingApiUser,
-          validate: (value) => (String(value ?? "").trim() ? undefined : "Required"),
-        }),
-      ).trim();
-      const apiPasswordStep = await runSingleChannelSecretStep({
-        cfg: next,
-        prompter,
-        providerHint: "nextcloud-talk-api",
-        credentialLabel: "API password",
-        accountConfigured: Boolean(existingApiUser && existingApiPasswordConfigured),
-        hasConfigToken: existingApiPasswordConfigured,
-        allowEnv: false,
-        envPrompt: "",
-        keepPrompt: "Nextcloud Talk API password already configured. Keep it?",
-        inputPrompt: "Enter Nextcloud Talk API password",
-        preferredEnvVar: "NEXTCLOUD_TALK_API_PASSWORD",
-        applySet: async (cfg, value) =>
-          setNextcloudTalkAccountConfig(cfg as CoreConfig, accountId, {
-            apiUser,
-            apiPassword: value,
-          }),
-      });
-      next =
-        apiPasswordStep.action === "keep"
-          ? setNextcloudTalkAccountConfig(next, accountId, { apiUser })
-          : (apiPasswordStep.cfg as CoreConfig);
-    }
-
-    if (forceAllowFrom) {
-      next = await promptNextcloudTalkAllowFrom({
-        cfg: next,
-        prompter,
-        accountId,
-      });
-    }
-
-    return { cfg: next, accountId };
-  },
-  dmPolicy,
-  disable: (cfg) => ({
-    ...cfg,
-    channels: {
-      ...cfg.channels,
-      "nextcloud-talk": { ...cfg.channels?.["nextcloud-talk"], enabled: false },
-    },
-  }),
-};

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,104 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-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: () => ({
-    config: {
-      loadConfig: hoisted.loadConfig,
-    },
-    channel: {
-      text: {
-        resolveMarkdownTableMode: hoisted.resolveMarkdownTableMode,
-        convertMarkdownTables: hoisted.convertMarkdownTables,
-      },
-      activity: {
-        record: hoisted.record,
-      },
-    },
-  }),
-}));
-
-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",
-    });
-
-    expect(hoisted.loadConfig).not.toHaveBeenCalled();
-    expect(hoisted.resolveNextcloudTalkAccount).toHaveBeenCalledWith({
-      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 });
-    expect(hoisted.loadConfig).toHaveBeenCalledTimes(1);
-    expect(hoisted.resolveNextcloudTalkAccount).toHaveBeenCalledWith({
-      cfg: runtimeCfg,
-      accountId: "default",
-    });
-  });
-});