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

package/src/channel.lifecycle.test.ts

@@ -1,81 +0,0 @@
-import { createStartAccountContext } from "openclaw/plugin-sdk/channel-test-helpers";
-import {
-  expectStopPendingUntilAbort,
-  startAccountAndTrackLifecycle,
-  waitForStartedMocks,
-} from "openclaw/plugin-sdk/channel-test-helpers";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import type { ResolvedNextcloudTalkAccount } from "./accounts.js";
-
-const hoisted = vi.hoisted(() => ({
-  monitorNextcloudTalkProvider: vi.fn(),
-}));
-
-vi.mock("./monitor-runtime.js", () => ({
-  monitorNextcloudTalkProvider: hoisted.monitorNextcloudTalkProvider,
-}));
-
-const { nextcloudTalkGatewayAdapter } = await import("./gateway.js");
-
-function buildAccount(): ResolvedNextcloudTalkAccount {
-  return {
-    accountId: "default",
-    enabled: true,
-    baseUrl: "https://nextcloud.example.com",
-    secret: "secret", // pragma: allowlist secret
-    secretSource: "config", // pragma: allowlist secret
-    config: {
-      baseUrl: "https://nextcloud.example.com",
-      botSecret: "secret", // pragma: allowlist secret
-      webhookPath: "/nextcloud-talk-webhook",
-      webhookPort: 8788,
-    },
-  };
-}
-
-function mockStartedMonitor() {
-  const stop = vi.fn();
-  hoisted.monitorNextcloudTalkProvider.mockResolvedValue({ stop });
-  return stop;
-}
-
-function startNextcloudAccount(abortSignal?: AbortSignal) {
-  return nextcloudTalkGatewayAdapter.startAccount!(
-    createStartAccountContext({
-      account: buildAccount(),
-      abortSignal,
-    }),
-  );
-}
-
-describe("nextcloud-talk startAccount lifecycle", () => {
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("keeps startAccount pending until abort, then stops the monitor", async () => {
-    const stop = mockStartedMonitor();
-    const { abort, task, isSettled } = startAccountAndTrackLifecycle({
-      startAccount: nextcloudTalkGatewayAdapter.startAccount!,
-      account: buildAccount(),
-    });
-    await expectStopPendingUntilAbort({
-      waitForStarted: waitForStartedMocks(hoisted.monitorNextcloudTalkProvider),
-      isSettled,
-      abort,
-      task,
-      stop,
-    });
-  });
-
-  it("stops immediately when startAccount receives an already-aborted signal", async () => {
-    const stop = mockStartedMonitor();
-    const abort = new AbortController();
-    abort.abort();
-
-    await startNextcloudAccount(abort.signal);
-
-    expect(hoisted.monitorNextcloudTalkProvider).toHaveBeenCalledOnce();
-    expect(stop).toHaveBeenCalledOnce();
-  });
-});

package/src/channel.ts

