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

package/src/types.ts

@@ -4,9 +4,7 @@ import type {
   DmPolicy,
   GroupPolicy,
   SecretInput,
-} from "openclaw/plugin-sdk/nextcloud-talk";
-
-export type { DmPolicy, GroupPolicy };
+} from "../runtime-api.js";
 
 export type NextcloudTalkRoomConfig = {
   requireMention?: boolean;
@@ -22,6 +20,11 @@ export type NextcloudTalkRoomConfig = {
   systemPrompt?: string;
 };
 
+type NextcloudTalkNetworkConfig = {
+  /** Dangerous opt-in for self-hosted Nextcloud Talk on trusted private/internal hosts. */
+  dangerouslyAllowPrivateNetwork?: boolean;
+};
+
 export type NextcloudTalkAccountConfig = {
   /** Optional display name for this account (used in CLI/UI lists). */
   name?: string;
@@ -75,9 +78,11 @@ export type NextcloudTalkAccountConfig = {
   responsePrefix?: string;
   /** Media upload max size in MB. */
   mediaMaxMb?: number;
+  /** Network policy overrides for self-hosted Nextcloud Talk on trusted private/internal hosts. */
+  network?: NextcloudTalkNetworkConfig;
 };
 
-export type NextcloudTalkConfig = {
+type NextcloudTalkConfig = {
   /** Optional per-account Nextcloud Talk configuration (multi-account). */
   accounts?: Record<string, NextcloudTalkAccountConfig>;
   /** Optional default account id when multiple accounts are configured. */
@@ -97,7 +102,7 @@ export type CoreConfig = {
  */
 
 /** Actor in the activity (the message sender). */
-export type NextcloudTalkActor = {
+type NextcloudTalkActor = {
   type: "Person";
   /** User ID in Nextcloud. */
   id: string;
@@ -106,7 +111,7 @@ export type NextcloudTalkActor = {
 };
 
 /** The message object in the activity. */
-export type NextcloudTalkObject = {
+type NextcloudTalkObject = {
   type: "Note";
   /** Message ID. */
   id: string;
@@ -119,7 +124,7 @@ export type NextcloudTalkObject = {
 };
 
 /** Target conversation/room. */
-export type NextcloudTalkTarget = {
+type NextcloudTalkTarget = {
   type: "Collection";
   /** Room token. */
   id: string;
@@ -172,19 +177,17 @@ export type NextcloudTalkWebhookServerOptions = {
   path: string;
   secret: string;
   maxBodyBytes?: number;
+  authRateLimit?: {
+    maxRequests?: number;
+    windowMs?: number;
+  };
   readBody?: (req: import("node:http").IncomingMessage, maxBodyBytes: number) => Promise<string>;
   isBackendAllowed?: (backend: string) => boolean;
   shouldProcessMessage?: (message: NextcloudTalkInboundMessage) => boolean | Promise<boolean>;
+  processMessage?: (
+    message: NextcloudTalkInboundMessage,
+  ) => void | "processed" | "duplicate" | Promise<void | "processed" | "duplicate">;
   onMessage: (message: NextcloudTalkInboundMessage) => void | Promise<void>;
   onError?: (error: Error) => void;
   abortSignal?: AbortSignal;
 };
-
-/** Options for sending a message. */
-export type NextcloudTalkSendOptions = {
-  baseUrl: string;
-  secret: string;
-  roomToken: string;
-  message: string;
-  replyTo?: string;
-};

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": "../tsconfig.package-boundary.base.json",
+  "compilerOptions": {
+    "rootDir": "."
+  },
+  "include": ["./*.ts", "./src/**/*.ts"],
+  "exclude": [
+    "./**/*.test.ts",
+    "./dist/**",
+    "./node_modules/**",
+    "./src/test-support/**",
+    "./src/**/*test-helpers.ts",
+    "./src/**/*test-harness.ts",
+    "./src/**/*test-support.ts"
+  ]
+}

package/src/accounts.test.ts

@@ -1,30 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { describe, expect, it } from "vitest";
-import { resolveNextcloudTalkAccount } from "./accounts.js";
-import type { CoreConfig } from "./types.js";
-
-describe("resolveNextcloudTalkAccount", () => {
-  it.runIf(process.platform !== "win32")("rejects symlinked botSecretFile paths", () => {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "openclaw-nextcloud-talk-"));
-    const secretFile = path.join(dir, "secret.txt");
-    const secretLink = path.join(dir, "secret-link.txt");
-    fs.writeFileSync(secretFile, "bot-secret\n", "utf8");
-    fs.symlinkSync(secretFile, secretLink);
-
-    const cfg = {
-      channels: {
-        "nextcloud-talk": {
-          baseUrl: "https://cloud.example.com",
-          botSecretFile: secretLink,
-        },
-      },
-    } as CoreConfig;
-
-    const account = resolveNextcloudTalkAccount({ cfg });
-    expect(account.secret).toBe("");
-    expect(account.secretSource).toBe("none");
-    fs.rmSync(dir, { recursive: true, force: true });
-  });
-});

package/src/config-schema.test.ts

@@ -1,36 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { NextcloudTalkConfigSchema } from "./config-schema.js";
-
-describe("NextcloudTalkConfigSchema SecretInput", () => {
-  it("accepts SecretRef botSecret and apiPassword at top-level", () => {
-    const result = NextcloudTalkConfigSchema.safeParse({
-      baseUrl: "https://cloud.example.com",
-      botSecret: { source: "env", provider: "default", id: "NEXTCLOUD_TALK_BOT_SECRET" },
-      apiUser: "bot",
-      apiPassword: { source: "env", provider: "default", id: "NEXTCLOUD_TALK_API_PASSWORD" },
-    });
-    expect(result.success).toBe(true);
-  });
-
-  it("accepts SecretRef botSecret and apiPassword on account", () => {
-    const result = NextcloudTalkConfigSchema.safeParse({
-      accounts: {
-        main: {
-          baseUrl: "https://cloud.example.com",
-          botSecret: {
-            source: "env",
-            provider: "default",
-            id: "NEXTCLOUD_TALK_MAIN_BOT_SECRET",
-          },
-          apiUser: "bot",
-          apiPassword: {
-            source: "env",
-            provider: "default",
-            id: "NEXTCLOUD_TALK_MAIN_API_PASSWORD",
-          },
-        },
-      },
-    });
-    expect(result.success).toBe(true);
-  });
-});

package/src/format.ts

@@ -1,79 +0,0 @@
-/**
- * Format utilities for Nextcloud Talk messages.
- *
- * Nextcloud Talk supports markdown natively, so most formatting passes through.
- * This module handles any edge cases or transformations needed.
- */
-
-/**
- * Convert markdown to Nextcloud Talk compatible format.
- * Nextcloud Talk supports standard markdown, so minimal transformation needed.
- */
-export function markdownToNextcloudTalk(text: string): string {
-  return text.trim();
-}
-
-/**
- * Escape special characters in text to prevent markdown interpretation.
- */
-export function escapeNextcloudTalkMarkdown(text: string): string {
-  return text.replace(/([*_`~[\]()#>+\-=|{}!\\])/g, "\\$1");
-}
-
-/**
- * Format a mention for a Nextcloud user.
- * Nextcloud Talk uses @user format for mentions.
- */
-export function formatNextcloudTalkMention(userId: string): string {
-  return `@${userId.replace(/^@/, "")}`;
-}
-
-/**
- * Format a code block for Nextcloud Talk.
- */
-export function formatNextcloudTalkCodeBlock(code: string, language?: string): string {
-  const lang = language ?? "";
-  return `\`\`\`${lang}\n${code}\n\`\`\``;
-}
-
-/**
- * Format inline code for Nextcloud Talk.
- */
-export function formatNextcloudTalkInlineCode(code: string): string {
-  if (code.includes("`")) {
-    return `\`\` ${code} \`\``;
-  }
-  return `\`${code}\``;
-}
-
-/**
- * Strip Nextcloud Talk specific formatting from text.
- * Useful for extracting plain text content.
- */
-export function stripNextcloudTalkFormatting(text: string): string {
-  return text
-    .replace(/```[\s\S]*?```/g, "")
-    .replace(/`[^`]+`/g, "")
-    .replace(/\*\*([^*]+)\*\*/g, "$1")
-    .replace(/\*([^*]+)\*/g, "$1")
-    .replace(/_([^_]+)_/g, "$1")
-    .replace(/~~([^~]+)~~/g, "$1")
-    .replace(/\[([^\]]+)\]\([^)]+\)/g, "$1")
-    .replace(/\s+/g, " ")
-    .trim();
-}
-
-/**
- * Truncate text to a maximum length, preserving word boundaries.
- */
-export function truncateNextcloudTalkText(text: string, maxLength: number, suffix = "..."): string {
-  if (text.length <= maxLength) {
-    return text;
-  }
-  const truncated = text.slice(0, maxLength - suffix.length);
-  const lastSpace = truncated.lastIndexOf(" ");
-  if (lastSpace > maxLength * 0.7) {
-    return truncated.slice(0, lastSpace) + suffix;
-  }
-  return truncated + suffix;
-}

package/src/monitor.auth-order.test.ts

@@ -1,28 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { startWebhookServer } from "./monitor.test-harness.js";
-
-describe("createNextcloudTalkWebhookServer auth order", () => {
-  it("rejects missing signature headers before reading request body", async () => {
-    const readBody = vi.fn(async () => {
-      throw new Error("should not be called for missing signature headers");
-    });
-    const harness = await startWebhookServer({
-      path: "/nextcloud-auth-order",
-      maxBodyBytes: 128,
-      readBody,
-      onMessage: vi.fn(),
-    });
-
-    const response = await fetch(harness.webhookUrl, {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-      },
-      body: "{}",
-    });
-
-    expect(response.status).toBe(400);
-    expect(await response.json()).toEqual({ error: "Missing signature headers" });
-    expect(readBody).not.toHaveBeenCalled();
-  });
-});

package/src/monitor.backend.test.ts

@@ -1,27 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { createSignedCreateMessageRequest } from "./monitor.test-fixtures.js";
-import { startWebhookServer } from "./monitor.test-harness.js";
-
-describe("createNextcloudTalkWebhookServer backend allowlist", () => {
-  it("rejects requests from unexpected backend origins", async () => {
-    const onMessage = vi.fn(async () => {});
-    const harness = await startWebhookServer({
-      path: "/nextcloud-backend-check",
-      isBackendAllowed: (backend) => backend === "https://nextcloud.expected",
-      onMessage,
-    });
-
-    const { body, headers } = createSignedCreateMessageRequest({
-      backend: "https://nextcloud.unexpected",
-    });
-    const response = await fetch(harness.webhookUrl, {
-      method: "POST",
-      headers,
-      body,
-    });
-
-    expect(response.status).toBe(401);
-    expect(await response.json()).toEqual({ error: "Invalid backend" });
-    expect(onMessage).not.toHaveBeenCalled();
-  });
-});

package/src/monitor.read-body.test.ts

@@ -1,16 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { createMockIncomingRequest } from "../../../test/helpers/mock-incoming-request.js";
-import { readNextcloudTalkWebhookBody } from "./monitor.js";
-
-describe("readNextcloudTalkWebhookBody", () => {
-  it("reads valid body within max bytes", async () => {
-    const req = createMockIncomingRequest(['{"type":"Create"}']);
-    const body = await readNextcloudTalkWebhookBody(req, 1024);
-    expect(body).toBe('{"type":"Create"}');
-  });
-
-  it("rejects when payload exceeds max bytes", async () => {
-    const req = createMockIncomingRequest(["x".repeat(300)]);
-    await expect(readNextcloudTalkWebhookBody(req, 128)).rejects.toThrow("PayloadTooLarge");
-  });
-});

package/src/normalize.test.ts

@@ -1,28 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  looksLikeNextcloudTalkTargetId,
-  normalizeNextcloudTalkMessagingTarget,
-  stripNextcloudTalkTargetPrefix,
-} from "./normalize.js";
-
-describe("nextcloud-talk target normalization", () => {
-  it("strips supported prefixes to a room token", () => {
-    expect(stripNextcloudTalkTargetPrefix(" room:abc123 ")).toBe("abc123");
-    expect(stripNextcloudTalkTargetPrefix("nextcloud-talk:room:AbC123")).toBe("AbC123");
-    expect(stripNextcloudTalkTargetPrefix("nc-talk:room:ops")).toBe("ops");
-    expect(stripNextcloudTalkTargetPrefix("nc:room:ops")).toBe("ops");
-    expect(stripNextcloudTalkTargetPrefix("room:   ")).toBeUndefined();
-  });
-
-  it("normalizes messaging targets to lowercase channel ids", () => {
-    expect(normalizeNextcloudTalkMessagingTarget("room:AbC123")).toBe("nextcloud-talk:abc123");
-    expect(normalizeNextcloudTalkMessagingTarget("nc-talk:room:Ops")).toBe("nextcloud-talk:ops");
-  });
-
-  it("detects prefixed and bare room ids", () => {
-    expect(looksLikeNextcloudTalkTargetId("nextcloud-talk:room:abc12345")).toBe(true);
-    expect(looksLikeNextcloudTalkTargetId("nc:opsroom1")).toBe(true);
-    expect(looksLikeNextcloudTalkTargetId("abc12345")).toBe(true);
-    expect(looksLikeNextcloudTalkTargetId("")).toBe(false);
-  });
-});

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 },
-    },
-  }),
-};