@kodelyth/nextcloud-talk 2026.5.42 → 2026.6.1

package/src/setup-core.ts

@@ -1,250 +0,0 @@
-import type { ChannelSetupAdapter, ChannelSetupInput } from "klaw/plugin-sdk/channel-setup";
-import type { KlawConfig } from "klaw/plugin-sdk/config-contracts";
-import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "klaw/plugin-sdk/routing";
-import { applyAccountNameToChannelSection, patchScopedAccountConfig } from "klaw/plugin-sdk/setup";
-import {
-  createSetupInputPresenceValidator,
-  mergeAllowFromEntries,
-  promptParsedAllowFromForAccount,
-  resolveSetupAccountId,
-  createSetupTranslator,
-  type ChannelSetupDmPolicy,
-  type WizardPrompter,
-} from "klaw/plugin-sdk/setup-runtime";
-import { formatDocsLink } from "klaw/plugin-sdk/setup-tools";
-import { normalizeLowercaseStringOrEmpty } from "klaw/plugin-sdk/string-coerce-runtime";
-import { resolveDefaultNextcloudTalkAccountId, resolveNextcloudTalkAccount } from "./accounts.js";
-import type { CoreConfig } from "./types.js";
-
-const t = createSetupTranslator();
-
-const channel = "nextcloud-talk" as const;
-
-type NextcloudSetupInput = ChannelSetupInput & {
-  baseUrl?: string;
-  secret?: string;
-  secretFile?: string;
-};
-type NextcloudTalkSection = NonNullable<CoreConfig["channels"]>["nextcloud-talk"];
-
-function addWildcardAllowFrom(allowFrom?: Array<string | number> | null): string[] {
-  return mergeAllowFromEntries(allowFrom, ["*"]);
-}
-
-export function normalizeNextcloudTalkBaseUrl(value: string | undefined): string {
-  return value?.trim().replace(/\/+$/, "") ?? "";
-}
-
-export function validateNextcloudTalkBaseUrl(value: string): string | undefined {
-  if (!value) {
-    return "Required";
-  }
-  if (!value.startsWith("http://") && !value.startsWith("https://")) {
-    return "URL must start with http:// or https://";
-  }
-  return undefined;
-}
-
-export function setNextcloudTalkAccountConfig(
-  cfg: CoreConfig,
-  accountId: string,
-  updates: Record<string, unknown>,
-): CoreConfig {
-  return patchScopedAccountConfig({
-    cfg,
-    channelKey: channel,
-    accountId,
-    patch: updates,
-  }) as CoreConfig;
-}
-
-export function clearNextcloudTalkAccountFields(
-  cfg: CoreConfig,
-  accountId: string,
-  fields: string[],
-): CoreConfig {
-  const section = cfg.channels?.["nextcloud-talk"];
-  if (!section) {
-    return cfg;
-  }
-
-  if (accountId === DEFAULT_ACCOUNT_ID) {
-    const nextSection = { ...section } as Record<string, unknown>;
-    for (const field of fields) {
-      delete nextSection[field];
-    }
-    return {
-      ...cfg,
-      channels: {
-        ...cfg.channels,
-        "nextcloud-talk": nextSection as NextcloudTalkSection,
-      },
-    } as CoreConfig;
-  }
-
-  const currentAccount = section.accounts?.[accountId];
-  if (!currentAccount) {
-    return cfg;
-  }
-
-  const nextAccount = { ...currentAccount } as Record<string, unknown>;
-  for (const field of fields) {
-    delete nextAccount[field];
-  }
-  return {
-    ...cfg,
-    channels: {
-      ...cfg.channels,
-      "nextcloud-talk": {
-        ...section,
-        accounts: {
-          ...section.accounts,
-          [accountId]: nextAccount as NonNullable<typeof section.accounts>[string],
-        },
-      },
-    },
-  } as CoreConfig;
-}
-
-async function promptNextcloudTalkAllowFrom(params: {
-  cfg: CoreConfig;
-  prompter: WizardPrompter;
-  accountId: string;
-}): Promise<CoreConfig> {
-  return await promptParsedAllowFromForAccount({
-    cfg: params.cfg,
-    accountId: params.accountId,
-    defaultAccountId: params.accountId,
-    prompter: params.prompter,
-    noteTitle: t("wizard.nextcloudTalk.userIdTitle"),
-    noteLines: [
-      t("wizard.nextcloudTalk.userIdHelpAdmin"),
-      t("wizard.nextcloudTalk.userIdHelpLogs"),
-      t("wizard.nextcloudTalk.userIdHelpLowercase"),
-      t("wizard.channels.docs", {
-        link: formatDocsLink("/channels/nextcloud-talk", "nextcloud-talk"),
-      }),
-    ],
-    message: t("wizard.nextcloudTalk.allowFromPrompt"),
-    placeholder: "username",
-    parseEntries: (raw) => ({
-      entries: raw
-        .split(/[\n,;]+/g)
-        .map(normalizeLowercaseStringOrEmpty)
-        .filter(Boolean),
-    }),
-    getExistingAllowFrom: ({ cfg, accountId }) =>
-      resolveNextcloudTalkAccount({ cfg, accountId }).config.allowFrom ?? [],
-    mergeEntries: ({ existing, parsed }) =>
-      mergeAllowFromEntries(
-        existing.map((value) => normalizeLowercaseStringOrEmpty(String(value))),
-        parsed,
-      ),
-    applyAllowFrom: ({ cfg, accountId, allowFrom }) =>
-      setNextcloudTalkAccountConfig(cfg, accountId, {
-        dmPolicy: "allowlist",
-        allowFrom,
-      }),
-  });
-}
-
-async function promptNextcloudTalkAllowFromForAccount(params: {
-  cfg: KlawConfig;
-  prompter: WizardPrompter;
-  accountId?: string;
-}): Promise<KlawConfig> {
-  const accountId = resolveSetupAccountId({
-    accountId: params.accountId,
-    defaultAccountId: resolveDefaultNextcloudTalkAccountId(params.cfg as CoreConfig),
-  });
-  return await promptNextcloudTalkAllowFrom({
-    cfg: params.cfg as CoreConfig,
-    prompter: params.prompter,
-    accountId,
-  });
-}
-
-export const nextcloudTalkDmPolicy: ChannelSetupDmPolicy = {
-  label: "Nextcloud Talk",
-  channel,
-  policyKey: "channels.nextcloud-talk.dmPolicy",
-  allowFromKey: "channels.nextcloud-talk.allowFrom",
-  resolveConfigKeys: (cfg, accountId) =>
-    (accountId ?? resolveDefaultNextcloudTalkAccountId(cfg as CoreConfig)) !== DEFAULT_ACCOUNT_ID
-      ? {
-          policyKey: `channels.nextcloud-talk.accounts.${accountId ?? resolveDefaultNextcloudTalkAccountId(cfg as CoreConfig)}.dmPolicy`,
-          allowFromKey: `channels.nextcloud-talk.accounts.${accountId ?? resolveDefaultNextcloudTalkAccountId(cfg as CoreConfig)}.allowFrom`,
-        }
-      : {
-          policyKey: "channels.nextcloud-talk.dmPolicy",
-          allowFromKey: "channels.nextcloud-talk.allowFrom",
-        },
-  getCurrent: (cfg, accountId) =>
-    resolveNextcloudTalkAccount({
-      cfg: cfg as CoreConfig,
-      accountId: accountId ?? resolveDefaultNextcloudTalkAccountId(cfg as CoreConfig),
-    }).config.dmPolicy ?? "pairing",
-  setPolicy: (cfg, policy, accountId) => {
-    const resolvedAccountId = accountId ?? resolveDefaultNextcloudTalkAccountId(cfg as CoreConfig);
-    const resolved = resolveNextcloudTalkAccount({
-      cfg: cfg as CoreConfig,
-      accountId: resolvedAccountId,
-    });
-    return setNextcloudTalkAccountConfig(cfg as CoreConfig, resolvedAccountId, {
-      dmPolicy: policy,
-      ...(policy === "open" ? { allowFrom: addWildcardAllowFrom(resolved.config.allowFrom) } : {}),
-    });
-  },
-  promptAllowFrom: promptNextcloudTalkAllowFromForAccount,
-};
-
-export const nextcloudTalkSetupAdapter: ChannelSetupAdapter = {
-  resolveAccountId: ({ accountId }) => normalizeAccountId(accountId),
-  applyAccountName: ({ cfg, accountId, name }) =>
-    applyAccountNameToChannelSection({
-      cfg,
-      channelKey: channel,
-      accountId,
-      name,
-    }),
-  validateInput: createSetupInputPresenceValidator({
-    defaultAccountOnlyEnvError:
-      "NEXTCLOUD_TALK_BOT_SECRET can only be used for the default account.",
-    validate: ({ input }) => {
-      const setupInput = input as NextcloudSetupInput;
-      if (!setupInput.useEnv && !setupInput.secret && !setupInput.secretFile) {
-        return "Nextcloud Talk requires bot secret or --secret-file (or --use-env).";
-      }
-      if (!setupInput.baseUrl) {
-        return "Nextcloud Talk requires --base-url.";
-      }
-      return null;
-    },
-  }),
-  applyAccountConfig: ({ cfg, accountId, input }) => {
-    const setupInput = input as NextcloudSetupInput;
-    const namedConfig = applyAccountNameToChannelSection({
-      cfg,
-      channelKey: channel,
-      accountId,
-      name: setupInput.name,
-    });
-    const next = setupInput.useEnv
-      ? clearNextcloudTalkAccountFields(namedConfig as CoreConfig, accountId, [
-          "botSecret",
-          "botSecretFile",
-        ])
-      : namedConfig;
-    const patch = {
-      baseUrl: normalizeNextcloudTalkBaseUrl(setupInput.baseUrl),
-      ...(setupInput.useEnv
-        ? {}
-        : setupInput.secretFile
-          ? { botSecretFile: setupInput.secretFile }
-          : setupInput.secret
-            ? { botSecret: setupInput.secret }
-            : {}),
-    };
-    return setNextcloudTalkAccountConfig(next as CoreConfig, accountId, patch);
-  },
-};

