@m1heng-clawd/feishu 0.1.18 → 0.1.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m1heng-clawd/feishu",
-  "version": "0.1.18",
+  "version": "0.1.19",
   "type": "module",
   "description": "OpenClaw Feishu/Lark channel plugin",
   "scripts": {
@@ -63,7 +63,7 @@
   "devDependencies": {
     "@types/node": "^25.0.10",
     "@vitest/coverage-v8": "^2.1.8",
-    "openclaw": "2026.3.1",
+    "openclaw": "2026.3.24",
     "tsx": "^4.21.0",
     "typescript": "^5.7.0",
     "vitest": "^2.1.8"

package/src/accounts.ts

@@ -1,5 +1,5 @@
 import type { ClawdbotConfig } from "openclaw/plugin-sdk";
-import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "./sdk-compat.js";
 import type { FeishuConfig, FeishuAccountConfig, FeishuDomain, ResolvedFeishuAccount } from "./types.js";
 
 /**

package/src/bot.ts

@@ -1,12 +1,12 @@
 import type { ClawdbotConfig, RuntimeEnv } from "openclaw/plugin-sdk";
+import type { HistoryEntry } from "openclaw/plugin-sdk/feishu";
 import {
   buildPendingHistoryContextFromMap,
   recordPendingHistoryEntryIfEnabled,
   clearHistoryEntriesIfEnabled,
   DEFAULT_GROUP_HISTORY_LIMIT,
   resolveMentionGatingWithBypass,
-  type HistoryEntry,
-} from "openclaw/plugin-sdk";
+} from "./sdk-compat.js";
 import type { FeishuConfig, FeishuMessageContext, FeishuMediaInfo, ResolvedFeishuAccount } from "./types.js";
 import { getFeishuRuntime } from "./runtime.js";
 import { createFeishuClient } from "./client.js";

package/src/channel.ts

@@ -1,5 +1,6 @@
 import type { ChannelPlugin, ClawdbotConfig } from "openclaw/plugin-sdk";
-import { DEFAULT_ACCOUNT_ID, normalizeAccountId, PAIRING_APPROVED_MESSAGE } from "openclaw/plugin-sdk";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId, PAIRING_APPROVED_MESSAGE } from "./sdk-compat.js";
+import { feishuSetupWizardWithAccounts } from "./setup-wizard.js";
 import type { ResolvedFeishuAccount, FeishuConfig } from "./types.js";
 import {
   resolveConfiguredFeishuAccountKey,
@@ -20,7 +21,6 @@ import {
   listFeishuDirectoryPeersLive,
   listFeishuDirectoryGroupsLive,
 } from "./directory.js";
-import { feishuOnboardingAdapter } from "./onboarding.js";
 
 const meta = {
   id: "feishu",
@@ -269,7 +269,7 @@ export const feishuPlugin: ChannelPlugin<ResolvedFeishuAccount> = {
       };
     },
   },
-  onboarding: feishuOnboardingAdapter,
+  setupWizard: feishuSetupWizardWithAccounts,
   messaging: {
     normalizeTarget: normalizeFeishuTarget,
     targetResolver: {

package/src/config-schema.ts

@@ -1,4 +1,4 @@
-import { normalizeAccountId } from "openclaw/plugin-sdk";
+import { normalizeAccountId } from "./sdk-compat.js";
 import { z } from "zod";
 export { z };
 

package/src/monitor.ts

@@ -3,9 +3,9 @@ import * as http from "http";
 import {
   type ClawdbotConfig,
   type RuntimeEnv,
-  type HistoryEntry,
-  installRequestBodyLimitGuard,
 } from "openclaw/plugin-sdk";
+import type { HistoryEntry } from "openclaw/plugin-sdk/feishu";
+import { installRequestBodyLimitGuard } from "./sdk-compat.js";
 import type { ResolvedFeishuAccount } from "./types.js";
 import { createFeishuWSClient, createEventDispatcher } from "./client.js";
 import { resolveFeishuAccount, listEnabledFeishuAccounts } from "./accounts.js";

package/src/outbound.ts

@@ -1,4 +1,4 @@
-import type { ChannelOutboundAdapter } from "openclaw/plugin-sdk";
+import type { ChannelOutboundAdapter } from "openclaw/plugin-sdk/feishu";
 import { getFeishuRuntime } from "./runtime.js";
 import { sendMessageFeishu } from "./send.js";
 import { sendMediaFeishu } from "./media.js";

package/src/policy.ts

@@ -1,4 +1,4 @@
-import type { ChannelGroupContext, GroupToolPolicyConfig } from "openclaw/plugin-sdk";
+import type { ChannelGroupContext, GroupToolPolicyConfig } from "openclaw/plugin-sdk/feishu";
 import type { FeishuConfig, FeishuGroupConfig } from "./types.js";
 
 export type FeishuGroupCommandMentionBypass = "never" | "single_bot" | "always";

package/src/reply-dispatcher.ts

@@ -1,11 +1,13 @@
 import {
-  createReplyPrefixContext,
-  createTypingCallbacks,
-  logTypingFailure,
   type ClawdbotConfig,
   type ReplyPayload,
   type RuntimeEnv,
 } from "openclaw/plugin-sdk";
+import {
+  createReplyPrefixContext,
+  createTypingCallbacks,
+  logTypingFailure,
+} from "./sdk-compat.js";
 import { resolveFeishuAccount } from "./accounts.js";
 import { createFeishuClient } from "./client.js";
 import { buildMentionedCardContent, type MentionTarget } from "./mention.js";

package/src/sdk-compat.ts

@@ -0,0 +1,13 @@
+export { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-id";
+export {
+  PAIRING_APPROVED_MESSAGE,
+  buildPendingHistoryContextFromMap,
+  clearHistoryEntriesIfEnabled,
+  createReplyPrefixContext,
+  DEFAULT_GROUP_HISTORY_LIMIT,
+  installRequestBodyLimitGuard,
+  logTypingFailure,
+  recordPendingHistoryEntryIfEnabled,
+} from "openclaw/plugin-sdk/feishu";
+export { resolveMentionGatingWithBypass } from "openclaw/plugin-sdk/channel-inbound";
+export { createTypingCallbacks, promptAccountId } from "openclaw/plugin-sdk/matrix";

package/src/setup-wizard.ts

@@ -0,0 +1,171 @@
+import type { ClawdbotConfig, ChannelPlugin } from "openclaw/plugin-sdk";
+import type { ChannelSetupWizard } from "openclaw/plugin-sdk/setup";
+import { feishuSetupWizard } from "openclaw/plugin-sdk/feishu";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId, promptAccountId } from "./sdk-compat.js";
+import {
+  listFeishuAccountIds,
+  resolveConfiguredFeishuAccountKey,
+  resolveDefaultFeishuAccountId,
+  resolveFeishuAccount,
+  resolveFeishuCredentials,
+} from "./accounts.js";
+import { probeFeishu } from "./probe.js";
+import type { FeishuConfig } from "./types.js";
+
+function patchFeishuAccountConfig(
+  cfg: ClawdbotConfig,
+  accountId: string,
+  patch: Record<string, unknown>,
+): ClawdbotConfig {
+  const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
+
+  if (accountId === DEFAULT_ACCOUNT_ID) {
+    return {
+      ...cfg,
+      channels: {
+        ...cfg.channels,
+        feishu: { ...feishuCfg, ...patch },
+      },
+    };
+  }
+
+  const accountKey = resolveConfiguredFeishuAccountKey(cfg, accountId) ?? accountId;
+  return {
+    ...cfg,
+    channels: {
+      ...cfg.channels,
+      feishu: {
+        ...feishuCfg,
+        accounts: {
+          ...feishuCfg?.accounts,
+          [accountKey]: { ...feishuCfg?.accounts?.[accountKey], ...patch },
+        },
+      },
+    },
+  };
+}
+
+const accountScopedFinalize: NonNullable<ChannelSetupWizard["finalize"]> = async ({
+  cfg,
+  accountId,
+  prompter,
+}) => {
+  const account = resolveFeishuAccount({ cfg, accountId });
+  const resolved = resolveFeishuCredentials(account.config);
+  const hasConfigCreds = Boolean(account.config?.appId?.trim() && account.config?.appSecret?.trim());
+  const accountLabel = accountId === DEFAULT_ACCOUNT_ID ? "default" : accountId;
+
+  let next = cfg;
+  let appId: string | null = null;
+  let appSecret: string | null = null;
+
+  if (!resolved) {
+    await prompter.note(
+      [
+        "1) Go to Feishu Open Platform (open.feishu.cn)",
+        "2) Create a self-built app",
+        "3) Get App ID and App Secret from Credentials page",
+        "4) Enable required permissions: im:message, im:chat, contact:user.base:readonly",
+        "5) Publish the app or add it to a test group",
+      ].join("\n"),
+      `Feishu credentials (${accountLabel})`,
+    );
+  }
+
+  if (hasConfigCreds) {
+    const keep = await prompter.confirm({
+      message: `Feishu credentials already configured for "${accountLabel}". Keep them?`,
+      initialValue: true,
+    });
+    if (!keep) {
+      appId = String(await prompter.text({
+        message: `Enter Feishu App ID for "${accountLabel}"`,
+        validate: (v) => (v?.trim() ? undefined : "Required"),
+      })).trim();
+      appSecret = String(await prompter.text({
+        message: `Enter Feishu App Secret for "${accountLabel}"`,
+        validate: (v) => (v?.trim() ? undefined : "Required"),
+      })).trim();
+    }
+  } else {
+    appId = String(await prompter.text({
+      message: `Enter Feishu App ID for "${accountLabel}"`,
+      initialValue: account.config?.appId?.trim() || undefined,
+      validate: (v) => (v?.trim() ? undefined : "Required"),
+    })).trim();
+    appSecret = String(await prompter.text({
+      message: `Enter Feishu App Secret for "${accountLabel}"`,
+      validate: (v) => (v?.trim() ? undefined : "Required"),
+    })).trim();
+  }
+
+  if (appId && appSecret) {
+    next = patchFeishuAccountConfig(next, accountId, { enabled: true, appId, appSecret });
+    try {
+      const testAccount = resolveFeishuAccount({ cfg: next, accountId });
+      const probe = await probeFeishu(testAccount);
+      if (probe.ok) {
+        await prompter.note(
+          `Connected as ${probe.botName ?? probe.botOpenId ?? "bot"}`,
+          `Feishu connection test (${accountLabel})`,
+        );
+      } else {
+        await prompter.note(
+          `Connection failed: ${probe.error ?? "unknown error"}`,
+          `Feishu connection test (${accountLabel})`,
+        );
+      }
+    } catch (err) {
+      await prompter.note(`Connection test failed: ${String(err)}`, `Feishu connection test (${accountLabel})`);
+    }
+  } else {
+    next = patchFeishuAccountConfig(next, accountId, { enabled: true });
+  }
+
+  const currentDomain = resolveFeishuAccount({ cfg: next, accountId }).config?.domain ?? "feishu";
+  const domain = await prompter.select({
+    message: `Which Feishu domain? (${accountLabel})`,
+    options: [
+      { value: "feishu", label: "Feishu (feishu.cn) - China" },
+      { value: "lark", label: "Lark (larksuite.com) - International" },
+    ],
+    initialValue: currentDomain,
+  });
+  if (domain) {
+    next = patchFeishuAccountConfig(next, accountId, { domain });
+  }
+
+  return { cfg: next };
+};
+
+export const feishuSetupWizardWithAccounts: NonNullable<ChannelPlugin["setupWizard"]> = {
+  ...feishuSetupWizard,
+
+  resolveShouldPromptAccountIds: ({ cfg }) => listFeishuAccountIds(cfg).length > 1,
+
+  resolveAccountIdForConfigure: async ({
+    cfg,
+    prompter,
+    accountOverride,
+    shouldPromptAccountIds,
+  }) => {
+    if (accountOverride?.trim()) return normalizeAccountId(accountOverride);
+    const defaultId = resolveDefaultFeishuAccountId(cfg);
+    if (!shouldPromptAccountIds) return defaultId;
+    return promptAccountId({
+      cfg,
+      prompter,
+      label: "Feishu",
+      currentId: defaultId,
+      listAccountIds: listFeishuAccountIds,
+      defaultAccountId: defaultId,
+    });
+  },
+
+  finalize: async (params) => {
+    if (params.accountId === DEFAULT_ACCOUNT_ID) {
+      return feishuSetupWizard.finalize!(params);
+    }
+    return accountScopedFinalize(params);
+  },
+};

package/src/onboarding.ts

@@ -1,451 +0,0 @@
-import type {
-  ChannelOnboardingAdapter,
-  ChannelOnboardingDmPolicy,
-  ClawdbotConfig,
-  DmPolicy,
-  WizardPrompter,
-} from "openclaw/plugin-sdk";
-import {
-  addWildcardAllowFrom,
-  DEFAULT_ACCOUNT_ID,
-  formatDocsLink,
-  normalizeAccountId,
-  promptAccountId,
-} from "openclaw/plugin-sdk";
-
-import {
-  listFeishuAccountIds,
-  resolveConfiguredFeishuAccountKey,
-  resolveDefaultFeishuAccountId,
-  resolveFeishuAccount,
-  resolveFeishuCredentials,
-} from "./accounts.js";
-import { probeFeishu } from "./probe.js";
-import type { FeishuConfig } from "./types.js";
-
-const channel = "feishu" as const;
-let onboardingDmPolicyAccountId: string | undefined;
-
-function resolveOnboardingAccountId(cfg: ClawdbotConfig, accountId?: string | null): string {
-  const raw = accountId?.trim();
-  if (raw) {
-    return normalizeAccountId(raw);
-  }
-  return resolveDefaultFeishuAccountId(cfg);
-}
-
-function resolveDmPolicyAccountId(cfg: ClawdbotConfig, accountId?: string | null): string {
-  return resolveOnboardingAccountId(cfg, accountId ?? onboardingDmPolicyAccountId);
-}
-
-function upsertFeishuAccountConfig(
-  cfg: ClawdbotConfig,
-  accountId: string,
-  patch: Partial<FeishuConfig>,
-): ClawdbotConfig {
-  const normalizedAccountId = normalizeAccountId(accountId);
-  const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
-
-  if (normalizedAccountId === DEFAULT_ACCOUNT_ID) {
-    return {
-      ...cfg,
-      channels: {
-        ...cfg.channels,
-        feishu: {
-          ...feishuCfg,
-          ...patch,
-        },
-      },
-    };
-  }
-
-  const accountKey = resolveConfiguredFeishuAccountKey(cfg, normalizedAccountId) ?? normalizedAccountId;
-  const existingAccount = feishuCfg?.accounts?.[accountKey];
-  return {
-    ...cfg,
-    channels: {
-      ...cfg.channels,
-      feishu: {
-        ...feishuCfg,
-        enabled: true,
-        accounts: {
-          ...feishuCfg?.accounts,
-          [accountKey]: {
-            ...existingAccount,
-            enabled: existingAccount?.enabled ?? true,
-            ...patch,
-          },
-        },
-      },
-    },
-  };
-}
-
-function setFeishuDmPolicy(
-  cfg: ClawdbotConfig,
-  dmPolicy: DmPolicy,
-  accountId?: string,
-): ClawdbotConfig {
-  const resolvedAccountId = resolveDmPolicyAccountId(cfg, accountId);
-  const account = resolveFeishuAccount({ cfg, accountId: resolvedAccountId });
-  // Feishu channel config does not support "disabled" as a dmPolicy value.
-  const effectiveDmPolicy = dmPolicy === "disabled" ? "pairing" : dmPolicy;
-  const allowFrom =
-    effectiveDmPolicy === "open"
-      ? addWildcardAllowFrom(account.config.allowFrom)?.map((entry) => String(entry))
-      : undefined;
-  return upsertFeishuAccountConfig(cfg, resolvedAccountId, {
-    dmPolicy: effectiveDmPolicy,
-    ...(allowFrom ? { allowFrom } : {}),
-  });
-}
-
-function setFeishuAllowFrom(cfg: ClawdbotConfig, allowFrom: string[], accountId?: string): ClawdbotConfig {
-  const resolvedAccountId = resolveOnboardingAccountId(cfg, accountId);
-  return upsertFeishuAccountConfig(cfg, resolvedAccountId, { allowFrom });
-}
-
-function parseAllowFromInput(raw: string): string[] {
-  return raw
-    .split(/[\n,;]+/g)
-    .map((entry) => entry.trim())
-    .filter(Boolean);
-}
-
-async function promptFeishuAllowFrom(params: {
-  cfg: ClawdbotConfig;
-  prompter: WizardPrompter;
-  accountId?: string;
-}): Promise<ClawdbotConfig> {
-  const accountId = resolveDmPolicyAccountId(params.cfg, params.accountId);
-  const existing = resolveFeishuAccount({ cfg: params.cfg, accountId }).config.allowFrom ?? [];
-  const accountLabel = accountId === DEFAULT_ACCOUNT_ID ? "default" : accountId;
-  await params.prompter.note(
-    [
-      `Account: ${accountLabel}`,
-      "Allowlist Feishu DMs by open_id or user_id.",
-      "You can find user open_id in Feishu admin console or via API.",
-      "Examples:",
-      "- ou_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
-      "- on_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
-    ].join("\n"),
-    "Feishu allowlist",
-  );
-
-  while (true) {
-    const entry = await params.prompter.text({
-      message: "Feishu allowFrom (user open_ids)",
-      placeholder: "ou_xxxxx, ou_yyyyy",
-      initialValue: existing[0] ? String(existing[0]) : undefined,
-      validate: (value) => (String(value ?? "").trim() ? undefined : "Required"),
-    });
-    const parts = parseAllowFromInput(String(entry));
-    if (parts.length === 0) {
-      await params.prompter.note("Enter at least one user.", "Feishu allowlist");
-      continue;
-    }
-
-    const unique = [
-      ...new Set([...existing.map((v) => String(v).trim()).filter(Boolean), ...parts]),
-    ];
-    return setFeishuAllowFrom(params.cfg, unique, accountId);
-  }
-}
-
-async function noteFeishuCredentialHelp(prompter: WizardPrompter): Promise<void> {
-  await prompter.note(
-    [
-      "1) Go to Feishu Open Platform (open.feishu.cn)",
-      "2) Create a self-built app",
-      "3) Get App ID and App Secret from Credentials page",
-      "4) Enable required permissions: im:message, im:chat, contact:user.base:readonly",
-      "5) Publish the app or add it to a test group",
-      "Tip: you can also set FEISHU_APP_ID / FEISHU_APP_SECRET env vars.",
-      `Docs: ${formatDocsLink("/channels/feishu", "feishu")}`,
-    ].join("\n"),
-    "Feishu credentials",
-  );
-}
-
-function setFeishuGroupPolicy(
-  cfg: ClawdbotConfig,
-  groupPolicy: "open" | "allowlist" | "disabled",
-  accountId?: string,
-): ClawdbotConfig {
-  const resolvedAccountId = resolveOnboardingAccountId(cfg, accountId);
-  return upsertFeishuAccountConfig(cfg, resolvedAccountId, { enabled: true, groupPolicy });
-}
-
-function setFeishuGroupAllowFrom(
-  cfg: ClawdbotConfig,
-  groupAllowFrom: string[],
-  accountId?: string,
-): ClawdbotConfig {
-  const resolvedAccountId = resolveOnboardingAccountId(cfg, accountId);
-  return upsertFeishuAccountConfig(cfg, resolvedAccountId, { groupAllowFrom });
-}
-
-function setFeishuDomain(cfg: ClawdbotConfig, domain: "feishu" | "lark", accountId?: string): ClawdbotConfig {
-  const resolvedAccountId = resolveOnboardingAccountId(cfg, accountId);
-  return upsertFeishuAccountConfig(cfg, resolvedAccountId, { domain });
-}
-
-const dmPolicy: ChannelOnboardingDmPolicy = {
-  label: "Feishu",
-  channel,
-  policyKey: "channels.feishu.dmPolicy",
-  allowFromKey: "channels.feishu.allowFrom",
-  getCurrent: (cfg) => {
-    const accountId = resolveDmPolicyAccountId(cfg);
-    return resolveFeishuAccount({ cfg, accountId }).config.dmPolicy ?? "pairing";
-  },
-  setPolicy: (cfg, policy) => setFeishuDmPolicy(cfg, policy, onboardingDmPolicyAccountId),
-  promptAllowFrom: promptFeishuAllowFrom,
-};
-
-export const feishuOnboardingAdapter: ChannelOnboardingAdapter = {
-  channel,
-  getStatus: async ({ cfg, accountOverrides }) => {
-    const override = accountOverrides?.feishu?.trim();
-    const accountIds = override
-      ? [resolveOnboardingAccountId(cfg, override)]
-      : listFeishuAccountIds(cfg);
-    const accounts = accountIds.map((accountId) => resolveFeishuAccount({ cfg, accountId }));
-    const configuredAccounts = accounts.filter((account) => account.configured);
-    const configured = configuredAccounts.length > 0;
-
-    // Try to probe if configured
-    let probeResult = null;
-    if (configuredAccounts[0]) {
-      try {
-        probeResult = await probeFeishu(configuredAccounts[0]);
-      } catch {
-        // Ignore probe errors
-      }
-    }
-
-    const statusLines: string[] = [];
-    if (!configured) {
-      statusLines.push("Feishu: needs app credentials");
-    } else if (probeResult?.ok) {
-      const probeAccountId = configuredAccounts[0]?.accountId ?? DEFAULT_ACCOUNT_ID;
-      const accountNote = probeAccountId === DEFAULT_ACCOUNT_ID ? "" : ` [${probeAccountId}]`;
-      statusLines.push(
-        `Feishu${accountNote}: connected as ${probeResult.botName ?? probeResult.botOpenId ?? "bot"}`,
-      );
-      if (!override && configuredAccounts.length > 1) {
-        statusLines.push(`Feishu: ${configuredAccounts.length} account(s) configured`);
-      }
-    } else if (!override && configuredAccounts.length > 1) {
-      statusLines.push(`Feishu: configured (${configuredAccounts.length} account(s), connection not verified)`);
-    } else {
-      statusLines.push("Feishu: configured (connection not verified)");
-    }
-
-    return {
-      channel,
-      configured,
-      statusLines,
-      selectionHint: configured ? "configured" : "needs app creds",
-      quickstartScore: configured ? 2 : 0,
-    };
-  },
-
-  configure: async ({ cfg, prompter, accountOverrides, shouldPromptAccountIds }) => {
-    const feishuOverride = accountOverrides?.feishu?.trim();
-    const defaultFeishuAccountId = resolveDefaultFeishuAccountId(cfg);
-    let feishuAccountId = feishuOverride
-      ? normalizeAccountId(feishuOverride)
-      : defaultFeishuAccountId;
-    if (shouldPromptAccountIds && !feishuOverride) {
-      feishuAccountId = await promptAccountId({
-        cfg,
-        prompter,
-        label: "Feishu",
-        currentId: feishuAccountId,
-        listAccountIds: listFeishuAccountIds,
-        defaultAccountId: defaultFeishuAccountId,
-      });
-    }
-    onboardingDmPolicyAccountId = feishuAccountId;
-    const accountLabel = feishuAccountId === DEFAULT_ACCOUNT_ID ? "default" : feishuAccountId;
-    const currentAccount = resolveFeishuAccount({ cfg, accountId: feishuAccountId });
-    const resolved = resolveFeishuCredentials(currentAccount.config);
-    const hasConfigCreds = Boolean(
-      currentAccount.config.appId?.trim() && currentAccount.config.appSecret?.trim(),
-    );
-    const canUseEnv = Boolean(
-      feishuAccountId === DEFAULT_ACCOUNT_ID &&
-      !hasConfigCreds &&
-        process.env.FEISHU_APP_ID?.trim() &&
-        process.env.FEISHU_APP_SECRET?.trim(),
-    );
-
-    let next = cfg;
-    let appId: string | null = null;
-    let appSecret: string | null = null;
-    const appIdPrompt =
-      feishuAccountId === DEFAULT_ACCOUNT_ID
-        ? "Enter Feishu App ID"
-        : `Enter Feishu App ID for account "${accountLabel}"`;
-    const appSecretPrompt =
-      feishuAccountId === DEFAULT_ACCOUNT_ID
-        ? "Enter Feishu App Secret"
-        : `Enter Feishu App Secret for account "${accountLabel}"`;
-
-    if (!resolved) {
-      await noteFeishuCredentialHelp(prompter);
-    }
-
-    if (canUseEnv) {
-      const keepEnv = await prompter.confirm({
-        message: "FEISHU_APP_ID + FEISHU_APP_SECRET detected. Use env vars?",
-        initialValue: true,
-      });
-      if (keepEnv) {
-        next = upsertFeishuAccountConfig(next, feishuAccountId, { enabled: true });
-      } else {
-        appId = String(
-          await prompter.text({
-            message: appIdPrompt,
-            validate: (value) => (value?.trim() ? undefined : "Required"),
-          }),
-        ).trim();
-        appSecret = String(
-          await prompter.text({
-            message: appSecretPrompt,
-            validate: (value) => (value?.trim() ? undefined : "Required"),
-          }),
-        ).trim();
-      }
-    } else if (hasConfigCreds) {
-      const keep = await prompter.confirm({
-        message: `Feishu credentials already configured for account "${accountLabel}". Keep them?`,
-        initialValue: true,
-      });
-      if (!keep) {
-        appId = String(
-          await prompter.text({
-            message: appIdPrompt,
-            validate: (value) => (value?.trim() ? undefined : "Required"),
-          }),
-        ).trim();
-        appSecret = String(
-          await prompter.text({
-            message: appSecretPrompt,
-            validate: (value) => (value?.trim() ? undefined : "Required"),
-          }),
-        ).trim();
-      }
-    } else {
-      appId = String(
-        await prompter.text({
-          message: appIdPrompt,
-          validate: (value) => (value?.trim() ? undefined : "Required"),
-        }),
-      ).trim();
-      appSecret = String(
-        await prompter.text({
-          message: appSecretPrompt,
-          validate: (value) => (value?.trim() ? undefined : "Required"),
-        }),
-      ).trim();
-    }
-
-    if (appId && appSecret) {
-      next = upsertFeishuAccountConfig(next, feishuAccountId, {
-        enabled: true,
-        appId,
-        appSecret,
-      });
-
-      // Test connection
-      const testAccount = resolveFeishuAccount({ cfg: next, accountId: feishuAccountId });
-      try {
-        const probe = await probeFeishu(testAccount);
-        if (probe.ok) {
-          await prompter.note(
-            `Connected as ${probe.botName ?? probe.botOpenId ?? "bot"}`,
-            `Feishu connection test (${accountLabel})`,
-          );
-        } else {
-          await prompter.note(
-            `Connection failed: ${probe.error ?? "unknown error"}`,
-            `Feishu connection test (${accountLabel})`,
-          );
-        }
-      } catch (err) {
-        await prompter.note(
-          `Connection test failed: ${String(err)}`,
-          `Feishu connection test (${accountLabel})`,
-        );
-      }
-    }
-
-    // Domain selection
-    const currentDomain = resolveFeishuAccount({ cfg: next, accountId: feishuAccountId }).config.domain ?? "feishu";
-    const domain = await prompter.select({
-      message: "Which Feishu domain?",
-      options: [
-        { value: "feishu", label: "Feishu (feishu.cn) - China" },
-        { value: "lark", label: "Lark (larksuite.com) - International" },
-      ],
-      initialValue: currentDomain,
-    });
-    if (domain) {
-      next = setFeishuDomain(next, domain as "feishu" | "lark", feishuAccountId);
-    }
-
-    // Group policy
-    const groupPolicyAccount = resolveFeishuAccount({ cfg: next, accountId: feishuAccountId });
-    const groupPolicy = await prompter.select({
-      message: "Group chat policy",
-      options: [
-        { value: "allowlist", label: "Allowlist - only respond in specific groups" },
-        { value: "open", label: "Open - respond in all groups (requires mention)" },
-        { value: "disabled", label: "Disabled - don't respond in groups" },
-      ],
-      initialValue: groupPolicyAccount.config.groupPolicy ?? "allowlist",
-    });
-    if (groupPolicy) {
-      next = setFeishuGroupPolicy(
-        next,
-        groupPolicy as "open" | "allowlist" | "disabled",
-        feishuAccountId,
-      );
-    }
-
-    // Group allowlist if needed
-    if (groupPolicy === "allowlist") {
-      const existing =
-        resolveFeishuAccount({ cfg: next, accountId: feishuAccountId }).config.groupAllowFrom ?? [];
-      const entry = await prompter.text({
-        message: "Group chat allowlist (chat_ids)",
-        placeholder: "oc_xxxxx, oc_yyyyy",
-        initialValue: existing.length > 0 ? existing.map(String).join(", ") : undefined,
-      });
-      if (entry) {
-        const parts = parseAllowFromInput(String(entry));
-        if (parts.length > 0) {
-          next = setFeishuGroupAllowFrom(next, parts, feishuAccountId);
-        }
-      }
-    }
-
-    return { cfg: next, accountId: feishuAccountId };
-  },
-
-  dmPolicy,
-
-  onAccountRecorded: (accountId) => {
-    onboardingDmPolicyAccountId = normalizeAccountId(accountId);
-  },
-
-  disable: (cfg) => ({
-    ...cfg,
-    channels: {
-      ...cfg.channels,
-      feishu: { ...cfg.channels?.feishu, enabled: false },
-    },
-  }),
-};