@m1heng-clawd/feishu 0.1.17 → 0.1.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m1heng-clawd/feishu",
-  "version": "0.1.17",
+  "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";
 
 /**
@@ -10,7 +10,11 @@ function listConfiguredAccountIds(cfg: ClawdbotConfig): string[] {
   if (!accounts || typeof accounts !== "object") {
     return [];
   }
-  return Object.keys(accounts).filter(Boolean);
+  return [...new Set(
+    Object.keys(accounts)
+      .filter((accountId) => accountId.trim())
+      .map((accountId) => normalizeAccountId(accountId)),
+  )];
 }
 
 /**
@@ -38,17 +42,35 @@ export function resolveDefaultFeishuAccountId(cfg: ClawdbotConfig): string {
 }
 
 /**
- * Get the raw account-specific config.
+ * Resolve the configured account key for a normalized account id.
+ * Preserves the original config key casing so write paths can avoid shadow entries.
  */
-function resolveAccountConfig(
+export function resolveConfiguredFeishuAccountKey(
   cfg: ClawdbotConfig,
   accountId: string,
-): FeishuAccountConfig | undefined {
+): string | undefined {
   const accounts = (cfg.channels?.feishu as FeishuConfig)?.accounts;
   if (!accounts || typeof accounts !== "object") {
     return undefined;
   }
-  return accounts[accountId];
+  if (Object.prototype.hasOwnProperty.call(accounts, accountId)) {
+    return accountId;
+  }
+  const normalizedId = normalizeAccountId(accountId);
+  return Object.keys(accounts).find((key) => normalizeAccountId(key) === normalizedId);
+}
+
+/**
+ * Get the raw account-specific config.
+ * Preserves mixed-case config keys by resolving through the normalized account id.
+ */
+function resolveAccountConfig(
+  cfg: ClawdbotConfig,
+  accountId: string,
+): FeishuAccountConfig | undefined {
+  const accounts = (cfg.channels?.feishu as FeishuConfig)?.accounts;
+  const matchedKey = resolveConfiguredFeishuAccountKey(cfg, accountId);
+  return matchedKey && accounts ? accounts[matchedKey] : undefined;
 }
 
 /**

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";
@@ -94,6 +94,7 @@ const senderNameCache = new Map<string, { name: string; expireAt: number }>();
 // Key: appId or "default", Value: timestamp of last notification
 const permissionErrorNotifiedAt = new Map<string, number>();
 const PERMISSION_ERROR_COOLDOWN_MS = 5 * 60 * 1000; // 5 minutes
+const DEFAULT_MAX_MESSAGE_AGE_MS = 300_000; // 5 minutes
 
 type SenderNameResult = {
   name?: string;
@@ -918,13 +919,20 @@ export async function handleFeishuMessage(params: {
     return;
   }
 
-  let ctx = parseFeishuMessageEvent(event, botOpenId);
-
   // Parse message create_time (Feishu uses millisecond epoch string).
   const messageCreateTimeMs = event.message.create_time
     ? parseInt(event.message.create_time, 10)
     : undefined;
 
+  // Discard stale messages (e.g. replayed after gateway restart).
+  const maxAgeMs = feishuCfg.maxMessageAgeMs ?? DEFAULT_MAX_MESSAGE_AGE_MS;
+  if (messageCreateTimeMs && Date.now() - messageCreateTimeMs > maxAgeMs) {
+    log(`feishu[${account.accountId}]: discarding stale message ${messageId} (age: ${Math.round((Date.now() - messageCreateTimeMs) / 1000)}s, max: ${maxAgeMs / 1000}s)`);
+    return;
+  }
+
+  let ctx = parseFeishuMessageEvent(event, botOpenId);
+
   const messageType = event.message.message_type;
   const isForwardedInbound = isForwardedMessageType(messageType);
   const forwardedDispatchKey = getForwardedKey({
@@ -1304,9 +1312,12 @@ export async function handleFeishuMessage(params: {
       }
     }
 
-    // In group chats, the session is scoped to the group, but the *speaker* is the sender.
-    // Using a group-scoped From causes the agent to treat different users as the same person.
-    const feishuFrom = `feishu:${ctx.senderOpenId}`;
+    // In group chats, From must be group-scoped so the core's resolveGroupSessionKey can
+    // detect group context and route replies back to the group — not to a user's DM session.
+    // We include senderOpenId to preserve per-speaker identity within the group.
+    const feishuFrom = isGroup
+      ? `feishu:${ctx.chatId}:${ctx.senderOpenId}`
+      : `feishu:${ctx.senderOpenId}`;
     const feishuTo = isGroup ? `chat:${ctx.chatId}` : `user:${ctx.senderOpenId}`;
 
     // Resolve peer ID for session routing

package/src/channel.ts

@@ -1,12 +1,15 @@
 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,
   resolveFeishuAccount,
   resolveFeishuCredentials,
   listFeishuAccountIds,
   resolveDefaultFeishuAccountId,
 } from "./accounts.js";
+import { monitorFeishuProvider } from "./monitor.js";
 import { feishuOutbound } from "./outbound.js";
 import { probeFeishu } from "./probe.js";
 import { resolveFeishuGroupToolPolicy } from "./policy.js";
@@ -18,7 +21,6 @@ import {
   listFeishuDirectoryPeersLive,
   listFeishuDirectoryGroupsLive,
 } from "./directory.js";
-import { feishuOnboardingAdapter } from "./onboarding.js";
 
 const meta = {
   id: "feishu",
@@ -129,7 +131,6 @@ export const feishuPlugin: ChannelPlugin<ResolvedFeishuAccount> = {
     resolveAccount: (cfg, accountId) => resolveFeishuAccount({ cfg, accountId }),
     defaultAccountId: (cfg) => resolveDefaultFeishuAccountId(cfg),
     setAccountEnabled: ({ cfg, accountId, enabled }) => {
-      const account = resolveFeishuAccount({ cfg, accountId });
       const isDefault = accountId === DEFAULT_ACCOUNT_ID;
       
       if (isDefault) {
@@ -148,6 +149,7 @@ export const feishuPlugin: ChannelPlugin<ResolvedFeishuAccount> = {
       
       // For named accounts, set enabled in accounts[accountId]
       const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
+      const accountKey = resolveConfiguredFeishuAccountKey(cfg, accountId) ?? accountId;
       return {
         ...cfg,
         channels: {
@@ -156,8 +158,8 @@ export const feishuPlugin: ChannelPlugin<ResolvedFeishuAccount> = {
             ...feishuCfg,
             accounts: {
               ...feishuCfg?.accounts,
-              [accountId]: {
-                ...feishuCfg?.accounts?.[accountId],
+              [accountKey]: {
+                ...feishuCfg?.accounts?.[accountKey],
                 enabled,
               },
             },
@@ -184,7 +186,8 @@ export const feishuPlugin: ChannelPlugin<ResolvedFeishuAccount> = {
       // Delete specific account from accounts
       const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
       const accounts = { ...feishuCfg?.accounts };
-      delete accounts[accountId];
+      const accountKey = resolveConfiguredFeishuAccountKey(cfg, accountId) ?? accountId;
+      delete accounts[accountKey];
       
       return {
         ...cfg,
@@ -247,6 +250,7 @@ export const feishuPlugin: ChannelPlugin<ResolvedFeishuAccount> = {
       }
       
       const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
+      const accountKey = resolveConfiguredFeishuAccountKey(cfg, accountId) ?? accountId;
       return {
         ...cfg,
         channels: {
@@ -255,8 +259,8 @@ export const feishuPlugin: ChannelPlugin<ResolvedFeishuAccount> = {
             ...feishuCfg,
             accounts: {
               ...feishuCfg?.accounts,
-              [accountId]: {
-                ...feishuCfg?.accounts?.[accountId],
+              [accountKey]: {
+                ...feishuCfg?.accounts?.[accountKey],
                 enabled: true,
               },
             },
@@ -265,7 +269,7 @@ export const feishuPlugin: ChannelPlugin<ResolvedFeishuAccount> = {
       };
     },
   },
-  onboarding: feishuOnboardingAdapter,
+  setupWizard: feishuSetupWizardWithAccounts,
   messaging: {
     normalizeTarget: normalizeFeishuTarget,
     targetResolver: {
@@ -324,7 +328,6 @@ export const feishuPlugin: ChannelPlugin<ResolvedFeishuAccount> = {
   },
   gateway: {
     startAccount: async (ctx) => {
-      const { monitorFeishuProvider } = await import("./monitor.js");
       const account = resolveFeishuAccount({ cfg: ctx.cfg, accountId: ctx.accountId });
       const port = account.config?.webhookPort ?? null;
       ctx.setStatus({ accountId: ctx.accountId, port });

package/src/config-schema.ts

@@ -1,3 +1,4 @@
+import { normalizeAccountId } from "./sdk-compat.js";
 import { z } from "zod";
 export { z };
 
@@ -157,6 +158,7 @@ export const FeishuAccountConfigSchema = z
     mediaMaxMb: z.number().positive().optional(),
     mediaLocalRoots: z.array(z.string()).optional(),
     heartbeat: ChannelHeartbeatVisibilitySchema,
+    maxMessageAgeMs: z.number().positive().optional(),
     renderMode: RenderModeSchema,
     streaming: StreamingModeSchema,
     tools: FeishuToolsConfigSchema,
@@ -196,6 +198,7 @@ export const FeishuConfigSchema = z
     mediaMaxMb: z.number().positive().optional(),
     mediaLocalRoots: z.array(z.string()).optional(),
     heartbeat: ChannelHeartbeatVisibilitySchema,
+    maxMessageAgeMs: z.number().positive().optional(),
     renderMode: RenderModeSchema, // raw = plain text (default), card = interactive card with markdown
     streaming: StreamingModeSchema,
     tools: FeishuToolsConfigSchema,
@@ -206,6 +209,23 @@ export const FeishuConfigSchema = z
   })
   .strict()
   .superRefine((value, ctx) => {
+    const normalizedAccountIds = new Map<string, string>();
+    for (const accountId of Object.keys(value.accounts ?? {})) {
+      const normalizedAccountId = normalizeAccountId(accountId);
+      const previousAccountId = normalizedAccountIds.get(normalizedAccountId);
+      if (previousAccountId && previousAccountId !== accountId) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ["accounts", accountId],
+          message:
+            `channels.feishu.accounts contains duplicate account ids after normalization: ` +
+            `"${previousAccountId}" and "${accountId}" both normalize to "${normalizedAccountId}"`,
+        });
+        continue;
+      }
+      normalizedAccountIds.set(normalizedAccountId, accountId);
+    }
+
     if (value.dmPolicy === "open") {
       const allowFrom = value.allowFrom ?? [];
       const hasWildcard = allowFrom.some((entry) => String(entry).trim() === "*");

package/src/media.ts

@@ -514,7 +514,14 @@ export async function sendMediaFeishu(params: {
       ...(mergedLocalRoots.length > 0 ? { localRoots: mergedLocalRoots } : {}),
     });
     buffer = loaded.buffer;
-    name = fileName ?? loaded.fileName ?? "file";
+    const loadedFileName = loaded.fileName ?? "file";
+    let decoded: string;
+    try {
+      decoded = decodeURIComponent(loadedFileName);
+    } catch {
+      decoded = loadedFileName;
+    }
+    name = fileName ?? decoded;
     contentType = loaded.contentType;
   } else {
     throw new Error("Either mediaUrl or mediaBuffer must be provided");

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/text/markdown-links.ts

@@ -91,8 +91,23 @@ function normalizeNonCodeSegments(text: string): string {
     .join("");
 }
 
+function normalizeCodeBlockFences(block: string): string {
+  const lines = block.split("\n");
+  return lines
+    .map((line) => {
+      // Fix opening and closing fences: remove leading whitespace
+      if (line.match(/^\s*```/)) {
+        return line.replace(/^\s+/, "");
+      }
+      return line;
+    })
+    .join("\n");
+}
+
 export function normalizeFeishuMarkdownLinks(text: string): string {
-  if (!text || (!text.includes("http://") && !text.includes("https://"))) {
+  if (!text) return text;
+  text = normalizeCodeBlockFences(text);
+  if (!text.includes("http://") && !text.includes("https://")) {
     return text;
   }
 

package/src/onboarding.ts

@@ -1,449 +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,
-  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 existingAccount = feishuCfg?.accounts?.[normalizedAccountId];
-  return {
-    ...cfg,
-    channels: {
-      ...cfg.channels,
-      feishu: {
-        ...feishuCfg,
-        enabled: true,
-        accounts: {
-          ...feishuCfg?.accounts,
-          [normalizedAccountId]: {
-            ...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 },
-    },
-  }),
-};