package/src/setup-surface.ts

@@ -1,195 +0,0 @@
-import { DEFAULT_ACCOUNT_ID } from "klaw/plugin-sdk/routing";
-import { hasConfiguredSecretInput } from "klaw/plugin-sdk/secret-input";
-import {
-  createStandardChannelSetupStatus,
-  formatDocsLink,
-  setSetupChannelEnabled,
-  createSetupTranslator,
-  type ChannelSetupWizard,
-} from "klaw/plugin-sdk/setup";
-import { normalizeOptionalString } from "klaw/plugin-sdk/string-coerce-runtime";
-import { resolveNextcloudTalkAccount } from "./accounts.js";
-import {
-  clearNextcloudTalkAccountFields,
-  nextcloudTalkDmPolicy,
-  normalizeNextcloudTalkBaseUrl,
-  setNextcloudTalkAccountConfig,
-  validateNextcloudTalkBaseUrl,
-} from "./setup-core.js";
-import type { CoreConfig } from "./types.js";
-
-const t = createSetupTranslator();
-
-const channel = "nextcloud-talk" as const;
-const CONFIGURE_API_FLAG = "__nextcloudTalkConfigureApiCredentials";
-
-export const nextcloudTalkSetupWizard: ChannelSetupWizard = {
-  channel,
-  stepOrder: "text-first",
-  status: createStandardChannelSetupStatus({
-    channelLabel: "Nextcloud Talk",
-    configuredLabel: t("wizard.channels.statusConfigured"),
-    unconfiguredLabel: t("wizard.channels.statusNeedsSetup"),
-    configuredHint: t("wizard.channels.statusConfigured"),
-    unconfiguredHint: t("wizard.channels.statusSelfHostedChat"),
-    configuredScore: 1,
-    unconfiguredScore: 5,
-    resolveConfigured: ({ cfg, accountId }) => {
-      const account = resolveNextcloudTalkAccount({ cfg: cfg as CoreConfig, accountId });
-      return Boolean(account.secret && account.baseUrl);
-    },
-  }),
-  introNote: {
-    title: t("wizard.nextcloudTalk.setupTitle"),
-    lines: [
-      t("wizard.nextcloudTalk.helpSsh"),
-      t("wizard.nextcloudTalk.helpInstallCommand"),
-      t("wizard.nextcloudTalk.helpCopySecret"),
-      t("wizard.nextcloudTalk.helpEnableRoom"),
-      t("wizard.nextcloudTalk.helpEnvTip"),
-      t("wizard.channels.docs", {
-        link: formatDocsLink("/channels/nextcloud-talk", "channels/nextcloud-talk"),
-      }),
-    ],
-    shouldShow: ({ cfg, accountId }) => {
-      const account = resolveNextcloudTalkAccount({ cfg: cfg as CoreConfig, accountId });
-      return !account.secret || !account.baseUrl;
-    },
-  },
-  prepare: async ({ cfg, accountId, credentialValues, prompter }) => {
-    const resolvedAccount = resolveNextcloudTalkAccount({ cfg: cfg as CoreConfig, accountId });
-    const hasApiCredentials = Boolean(
-      resolvedAccount.config.apiUser?.trim() &&
-      (hasConfiguredSecretInput(resolvedAccount.config.apiPassword) ||
-        resolvedAccount.config.apiPasswordFile),
-    );
-    const configureApiCredentials = await prompter.confirm({
-      message: t("wizard.nextcloudTalk.configureApiCredentials"),
-      initialValue: hasApiCredentials,
-    });
-    if (!configureApiCredentials) {
-      return undefined;
-    }
-    return {
-      credentialValues: {
-        ...credentialValues,
-        [CONFIGURE_API_FLAG]: "1",
-      },
-    };
-  },
-  credentials: [
-    {
-      inputKey: "token",
-      providerHint: channel,
-      credentialLabel: t("wizard.nextcloudTalk.botSecret"),
-      preferredEnvVar: "NEXTCLOUD_TALK_BOT_SECRET",
-      envPrompt: t("wizard.nextcloudTalk.botSecretEnvPrompt"),
-      keepPrompt: t("wizard.nextcloudTalk.botSecretKeep"),
-      inputPrompt: t("wizard.nextcloudTalk.botSecretInput"),
-      allowEnv: ({ accountId }) => accountId === DEFAULT_ACCOUNT_ID,
-      inspect: ({ cfg, accountId }) => {
-        const resolvedAccount = resolveNextcloudTalkAccount({ cfg: cfg as CoreConfig, accountId });
-        return {
-          accountConfigured: Boolean(resolvedAccount.secret && resolvedAccount.baseUrl),
-          hasConfiguredValue: Boolean(
-            hasConfiguredSecretInput(resolvedAccount.config.botSecret) ||
-            resolvedAccount.config.botSecretFile,
-          ),
-          resolvedValue: resolvedAccount.secret || undefined,
-          envValue:
-            accountId === DEFAULT_ACCOUNT_ID
-              ? normalizeOptionalString(process.env.NEXTCLOUD_TALK_BOT_SECRET)
-              : undefined,
-        };
-      },
-      applyUseEnv: async (params) => {
-        const resolvedAccount = resolveNextcloudTalkAccount({
-          cfg: params.cfg as CoreConfig,
-          accountId: params.accountId,
-        });
-        const cleared = clearNextcloudTalkAccountFields(
-          params.cfg as CoreConfig,
-          params.accountId,
-          ["botSecret", "botSecretFile"],
-        );
-        return setNextcloudTalkAccountConfig(cleared, params.accountId, {
-          baseUrl: resolvedAccount.baseUrl,
-        });
-      },
-      applySet: async (params) =>
-        setNextcloudTalkAccountConfig(
-          clearNextcloudTalkAccountFields(params.cfg as CoreConfig, params.accountId, [
-            "botSecret",
-            "botSecretFile",
-          ]),
-          params.accountId,
-          {
-            botSecret: params.value,
-          },
-        ),
-    },
-    {
-      inputKey: "password",
-      providerHint: "nextcloud-talk-api",
-      credentialLabel: t("wizard.nextcloudTalk.apiPassword"),
-      preferredEnvVar: "NEXTCLOUD_TALK_API_PASSWORD",
-      envPrompt: "",
-      keepPrompt: t("wizard.nextcloudTalk.apiPasswordKeep"),
-      inputPrompt: t("wizard.nextcloudTalk.apiPasswordInput"),
-      inspect: ({ cfg, accountId }) => {
-        const resolvedAccount = resolveNextcloudTalkAccount({ cfg: cfg as CoreConfig, accountId });
-        const apiUser = resolvedAccount.config.apiUser?.trim();
-        const apiPasswordConfigured = Boolean(
-          hasConfiguredSecretInput(resolvedAccount.config.apiPassword) ||
-          resolvedAccount.config.apiPasswordFile,
-        );
-        return {
-          accountConfigured: Boolean(apiUser && apiPasswordConfigured),
-          hasConfiguredValue: apiPasswordConfigured,
-        };
-      },
-      shouldPrompt: ({ credentialValues }) => credentialValues[CONFIGURE_API_FLAG] === "1",
-      applySet: async (params) =>
-        setNextcloudTalkAccountConfig(
-          clearNextcloudTalkAccountFields(params.cfg as CoreConfig, params.accountId, [
-            "apiPassword",
-            "apiPasswordFile",
-          ]),
-          params.accountId,
-          {
-            apiPassword: params.value,
-          },
-        ),
-    },
-  ],
-  textInputs: [
-    {
-      inputKey: "httpUrl",
-      message: t("wizard.nextcloudTalk.instanceUrlPrompt"),
-      currentValue: ({ cfg, accountId }) =>
-        resolveNextcloudTalkAccount({ cfg: cfg as CoreConfig, accountId }).baseUrl || undefined,
-      shouldPrompt: ({ currentValue }) => !currentValue,
-      validate: ({ value }) => validateNextcloudTalkBaseUrl(value),
-      normalizeValue: ({ value }) => normalizeNextcloudTalkBaseUrl(value),
-      applySet: async (params) =>
-        setNextcloudTalkAccountConfig(params.cfg as CoreConfig, params.accountId, {
-          baseUrl: params.value,
-        }),
-    },
-    {
-      inputKey: "userId",
-      message: t("wizard.nextcloudTalk.apiUserPrompt"),
-      currentValue: ({ cfg, accountId }) =>
-        resolveNextcloudTalkAccount({ cfg: cfg as CoreConfig, accountId }).config.apiUser?.trim() ||
-        undefined,
-      shouldPrompt: ({ credentialValues }) => credentialValues[CONFIGURE_API_FLAG] === "1",
-      validate: ({ value }) => (value ? undefined : t("common.required")),
-      applySet: async (params) =>
-        setNextcloudTalkAccountConfig(params.cfg as CoreConfig, params.accountId, {
-          apiUser: params.value,
-        }),
-    },
-  ],
-  dmPolicy: nextcloudTalkDmPolicy,
-  disable: (cfg) => setSetupChannelEnabled(cfg, channel, false),
-};