@@ -1,195 +0,0 @@
-import { describeWebhookAccountSnapshot } from "openclaw/plugin-sdk/account-helpers";
-import { createChatChannelPlugin } from "openclaw/plugin-sdk/channel-core";
-import { createLoggedPairingApprovalNotifier } from "openclaw/plugin-sdk/channel-pairing";
-import { createAllowlistProviderRouteAllowlistWarningCollector } from "openclaw/plugin-sdk/channel-policy";
-import {
-  buildWebhookChannelStatusSummary,
-  createComputedAccountStatusAdapter,
-  createDefaultChannelRuntimeState,
-} from "openclaw/plugin-sdk/status-helpers";
-import { resolveNextcloudTalkAccount, type ResolvedNextcloudTalkAccount } from "./accounts.js";
-import { nextcloudTalkApprovalAuth } from "./approval-auth.js";
-import { buildChannelConfigSchema, DEFAULT_ACCOUNT_ID, type ChannelPlugin } from "./channel-api.js";
-import {
-  nextcloudTalkConfigAdapter,
-  nextcloudTalkPairingTextAdapter,
-  nextcloudTalkSecurityAdapter,
-} from "./channel.adapters.js";
-import { NextcloudTalkConfigSchema } from "./config-schema.js";
-import { nextcloudTalkDoctor } from "./doctor.js";
-import { nextcloudTalkGatewayAdapter } from "./gateway.js";
-import {
-  looksLikeNextcloudTalkTargetId,
-  normalizeNextcloudTalkMessagingTarget,
-} from "./normalize.js";
-import { resolveNextcloudTalkGroupToolPolicy } from "./policy.js";
-import { getNextcloudTalkRuntime } from "./runtime.js";
-import { collectRuntimeConfigAssignments, secretTargetRegistryEntries } from "./secret-contract.js";
-import { sendMessageNextcloudTalk } from "./send.js";
-import { resolveNextcloudTalkOutboundSessionRoute } from "./session-route.js";
-import { nextcloudTalkSetupAdapter } from "./setup-core.js";
-import { nextcloudTalkSetupWizard } from "./setup-surface.js";
-import type { CoreConfig } from "./types.js";
-
-const meta = {
-  id: "nextcloud-talk",
-  label: "Nextcloud Talk",
-  selectionLabel: "Nextcloud Talk (self-hosted)",
-  docsPath: "/channels/nextcloud-talk",
-  docsLabel: "nextcloud-talk",
-  blurb: "Self-hosted chat via Nextcloud Talk webhook bots.",
-  aliases: ["nc-talk", "nc"],
-  order: 65,
-  quickstartAllowFrom: true,
-};
-
-const collectNextcloudTalkSecurityWarnings =
-  createAllowlistProviderRouteAllowlistWarningCollector<ResolvedNextcloudTalkAccount>({
-    providerConfigPresent: (cfg) =>
-      (cfg.channels as Record<string, unknown> | undefined)?.["nextcloud-talk"] !== undefined,
-    resolveGroupPolicy: (account) => account.config.groupPolicy,
-    resolveRouteAllowlistConfigured: (account) =>
-      Boolean(account.config.rooms) && Object.keys(account.config.rooms ?? {}).length > 0,
-    restrictSenders: {
-      surface: "Nextcloud Talk rooms",
-      openScope: "any member in allowed rooms",
-      groupPolicyPath: "channels.nextcloud-talk.groupPolicy",
-      groupAllowFromPath: "channels.nextcloud-talk.groupAllowFrom",
-    },
-    noRouteAllowlist: {
-      surface: "Nextcloud Talk rooms",
-      routeAllowlistPath: "channels.nextcloud-talk.rooms",
-      routeScope: "room",
-      groupPolicyPath: "channels.nextcloud-talk.groupPolicy",
-      groupAllowFromPath: "channels.nextcloud-talk.groupAllowFrom",
-    },
-  });
-
-export const nextcloudTalkPlugin: ChannelPlugin<ResolvedNextcloudTalkAccount> =
-  createChatChannelPlugin({
-    base: {
-      id: "nextcloud-talk",
-      meta,
-      setupWizard: nextcloudTalkSetupWizard,
-      capabilities: {
-        chatTypes: ["direct", "group"],
-        reactions: true,
-        threads: false,
-        media: true,
-        nativeCommands: false,
-        blockStreaming: true,
-      },
-      reload: { configPrefixes: ["channels.nextcloud-talk"] },
-      configSchema: buildChannelConfigSchema(NextcloudTalkConfigSchema),
-      config: {
-        ...nextcloudTalkConfigAdapter,
-        isConfigured: (account) => Boolean(account.secret?.trim() && account.baseUrl?.trim()),
-        describeAccount: (account) =>
-          describeWebhookAccountSnapshot({
-            account,
-            configured: Boolean(account.secret?.trim() && account.baseUrl?.trim()),
-            extra: {
-              secretSource: account.secretSource,
-              baseUrl: account.baseUrl ? "[set]" : "[missing]",
-            },
-          }),
-      },
-      approvalCapability: nextcloudTalkApprovalAuth,
-      doctor: nextcloudTalkDoctor,
-      groups: {
-        resolveRequireMention: ({ cfg, accountId, groupId }) => {
-          const account = resolveNextcloudTalkAccount({ cfg: cfg as CoreConfig, accountId });
-          const rooms = account.config.rooms;
-          if (!rooms || !groupId) {
-            return true;
-          }
-
-          const roomConfig = rooms[groupId];
-          if (roomConfig?.requireMention !== undefined) {
-            return roomConfig.requireMention;
-          }
-
-          const wildcardConfig = rooms["*"];
-          if (wildcardConfig?.requireMention !== undefined) {
-            return wildcardConfig.requireMention;
-          }
-
-          return true;
-        },
-        resolveToolPolicy: resolveNextcloudTalkGroupToolPolicy,
-      },
-      messaging: {
-        targetPrefixes: ["nextcloud-talk", "nc-talk", "nc"],
-        normalizeTarget: normalizeNextcloudTalkMessagingTarget,
-        resolveOutboundSessionRoute: (params) => resolveNextcloudTalkOutboundSessionRoute(params),
-        targetResolver: {
-          looksLikeId: looksLikeNextcloudTalkTargetId,
-          hint: "<roomToken>",
-        },
-      },
-      secrets: {
-        secretTargetRegistryEntries,
-        collectRuntimeConfigAssignments,
-      },
-      setup: nextcloudTalkSetupAdapter,
-      status: createComputedAccountStatusAdapter<ResolvedNextcloudTalkAccount>({
-        defaultRuntime: createDefaultChannelRuntimeState(DEFAULT_ACCOUNT_ID),
-        buildChannelSummary: ({ snapshot }) =>
-          buildWebhookChannelStatusSummary(snapshot, {
-            secretSource: snapshot.secretSource ?? "none",
-          }),
-        resolveAccountSnapshot: ({ account }) => ({
-          accountId: account.accountId,
-          name: account.name,
-          enabled: account.enabled,
-          configured: Boolean(account.secret?.trim() && account.baseUrl?.trim()),
-          extra: {
-            secretSource: account.secretSource,
-            baseUrl: account.baseUrl ? "[set]" : "[missing]",
-            mode: "webhook",
-          },
-        }),
-      }),
-      gateway: nextcloudTalkGatewayAdapter,
-    },
-    pairing: {
-      text: {
-        ...nextcloudTalkPairingTextAdapter,
-        notify: createLoggedPairingApprovalNotifier(
-          ({ id }) => `[nextcloud-talk] User ${id} approved for pairing`,
-        ),
-      },
-    },
-    security: {
-      ...nextcloudTalkSecurityAdapter,
-      collectWarnings: collectNextcloudTalkSecurityWarnings,
-    },
-    outbound: {
-      base: {
-        deliveryMode: "direct",
-        chunker: (text, limit) =>
-          getNextcloudTalkRuntime().channel.text.chunkMarkdownText(text, limit),
-        chunkerMode: "markdown",
-        textChunkLimit: 4000,
-      },
-      attachedResults: {
-        channel: "nextcloud-talk",
-        sendText: async ({ cfg, to, text, accountId, replyToId }) =>
-          await sendMessageNextcloudTalk(to, text, {
-            accountId: accountId ?? undefined,
-            replyTo: replyToId ?? undefined,
-            cfg: cfg as CoreConfig,
-          }),
-        sendMedia: async ({ cfg, to, text, mediaUrl, accountId, replyToId }) =>
-          await sendMessageNextcloudTalk(
-            to,
-            mediaUrl ? `${text}\n\nAttachment: ${mediaUrl}` : text,
-            {
-              accountId: accountId ?? undefined,
-              replyTo: replyToId ?? undefined,
-              cfg: cfg as CoreConfig,
-            },
-          ),
-      },
-    },
-  });

