@invago/mixin 1.0.9 → 1.0.11

package/src/mixpay-worker.ts

@@ -0,0 +1,353 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import { getMixpayConfig } from "./config.js";
+import type { MixinMixpayConfig } from "./config-schema.js";
+import { createMixpayPayment, getMixpayPaymentResult, type MixpayPaymentResult } from "./mixpay-service.js";
+import {
+  createMixpayOrder,
+  findMixpayOrder,
+  getMixpayStoreSnapshot,
+  listPendingMixpayOrders,
+  listRecentMixpayOrders,
+  type MixpayOrderRecord,
+  type MixpayOrderStatus,
+  updateMixpayOrder,
+} from "./mixpay-store.js";
+import { sendTextMessage } from "./send-service.js";
+import { sleep, type SendLog } from "./shared.js";
+
+export type MixinCollectRequest = {
+  amount: string;
+  assetId?: string;
+  settlementAssetId?: string;
+  memo?: string;
+  orderId?: string;
+  expireMinutes?: number;
+};
+
+const state: {
+  started: boolean;
+  cfg: OpenClawConfig | null;
+  log: SendLog | null;
+} = {
+  started: false,
+  cfg: null,
+  log: null,
+};
+
+function getPendingPollDelayMs(cfg: OpenClawConfig): number {
+  const configured = Object.values((cfg.channels?.mixin as { accounts?: Record<string, { mixpay?: MixinMixpayConfig }> } | undefined)?.accounts ?? {})
+    .map((account) => account?.mixpay?.pollIntervalSec)
+    .filter((value): value is number => typeof value === "number" && Number.isFinite(value) && value > 0);
+  const topLevel = (cfg.channels?.mixin as { mixpay?: MixinMixpayConfig } | undefined)?.mixpay?.pollIntervalSec;
+  if (typeof topLevel === "number" && Number.isFinite(topLevel) && topLevel > 0) {
+    configured.push(topLevel);
+  }
+  return Math.max(5_000, Math.min(...(configured.length > 0 ? configured : [30])) * 1000);
+}
+
+function formatStatusLabel(status: MixpayOrderStatus): string {
+  switch (status) {
+    case "unpaid":
+      return "unpaid";
+    case "pending":
+      return "pending";
+    case "paid_less":
+      return "paid less";
+    case "success":
+      return "success";
+    case "failed":
+      return "failed";
+    case "expired":
+      return "expired";
+    default:
+      return "unknown";
+  }
+}
+
+export function formatMixpayOrderSummary(order: MixpayOrderRecord): string {
+  const lines = [
+    `MixPay order: ${order.orderId}`,
+    `Status: ${formatStatusLabel(order.status)}`,
+    `Amount: ${order.quoteAmount} ${order.quoteAssetId}`,
+  ];
+  if (order.paymentUrl) {
+    lines.push(`Pay: ${order.paymentUrl}`);
+  }
+  if (order.memo) {
+    lines.push(`Memo: ${order.memo}`);
+  }
+  if (order.expireAt) {
+    lines.push(`Expires: ${order.expireAt}`);
+  }
+  if (order.latestError) {
+    lines.push(`Latest error: ${order.latestError}`);
+  }
+  return lines.join("\n");
+}
+
+function shouldNotifyStatus(config: MixinMixpayConfig, status: MixpayOrderStatus): boolean {
+  if (status === "success" || status === "failed" || status === "expired") {
+    return true;
+  }
+  if (status === "pending") {
+    return config.notifyOnPending === true;
+  }
+  if (status === "paid_less") {
+    return config.notifyOnPaidLess !== false;
+  }
+  return false;
+}
+
+function validateMixpayResult(
+  order: MixpayOrderRecord,
+  payment: MixpayPaymentResult,
+  config: MixinMixpayConfig,
+): string | null {
+  if (config.payeeId?.trim() && payment.payeeId?.trim() && config.payeeId.trim() !== payment.payeeId.trim()) {
+    return "MixPay payeeId mismatch";
+  }
+  if (payment.quoteAssetId?.trim() && payment.quoteAssetId.trim() !== order.quoteAssetId.trim()) {
+    return "MixPay quoteAssetId mismatch";
+  }
+  if (payment.quoteAmount?.trim() && payment.quoteAmount.trim() !== order.quoteAmount.trim()) {
+    return "MixPay quoteAmount mismatch";
+  }
+  return null;
+}
+
+async function notifyOrderStatus(
+  cfg: OpenClawConfig,
+  order: MixpayOrderRecord,
+  nextStatus: MixpayOrderStatus,
+  log: SendLog,
+): Promise<void> {
+  const recipientId = order.recipientId || undefined;
+  const message = [
+    `MixPay order update: ${order.orderId}`,
+    `Status: ${formatStatusLabel(nextStatus)}`,
+    `Amount: ${order.quoteAmount} ${order.quoteAssetId}`,
+  ];
+  if (order.paymentUrl) {
+    message.push(`Pay: ${order.paymentUrl}`);
+  }
+  const result = await sendTextMessage(cfg, order.accountId, order.conversationId, recipientId, message.join("\n"), log);
+  if (!result.ok) {
+    throw new Error(result.error ?? "failed to notify MixPay order status");
+  }
+}
+
+async function pollPendingOrders(): Promise<void> {
+  const cfg = state.cfg;
+  const log = state.log;
+  if (!cfg || !log) {
+    return;
+  }
+
+  const pendingOrders = await listPendingMixpayOrders();
+  for (const order of pendingOrders) {
+    const mixpayConfig = getMixpayConfig(cfg, order.accountId);
+    if (!mixpayConfig?.enabled) {
+      continue;
+    }
+
+    try {
+      const payment = await getMixpayPaymentResult({ config: mixpayConfig, orderId: order.orderId, traceId: order.traceId });
+      const mismatch = validateMixpayResult(order, payment, mixpayConfig);
+      if (mismatch) {
+        throw new Error(mismatch);
+      }
+      const nextStatus = payment.status;
+      const updated = await updateMixpayOrder(order.orderId, (current) => ({
+        ...current,
+        paymentId: current.paymentId ?? payment.raw.id as string | undefined,
+        rawStatus: payment.rawStatus,
+        status: nextStatus,
+        lastPolledAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      }));
+
+      if (!updated) {
+        continue;
+      }
+
+      if (updated.lastNotifyStatus !== nextStatus && shouldNotifyStatus(mixpayConfig, nextStatus)) {
+        await notifyOrderStatus(cfg, updated, nextStatus, log);
+        await updateMixpayOrder(order.orderId, (current) => ({
+          ...current,
+          lastNotifyStatus: nextStatus,
+          updatedAt: new Date().toISOString(),
+        }));
+      }
+    } catch (err) {
+      log.warn(`[mixin] MixPay poll failed: orderId=${order.orderId}, error=${err instanceof Error ? err.message : String(err)}`);
+      await updateMixpayOrder(order.orderId, (current) => ({
+        ...current,
+        latestError: err instanceof Error ? err.message : String(err),
+        lastPolledAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      }));
+    }
+  }
+}
+
+export async function startMixpayWorker(cfg: OpenClawConfig, log: SendLog): Promise<void> {
+  state.cfg = cfg;
+  state.log = log;
+  if (state.started) {
+    return;
+  }
+  state.started = true;
+
+  void (async () => {
+    while (true) {
+      try {
+        await pollPendingOrders();
+      } catch (err) {
+        log.error("[mixin] MixPay worker loop failed", err);
+      }
+      await sleep(getPendingPollDelayMs(state.cfg ?? cfg));
+    }
+  })();
+}
+
+export async function createMixinCollectOrder(params: {
+  cfg: OpenClawConfig;
+  accountId: string;
+  conversationId: string;
+  recipientId?: string;
+  creatorId: string;
+  request: MixinCollectRequest;
+}): Promise<MixpayOrderRecord> {
+  const mixpayConfig = getMixpayConfig(params.cfg, params.accountId);
+  if (!mixpayConfig?.enabled) {
+    throw new Error("MixPay is not enabled for this Mixin account");
+  }
+
+  const normalizedCreatorId = params.creatorId.trim().toLowerCase();
+  const allowedCreators = (mixpayConfig.allowedCreators ?? []).map((item) => item.trim().toLowerCase()).filter(Boolean);
+  if (allowedCreators.length > 0 && !allowedCreators.includes(normalizedCreatorId)) {
+    throw new Error("MixPay collect creation is not allowed for this sender");
+  }
+
+  const created = await createMixpayPayment({
+    config: mixpayConfig,
+    orderId: params.request.orderId,
+    quoteAmount: params.request.amount,
+    quoteAssetId: params.request.assetId?.trim() || mixpayConfig.defaultQuoteAssetId?.trim() || "",
+    settlementAssetId: params.request.settlementAssetId,
+    memo: params.request.memo,
+    expireMinutes: params.request.expireMinutes,
+  });
+
+  const quoteAssetId = params.request.assetId?.trim() || mixpayConfig.defaultQuoteAssetId?.trim();
+  if (!quoteAssetId) {
+    throw new Error("MixPay quote asset is not configured");
+  }
+
+  const record: MixpayOrderRecord = {
+    orderId: created.orderId,
+    traceId: created.traceId,
+    paymentId: created.paymentId,
+    code: created.code,
+    paymentUrl: created.paymentUrl,
+    accountId: params.accountId,
+    conversationId: params.conversationId,
+    recipientId: params.recipientId,
+    creatorId: params.creatorId,
+    quoteAssetId,
+    quoteAmount: params.request.amount,
+    settlementAssetId: params.request.settlementAssetId,
+    memo: params.request.memo,
+    status: "unpaid",
+    createdAt: created.createdAt,
+    updatedAt: created.createdAt,
+    expireAt: created.expireAt,
+  };
+
+  await createMixpayOrder(record);
+  return record;
+}
+
+export async function getMixpayOrderStatusText(orderId: string): Promise<string> {
+  const order = await findMixpayOrder(orderId);
+  if (!order) {
+    return `MixPay order not found: ${orderId}`;
+  }
+  return formatMixpayOrderSummary(order);
+}
+
+export async function refreshMixpayOrderStatus(params: {
+  cfg: OpenClawConfig;
+  accountId: string;
+  orderId: string;
+}): Promise<MixpayOrderRecord | null> {
+  const order = await findMixpayOrder(params.orderId);
+  if (!order || order.accountId !== params.accountId) {
+    return order;
+  }
+
+  const mixpayConfig = getMixpayConfig(params.cfg, params.accountId);
+  if (!mixpayConfig?.enabled) {
+    return order;
+  }
+
+  try {
+    const payment = await getMixpayPaymentResult({
+      config: mixpayConfig,
+      orderId: order.orderId,
+      traceId: order.traceId,
+    });
+    const mismatch = validateMixpayResult(order, payment, mixpayConfig);
+    if (mismatch) {
+      throw new Error(mismatch);
+    }
+    return await updateMixpayOrder(order.orderId, (current) => ({
+      ...current,
+      rawStatus: payment.rawStatus,
+      status: payment.status,
+      lastPolledAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      latestError: undefined,
+    }));
+  } catch (err) {
+    return await updateMixpayOrder(order.orderId, (current) => ({
+      ...current,
+      latestError: err instanceof Error ? err.message : String(err),
+      lastPolledAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    }));
+  }
+}
+
+export async function getRecentMixpayOrdersText(params: {
+  accountId: string;
+  conversationId: string;
+  limit?: number;
+}): Promise<string> {
+  const items = await listRecentMixpayOrders({
+    accountId: params.accountId,
+    conversationId: params.conversationId,
+    limit: params.limit ?? 5,
+  });
+
+  if (items.length === 0) {
+    return "No MixPay orders found for this conversation.";
+  }
+
+  return items
+    .map((item) => `${item.orderId} | ${formatStatusLabel(item.status)} | ${item.quoteAmount} ${item.quoteAssetId}`)
+    .join("\n");
+}
+
+export async function getMixpayStatusSnapshot(): Promise<{
+  pendingOrders: number;
+  storeDir: string;
+  storeFile: string;
+}> {
+  const snapshot = await getMixpayStoreSnapshot();
+  return {
+    pendingOrders: snapshot.pending,
+    storeDir: snapshot.storeDir,
+    storeFile: snapshot.storeFile,
+  };
+}