package/src/config-schema.ts

@@ -1,79 +0,0 @@
-import {
-  DmPolicySchema,
-  GroupPolicySchema,
-  MarkdownConfigSchema,
-  ReplyRuntimeConfigSchemaShape,
-  ToolPolicySchema,
-  requireOpenAllowFrom,
-} from "openclaw/plugin-sdk/channel-config-schema";
-import { requireChannelOpenAllowFrom } from "openclaw/plugin-sdk/extension-shared";
-import { z } from "openclaw/plugin-sdk/zod";
-import { buildSecretInputSchema } from "./secret-input.js";
-
-const NextcloudTalkRoomSchema = z
-  .object({
-    requireMention: z.boolean().optional(),
-    tools: ToolPolicySchema,
-    skills: z.array(z.string()).optional(),
-    enabled: z.boolean().optional(),
-    allowFrom: z.array(z.string()).optional(),
-    systemPrompt: z.string().optional(),
-  })
-  .strict();
-
-const NextcloudTalkNetworkSchema = z
-  .object({
-    /** Dangerous opt-in for self-hosted Nextcloud Talk on trusted private/internal hosts. */
-    dangerouslyAllowPrivateNetwork: z.boolean().optional(),
-  })
-  .strict()
-  .optional();
-
-const NextcloudTalkAccountSchemaBase = z
-  .object({
-    name: z.string().optional(),
-    enabled: z.boolean().optional(),
-    markdown: MarkdownConfigSchema,
-    baseUrl: z.string().optional(),
-    botSecret: buildSecretInputSchema().optional(),
-    botSecretFile: z.string().optional(),
-    apiUser: z.string().optional(),
-    apiPassword: buildSecretInputSchema().optional(),
-    apiPasswordFile: z.string().optional(),
-    dmPolicy: DmPolicySchema.optional().default("pairing"),
-    webhookPort: z.number().int().positive().optional(),
-    webhookHost: z.string().optional(),
-    webhookPath: z.string().optional(),
-    webhookPublicUrl: z.string().optional(),
-    allowFrom: z.array(z.string()).optional(),
-    groupAllowFrom: z.array(z.string()).optional(),
-    groupPolicy: GroupPolicySchema.optional().default("allowlist"),
-    rooms: z.record(z.string(), NextcloudTalkRoomSchema.optional()).optional(),
-    /** Network policy overrides for self-hosted Nextcloud Talk on trusted private/internal hosts. */
-    network: NextcloudTalkNetworkSchema,
-    ...ReplyRuntimeConfigSchemaShape,
-  })
-  .strict();
-
-const NextcloudTalkAccountSchema = NextcloudTalkAccountSchemaBase.superRefine((value, ctx) => {
-  requireChannelOpenAllowFrom({
-    channel: "nextcloud-talk",
-    policy: value.dmPolicy,
-    allowFrom: value.allowFrom,
-    ctx,
-    requireOpenAllowFrom,
-  });
-});
-
-export const NextcloudTalkConfigSchema = NextcloudTalkAccountSchemaBase.extend({
-  accounts: z.record(z.string(), NextcloudTalkAccountSchema.optional()).optional(),
-  defaultAccount: z.string().optional(),
-}).superRefine((value, ctx) => {
-  requireChannelOpenAllowFrom({
-    channel: "nextcloud-talk",
-    policy: value.dmPolicy,
-    allowFrom: value.allowFrom,
-    ctx,
-    requireOpenAllowFrom,
-  });
-});