package/src/onboarding.ts

@@ -0,0 +1,342 @@
+import type {
+  ChannelOnboardingAdapter,
+  ChannelOnboardingDmPolicy,
+  DmPolicy,
+  OpenClawConfig,
+  WizardPrompter,
+} from "openclaw/plugin-sdk";
+import { DEFAULT_ACCOUNT_ID, promptAccountId } from "openclaw/plugin-sdk";
+import { getAccountConfig, listAccountIds, resolveAccount, resolveDefaultAccountId } from "./config.js";
+import type { MixinAccountConfig } from "./config-schema.js";
+
+const channel = "mixin" as const;
+
+type MixinConfigRoot = Partial<MixinAccountConfig> & {
+  defaultAccount?: string;
+  accounts?: Record<string, Partial<MixinAccountConfig> | undefined>;
+};
+
+type MixinGroupPolicy = NonNullable<MixinAccountConfig["groupPolicy"]>;
+
+type MixinDmPolicy = NonNullable<MixinAccountConfig["dmPolicy"]>;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function getMixinRoot(cfg: OpenClawConfig): MixinConfigRoot {
+  const root = cfg as unknown as Record<string, unknown>;
+  const channels = isRecord(root.channels) ? root.channels : undefined;
+  const channelConfig = channels && isRecord(channels.mixin) ? channels.mixin : undefined;
+  if (channelConfig) {
+    return channelConfig as MixinConfigRoot;
+  }
+
+  const legacyNamedConfig = isRecord(root.mixin) ? root.mixin : undefined;
+  if (legacyNamedConfig) {
+    return legacyNamedConfig as MixinConfigRoot;
+  }
+
+  const plugins = isRecord(root.plugins) ? root.plugins : undefined;
+  const entries = plugins && isRecord(plugins.entries) ? plugins.entries : undefined;
+  const mixinEntry = entries && isRecord(entries.mixin) ? entries.mixin : undefined;
+  const pluginEntryConfig = mixinEntry && isRecord(mixinEntry.config) ? mixinEntry.config : undefined;
+  if (pluginEntryConfig) {
+    return pluginEntryConfig as MixinConfigRoot;
+  }
+
+  return isRecord(root) ? (root as MixinConfigRoot) : {};
+}
+
+function updateMixinRoot(cfg: OpenClawConfig, patch: Partial<MixinConfigRoot>): OpenClawConfig {
+  const current = getMixinRoot(cfg);
+  return {
+    ...cfg,
+    channels: {
+      ...(cfg.channels ?? {}),
+      mixin: {
+        ...current,
+        ...patch,
+      },
+    },
+  } as OpenClawConfig;
+}
+
+function updateMixinAccountConfig(
+  cfg: OpenClawConfig,
+  accountId: string,
+  patch: Partial<MixinAccountConfig>,
+): OpenClawConfig {
+  if (accountId === DEFAULT_ACCOUNT_ID) {
+    return updateMixinRoot(cfg, patch);
+  }
+
+  const current = getMixinRoot(cfg);
+  const accounts = current.accounts ?? {};
+
+  return updateMixinRoot(cfg, {
+    accounts: {
+      ...accounts,
+      [accountId]: {
+        ...(accounts[accountId] ?? {}),
+        ...patch,
+      },
+    },
+  });
+}
+
+function mergeAllowFrom(values: string[] | undefined, nextValue: string): string[] {
+  const parts = nextValue
+    .split(/[\n,;]+/g)
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+  return [...new Set([...(values ?? []), ...parts])];
+}
+
+
+async function promptAccountGuide(prompter: WizardPrompter): Promise<void> {
+  await prompter.note(
+    [
+      "Mixin uses Blaze WebSocket and needs one account block per bot account.",
+      "Required fields: appId, sessionId, serverPublicKey, sessionPrivateKey.",
+      "Single-account setup lives directly under channels.mixin.",
+      "Multi-account setup lives under channels.mixin.accounts.<accountId>.",
+      "Optional fields: dmPolicy, allowFrom, groupPolicy, mixpay, proxy.",
+      "Docs: README.md / README.zh-CN.md",
+    ].join("\n"),
+    "Mixin setup guide",
+  );
+}
+
+function setRootDmPolicy(cfg: OpenClawConfig, policy: DmPolicy): OpenClawConfig {
+  return updateMixinRoot(cfg, {
+    dmPolicy: policy as MixinDmPolicy,
+  });
+}
+
+function normalizeDmPolicy(value: unknown): MixinDmPolicy {
+  return value === "allowlist" || value === "open" || value === "disabled" ? value : "pairing";
+}
+
+function normalizeGroupPolicy(value: unknown): MixinGroupPolicy {
+  return value === "allowlist" || value === "open" || value === "disabled" ? value : "open";
+}
+
+function defaultMixpayConfig(existing?: MixinAccountConfig["mixpay"]): NonNullable<MixinAccountConfig["mixpay"]> {
+  return {
+    enabled: existing?.enabled ?? false,
+    apiBaseUrl: existing?.apiBaseUrl,
+    payeeId: existing?.payeeId,
+    defaultQuoteAssetId: existing?.defaultQuoteAssetId,
+    defaultSettlementAssetId: existing?.defaultSettlementAssetId,
+    expireMinutes: existing?.expireMinutes ?? 15,
+    pollIntervalSec: existing?.pollIntervalSec ?? 30,
+    allowedCreators: existing?.allowedCreators ?? [],
+    notifyOnPending: existing?.notifyOnPending ?? false,
+    notifyOnPaidLess: existing?.notifyOnPaidLess ?? true,
+  };
+}
+
+async function promptAllowFrom(params: {
+  cfg: OpenClawConfig;
+  prompter: WizardPrompter;
+  accountId?: string;
+}): Promise<OpenClawConfig> {
+  const accountId = params.accountId ?? DEFAULT_ACCOUNT_ID;
+  const current = getAccountConfig(params.cfg, accountId).allowFrom ?? [];
+  await params.prompter.note(
+    [
+      "Enter Mixin UUID values separated by commas or new lines.",
+      "Example: 12345678-1234-1234-1234-123456789abc",
+      "Leave blank if you want to keep pairing-only access.",
+    ].join("\n"),
+    "Mixin allowFrom",
+  );
+  const raw = await params.prompter.text({
+    message: "Allowed Mixin UUIDs",
+    placeholder: "uuid-one, uuid-two",
+    initialValue: current.join(", ") || undefined,
+    validate: (value) => (String(value ?? "").trim() ? undefined : "Required"),
+  });
+  const allowFrom = mergeAllowFrom(current, String(raw));
+  return updateMixinAccountConfig(params.cfg, accountId, { allowFrom });
+}
+
+async function promptAccountConfig(params: {
+  cfg: OpenClawConfig;
+  prompter: WizardPrompter;
+  accountId: string;
+}): Promise<OpenClawConfig> {
+  const resolved = resolveAccount(params.cfg, params.accountId);
+  const current = getAccountConfig(params.cfg, params.accountId);
+  let next = params.cfg;
+
+  const appId = String(
+    await params.prompter.text({
+      message: "Mixin appId",
+      initialValue: resolved.appId ?? undefined,
+      validate: (value) => (String(value ?? "").trim() ? undefined : "Required"),
+    }),
+  ).trim();
+
+  const sessionId = String(
+    await params.prompter.text({
+      message: "Mixin sessionId",
+      initialValue: resolved.sessionId ?? undefined,
+      validate: (value) => (String(value ?? "").trim() ? undefined : "Required"),
+    }),
+  ).trim();
+
+  const serverPublicKey = String(
+    await params.prompter.text({
+      message: "Mixin serverPublicKey",
+      initialValue: resolved.serverPublicKey ?? undefined,
+      validate: (value) => (String(value ?? "").trim() ? undefined : "Required"),
+    }),
+  ).trim();
+
+  const sessionPrivateKey = String(
+    await params.prompter.text({
+      message: "Mixin sessionPrivateKey",
+      initialValue: resolved.sessionPrivateKey ?? undefined,
+      validate: (value) => (String(value ?? "").trim() ? undefined : "Required"),
+    }),
+  ).trim();
+
+  next = updateMixinAccountConfig(next, params.accountId, {
+    enabled: true,
+    appId,
+    sessionId,
+    serverPublicKey,
+    sessionPrivateKey,
+  });
+
+  const dmPolicy = await params.prompter.select<MixinDmPolicy>({
+    message: "DM policy",
+    initialValue: normalizeDmPolicy(current.dmPolicy),
+    options: [
+      { value: "pairing", label: "Pairing", hint: "Accept DMs after pairing approval" },
+      { value: "allowlist", label: "Allowlist", hint: "Only accept DMs from allowFrom" },
+      { value: "open", label: "Open", hint: "Accept DMs without an allowlist" },
+      { value: "disabled", label: "Disabled", hint: "Disable DMs for this account" },
+    ],
+  });
+  next = setRootDmPolicy(next, dmPolicy);
+  next = updateMixinAccountConfig(next, params.accountId, {
+    dmPolicy,
+  });
+
+  if (dmPolicy === "allowlist") {
+    next = await promptAllowFrom({ cfg: next, prompter: params.prompter, accountId: params.accountId });
+  }
+
+  const groupPolicy = await params.prompter.select<MixinGroupPolicy>({
+    message: "Group policy",
+    initialValue: normalizeGroupPolicy(current.groupPolicy),
+    options: [
+      { value: "open", label: "Open", hint: "Allow all configured group chats" },
+      { value: "allowlist", label: "Allowlist", hint: "Only accept listed group chats" },
+      { value: "disabled", label: "Disabled", hint: "Disable group access" },
+    ],
+  });
+  next = updateMixinAccountConfig(next, params.accountId, {
+    groupPolicy,
+  });
+
+  const addGroupAllowFrom = groupPolicy === "allowlist"
+    ? await params.prompter.confirm({
+        message: "Add initial group allowFrom entries now?",
+        initialValue: true,
+      })
+    : false;
+  if (addGroupAllowFrom) {
+    const groupAllowFrom = String(
+      await params.prompter.text({
+        message: "Group allowFrom",
+        placeholder: "conversation-id-one, conversation-id-two",
+        validate: (value) => (String(value ?? "").trim() ? undefined : "Required"),
+      }),
+    )
+      .split(/[\n,;]+/g)
+      .map((entry) => entry.trim())
+      .filter(Boolean);
+    next = updateMixinAccountConfig(next, params.accountId, {
+      groupAllowFrom,
+    });
+  }
+
+  const mixpayEnabled = await params.prompter.confirm({
+    message: "Enable MixPay for this account?",
+    initialValue: Boolean(current.mixpay?.enabled),
+  });
+  if (mixpayEnabled) {
+    next = updateMixinAccountConfig(next, params.accountId, {
+      mixpay: {
+        ...defaultMixpayConfig(current.mixpay),
+        enabled: true,
+      },
+    });
+  }
+
+  return next;
+}
+
+const dmPolicy: ChannelOnboardingDmPolicy = {
+  label: "Mixin",
+  channel,
+  policyKey: "channels.mixin.dmPolicy",
+  allowFromKey: "channels.mixin.allowFrom",
+  getCurrent: (cfg) => normalizeDmPolicy((cfg.channels?.mixin as { dmPolicy?: unknown } | undefined)?.dmPolicy),
+  setPolicy: (cfg, policy) => setRootDmPolicy(cfg, policy as DmPolicy),
+  promptAllowFrom,
+};
+
+export const mixinOnboardingAdapter: ChannelOnboardingAdapter = {
+  channel,
+  getStatus: async ({ cfg }) => {
+    const accountIds = listAccountIds(cfg);
+    const configured = accountIds.some((accountId) => resolveAccount(cfg, accountId).configured);
+    return {
+      channel,
+      configured,
+      statusLines: [
+        `Mixin: ${configured ? "configured" : "needs credentials"}`,
+        `Accounts: ${accountIds.length}`,
+      ],
+      selectionHint: configured ? "configured" : "Blaze WebSocket Mixin bridge",
+      quickstartScore: configured ? 1 : 4,
+    };
+  },
+  configure: async ({ cfg, prompter, accountOverrides, shouldPromptAccountIds }) => {
+    await promptAccountGuide(prompter);
+
+    const mixinOverride = accountOverrides.mixin?.trim();
+    const defaultAccountId = resolveDefaultAccountId(cfg);
+    let accountId = mixinOverride || defaultAccountId;
+    if (shouldPromptAccountIds && !mixinOverride) {
+      accountId = await promptAccountId({
+        cfg,
+        prompter,
+        label: "Mixin",
+        currentId: accountId,
+        listAccountIds,
+        defaultAccountId,
+      });
+    }
+
+    const next = await promptAccountConfig({ cfg, prompter, accountId });
+    await prompter.outro(
+      [
+        `Configured account: ${accountId}`,
+        "Restart the Gateway after saving the config.",
+        "Use /mixin-status to verify the connection.",
+      ].join("\n"),
+    );
+
+    return {
+      cfg: next,
+      accountId,
+    };
+  },
+  dmPolicy,
+};