@fased/fased 0.1.36 → 0.1.37

package/extensions/feishu/src/channel.ts

@@ -1,359 +0,0 @@
-import type { ChannelMeta, ChannelPlugin, FasedAgentConfig } from "fased/plugin-sdk";
-import {
-  buildBaseChannelStatusSummary,
-  createDefaultChannelRuntimeState,
-  DEFAULT_ACCOUNT_ID,
-  PAIRING_APPROVED_MESSAGE,
-  resolveAllowlistProviderRuntimeGroupPolicy,
-  resolveDefaultGroupPolicy,
-} from "fased/plugin-sdk";
-import {
-  resolveFeishuAccount,
-  resolveFeishuCredentials,
-  listFeishuAccountIds,
-  resolveDefaultFeishuAccountId,
-} from "./accounts.js";
-import {
-  listFeishuDirectoryPeers,
-  listFeishuDirectoryGroups,
-  listFeishuDirectoryPeersLive,
-  listFeishuDirectoryGroupsLive,
-} from "./directory.js";
-import { feishuOnboardingAdapter } from "./onboarding.js";
-import { feishuOutbound } from "./outbound.js";
-import { resolveFeishuGroupToolPolicy } from "./policy.js";
-import { probeFeishu } from "./probe.js";
-import { sendMessageFeishu } from "./send.js";
-import { normalizeFeishuTarget, looksLikeFeishuId, formatFeishuTarget } from "./targets.js";
-import type { ResolvedFeishuAccount, FeishuConfig } from "./types.js";
-
-const meta: ChannelMeta = {
-  id: "feishu",
-  label: "Feishu",
-  selectionLabel: "Feishu/Lark (飞书)",
-  docsPath: "/channels/feishu",
-  docsLabel: "feishu",
-  blurb: "飞书/Lark enterprise messaging.",
-  aliases: ["lark"],
-  order: 70,
-};
-
-export const feishuPlugin: ChannelPlugin<ResolvedFeishuAccount> = {
-  id: "feishu",
-  meta: {
-    ...meta,
-  },
-  pairing: {
-    idLabel: "feishuUserId",
-    normalizeAllowEntry: (entry) => entry.replace(/^(feishu|user|open_id):/i, ""),
-    notifyApproval: async ({ cfg, id }) => {
-      await sendMessageFeishu({
-        cfg,
-        to: id,
-        text: PAIRING_APPROVED_MESSAGE,
-      });
-    },
-  },
-  capabilities: {
-    chatTypes: ["direct", "channel"],
-    polls: false,
-    threads: true,
-    media: true,
-    reactions: true,
-    edit: true,
-    reply: true,
-  },
-  agentPrompt: {
-    messageToolHints: () => [
-      "- Feishu targeting: omit `target` to reply to the current conversation (auto-inferred). Explicit targets: `user:open_id` or `chat:chat_id`.",
-      "- Feishu supports interactive cards for rich messages.",
-    ],
-  },
-  groups: {
-    resolveToolPolicy: resolveFeishuGroupToolPolicy,
-  },
-  reload: { configPrefixes: ["channels.feishu"] },
-  configSchema: {
-    schema: {
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        enabled: { type: "boolean" },
-        appId: { type: "string" },
-        appSecret: { type: "string" },
-        encryptKey: { type: "string" },
-        verificationToken: { type: "string" },
-        domain: {
-          oneOf: [
-            { type: "string", enum: ["feishu", "lark"] },
-            { type: "string", format: "uri", pattern: "^https://" },
-          ],
-        },
-        connectionMode: { type: "string", enum: ["websocket", "webhook"] },
-        webhookPath: { type: "string" },
-        webhookHost: { type: "string" },
-        webhookPort: { type: "integer", minimum: 1 },
-        dmPolicy: { type: "string", enum: ["open", "pairing", "allowlist"] },
-        allowFrom: { type: "array", items: { oneOf: [{ type: "string" }, { type: "number" }] } },
-        groupPolicy: { type: "string", enum: ["open", "allowlist", "disabled"] },
-        groupAllowFrom: {
-          type: "array",
-          items: { oneOf: [{ type: "string" }, { type: "number" }] },
-        },
-        requireMention: { type: "boolean" },
-        topicSessionMode: { type: "string", enum: ["disabled", "enabled"] },
-        historyLimit: { type: "integer", minimum: 0 },
-        dmHistoryLimit: { type: "integer", minimum: 0 },
-        textChunkLimit: { type: "integer", minimum: 1 },
-        chunkMode: { type: "string", enum: ["length", "newline"] },
-        mediaMaxMb: { type: "number", minimum: 0 },
-        renderMode: { type: "string", enum: ["auto", "raw", "card"] },
-        accounts: {
-          type: "object",
-          additionalProperties: {
-            type: "object",
-            properties: {
-              enabled: { type: "boolean" },
-              name: { type: "string" },
-              appId: { type: "string" },
-              appSecret: { type: "string" },
-              encryptKey: { type: "string" },
-              verificationToken: { type: "string" },
-              domain: { type: "string", enum: ["feishu", "lark"] },
-              connectionMode: { type: "string", enum: ["websocket", "webhook"] },
-              webhookHost: { type: "string" },
-              webhookPath: { type: "string" },
-              webhookPort: { type: "integer", minimum: 1 },
-            },
-          },
-        },
-      },
-    },
-  },
-  config: {
-    listAccountIds: (cfg) => listFeishuAccountIds(cfg),
-    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) {
-        // For default account, set top-level enabled
-        return {
-          ...cfg,
-          channels: {
-            ...cfg.channels,
-            feishu: {
-              ...cfg.channels?.feishu,
-              enabled,
-            },
-          },
-        };
-      }
-
-      // For named accounts, set enabled in accounts[accountId]
-      const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
-      return {
-        ...cfg,
-        channels: {
-          ...cfg.channels,
-          feishu: {
-            ...feishuCfg,
-            accounts: {
-              ...feishuCfg?.accounts,
-              [accountId]: {
-                ...feishuCfg?.accounts?.[accountId],
-                enabled,
-              },
-            },
-          },
-        },
-      };
-    },
-    deleteAccount: ({ cfg, accountId }) => {
-      const isDefault = accountId === DEFAULT_ACCOUNT_ID;
-
-      if (isDefault) {
-        // Delete entire feishu config
-        const next = { ...cfg } as FasedAgentConfig;
-        const nextChannels = { ...cfg.channels };
-        delete (nextChannels as Record<string, unknown>).feishu;
-        if (Object.keys(nextChannels).length > 0) {
-          next.channels = nextChannels;
-        } else {
-          delete next.channels;
-        }
-        return next;
-      }
-
-      // Delete specific account from accounts
-      const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
-      const accounts = { ...feishuCfg?.accounts };
-      delete accounts[accountId];
-
-      return {
-        ...cfg,
-        channels: {
-          ...cfg.channels,
-          feishu: {
-            ...feishuCfg,
-            accounts: Object.keys(accounts).length > 0 ? accounts : undefined,
-          },
-        },
-      };
-    },
-    isConfigured: (account) => account.configured,
-    describeAccount: (account) => ({
-      accountId: account.accountId,
-      enabled: account.enabled,
-      configured: account.configured,
-      name: account.name,
-      appId: account.appId,
-      domain: account.domain,
-    }),
-    resolveAllowFrom: ({ cfg, accountId }) => {
-      const account = resolveFeishuAccount({ cfg, accountId });
-      return (account.config?.allowFrom ?? []).map((entry) => String(entry));
-    },
-    formatAllowFrom: ({ allowFrom }) =>
-      allowFrom
-        .map((entry) => String(entry).trim())
-        .filter(Boolean)
-        .map((entry) => entry.toLowerCase()),
-  },
-  security: {
-    collectWarnings: ({ cfg, accountId }) => {
-      const account = resolveFeishuAccount({ cfg, accountId });
-      const feishuCfg = account.config;
-      const defaultGroupPolicy = resolveDefaultGroupPolicy(cfg);
-      const { groupPolicy } = resolveAllowlistProviderRuntimeGroupPolicy({
-        providerConfigPresent: cfg.channels?.feishu !== undefined,
-        groupPolicy: feishuCfg?.groupPolicy,
-        defaultGroupPolicy,
-      });
-      if (groupPolicy !== "open") return [];
-      return [
-        `- Feishu[${account.accountId}] groups: groupPolicy="open" allows any member to trigger (mention-gated). Set channels.feishu.groupPolicy="allowlist" + channels.feishu.groupAllowFrom to restrict senders.`,
-      ];
-    },
-  },
-  setup: {
-    resolveAccountId: () => DEFAULT_ACCOUNT_ID,
-    applyAccountConfig: ({ cfg, accountId }) => {
-      const isDefault = !accountId || accountId === DEFAULT_ACCOUNT_ID;
-
-      if (isDefault) {
-        return {
-          ...cfg,
-          channels: {
-            ...cfg.channels,
-            feishu: {
-              ...cfg.channels?.feishu,
-              enabled: true,
-            },
-          },
-        };
-      }
-
-      const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
-      return {
-        ...cfg,
-        channels: {
-          ...cfg.channels,
-          feishu: {
-            ...feishuCfg,
-            accounts: {
-              ...feishuCfg?.accounts,
-              [accountId]: {
-                ...feishuCfg?.accounts?.[accountId],
-                enabled: true,
-              },
-            },
-          },
-        },
-      };
-    },
-  },
-  onboarding: feishuOnboardingAdapter,
-  messaging: {
-    normalizeTarget: (raw) => normalizeFeishuTarget(raw) ?? undefined,
-    targetResolver: {
-      looksLikeId: looksLikeFeishuId,
-      hint: "<chatId|user:openId|chat:chatId>",
-    },
-  },
-  directory: {
-    self: async () => null,
-    listPeers: async ({ cfg, query, limit, accountId }) =>
-      listFeishuDirectoryPeers({
-        cfg,
-        query: query ?? undefined,
-        limit: limit ?? undefined,
-        accountId: accountId ?? undefined,
-      }),
-    listGroups: async ({ cfg, query, limit, accountId }) =>
-      listFeishuDirectoryGroups({
-        cfg,
-        query: query ?? undefined,
-        limit: limit ?? undefined,
-        accountId: accountId ?? undefined,
-      }),
-    listPeersLive: async ({ cfg, query, limit, accountId }) =>
-      listFeishuDirectoryPeersLive({
-        cfg,
-        query: query ?? undefined,
-        limit: limit ?? undefined,
-        accountId: accountId ?? undefined,
-      }),
-    listGroupsLive: async ({ cfg, query, limit, accountId }) =>
-      listFeishuDirectoryGroupsLive({
-        cfg,
-        query: query ?? undefined,
-        limit: limit ?? undefined,
-        accountId: accountId ?? undefined,
-      }),
-  },
-  outbound: feishuOutbound,
-  status: {
-    defaultRuntime: createDefaultChannelRuntimeState(DEFAULT_ACCOUNT_ID, { port: null }),
-    buildChannelSummary: ({ snapshot }) => ({
-      ...buildBaseChannelStatusSummary(snapshot),
-      port: snapshot.port ?? null,
-      probe: snapshot.probe,
-      lastProbeAt: snapshot.lastProbeAt ?? null,
-    }),
-    probeAccount: async ({ account }) => await probeFeishu(account),
-    buildAccountSnapshot: ({ account, runtime, probe }) => ({
-      accountId: account.accountId,
-      enabled: account.enabled,
-      configured: account.configured,
-      name: account.name,
-      appId: account.appId,
-      domain: account.domain,
-      running: runtime?.running ?? false,
-      lastStartAt: runtime?.lastStartAt ?? null,
-      lastStopAt: runtime?.lastStopAt ?? null,
-      lastError: runtime?.lastError ?? null,
-      port: runtime?.port ?? null,
-      probe,
-    }),
-  },
-  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 });
-      ctx.log?.info(
-        `starting feishu[${ctx.accountId}] (mode: ${account.config?.connectionMode ?? "websocket"})`,
-      );
-      return monitorFeishuProvider({
-        config: ctx.cfg,
-        runtime: ctx.runtime,
-        abortSignal: ctx.abortSignal,
-        accountId: ctx.accountId,
-      });
-    },
-  },
-};

package/extensions/feishu/src/client.ts

@@ -1,118 +0,0 @@
-import * as Lark from "@larksuiteoapi/node-sdk";
-import type { FeishuDomain, ResolvedFeishuAccount } from "./types.js";
-
-// Multi-account client cache
-const clientCache = new Map<
-  string,
-  {
-    client: Lark.Client;
-    config: { appId: string; appSecret: string; domain?: FeishuDomain };
-  }
->();
-
-function resolveDomain(domain: FeishuDomain | undefined): Lark.Domain | string {
-  if (domain === "lark") {
-    return Lark.Domain.Lark;
-  }
-  if (domain === "feishu" || !domain) {
-    return Lark.Domain.Feishu;
-  }
-  return domain.replace(/\/+$/, ""); // Custom URL for private deployment
-}
-
-/**
- * Credentials needed to create a Feishu client.
- * Both FeishuConfig and ResolvedFeishuAccount satisfy this interface.
- */
-export type FeishuClientCredentials = {
-  accountId?: string;
-  appId?: string;
-  appSecret?: string;
-  domain?: FeishuDomain;
-};
-
-/**
- * Create or get a cached Feishu client for an account.
- * Accepts any object with appId, appSecret, and optional domain/accountId.
- */
-export function createFeishuClient(creds: FeishuClientCredentials): Lark.Client {
-  const { accountId = "default", appId, appSecret, domain } = creds;
-
-  if (!appId || !appSecret) {
-    throw new Error(`Feishu credentials not configured for account "${accountId}"`);
-  }
-
-  // Check cache
-  const cached = clientCache.get(accountId);
-  if (
-    cached &&
-    cached.config.appId === appId &&
-    cached.config.appSecret === appSecret &&
-    cached.config.domain === domain
-  ) {
-    return cached.client;
-  }
-
-  // Create new client
-  const client = new Lark.Client({
-    appId,
-    appSecret,
-    appType: Lark.AppType.SelfBuild,
-    domain: resolveDomain(domain),
-  });
-
-  // Cache it
-  clientCache.set(accountId, {
-    client,
-    config: { appId, appSecret, domain },
-  });
-
-  return client;
-}
-
-/**
- * Create a Feishu WebSocket client for an account.
- * Note: WSClient is not cached since each call creates a new connection.
- */
-export function createFeishuWSClient(account: ResolvedFeishuAccount): Lark.WSClient {
-  const { accountId, appId, appSecret, domain } = account;
-
-  if (!appId || !appSecret) {
-    throw new Error(`Feishu credentials not configured for account "${accountId}"`);
-  }
-
-  return new Lark.WSClient({
-    appId,
-    appSecret,
-    domain: resolveDomain(domain),
-    loggerLevel: Lark.LoggerLevel.info,
-  });
-}
-
-/**
- * Create an event dispatcher for an account.
- */
-export function createEventDispatcher(account: ResolvedFeishuAccount): Lark.EventDispatcher {
-  return new Lark.EventDispatcher({
-    encryptKey: account.encryptKey,
-    verificationToken: account.verificationToken,
-  });
-}
-
-/**
- * Get a cached client for an account (if exists).
- */
-export function getFeishuClient(accountId: string): Lark.Client | null {
-  return clientCache.get(accountId)?.client ?? null;
-}
-
-/**
- * Clear client cache for a specific account or all accounts.
- */
-export function clearClientCache(accountId?: string): void {
-  if (accountId) {
-    clientCache.delete(accountId);
-  } else {
-    clientCache.clear();
-  }
-}

package/extensions/feishu/src/config-schema.ts

@@ -1,226 +0,0 @@
-import { z } from "zod";
-export { z };
-
-const DmPolicySchema = z.enum(["open", "pairing", "allowlist"]);
-const GroupPolicySchema = z.enum(["open", "allowlist", "disabled"]);
-const FeishuDomainSchema = z.union([
-  z.enum(["feishu", "lark"]),
-  z.string().url().startsWith("https://"),
-]);
-const FeishuConnectionModeSchema = z.enum(["websocket", "webhook"]);
-
-const ToolPolicySchema = z
-  .object({
-    allow: z.array(z.string()).optional(),
-    deny: z.array(z.string()).optional(),
-  })
-  .strict()
-  .optional();
-
-const DmConfigSchema = z
-  .object({
-    enabled: z.boolean().optional(),
-    systemPrompt: z.string().optional(),
-  })
-  .strict()
-  .optional();
-
-const MarkdownConfigSchema = z
-  .object({
-    mode: z.enum(["native", "escape", "strip"]).optional(),
-    tableMode: z.enum(["native", "ascii", "simple"]).optional(),
-  })
-  .strict()
-  .optional();
-
-// Message render mode: auto (default) = detect markdown, raw = plain text, card = always card
-const RenderModeSchema = z.enum(["auto", "raw", "card"]).optional();
-
-// Streaming card mode: when enabled, card replies use Feishu's Card Kit streaming API
-// for incremental text display with a "Thinking..." placeholder
-const StreamingModeSchema = z.boolean().optional();
-
-const BlockStreamingCoalesceSchema = z
-  .object({
-    enabled: z.boolean().optional(),
-    minDelayMs: z.number().int().positive().optional(),
-    maxDelayMs: z.number().int().positive().optional(),
-  })
-  .strict()
-  .optional();
-
-const ChannelHeartbeatVisibilitySchema = z
-  .object({
-    visibility: z.enum(["visible", "hidden"]).optional(),
-    intervalMs: z.number().int().positive().optional(),
-  })
-  .strict()
-  .optional();
-
-/**
- * Dynamic agent creation configuration.
- * When enabled, a new agent is created for each unique DM user.
- */
-const DynamicAgentCreationSchema = z
-  .object({
-    enabled: z.boolean().optional(),
-    workspaceTemplate: z.string().optional(),
-    agentDirTemplate: z.string().optional(),
-    maxAgents: z.number().int().positive().optional(),
-  })
-  .strict()
-  .optional();
-
-/**
- * Feishu tools configuration.
- * Controls which tool categories are enabled.
- *
- * Dependencies:
- * - wiki requires doc (wiki content is edited via doc tools)
- * - perm can work independently but is typically used with drive
- */
-const FeishuToolsConfigSchema = z
-  .object({
-    doc: z.boolean().optional(), // Document operations (default: true)
-    wiki: z.boolean().optional(), // Knowledge base operations (default: true, requires doc)
-    drive: z.boolean().optional(), // Cloud storage operations (default: true)
-    perm: z.boolean().optional(), // Permission management (default: false, sensitive)
-    scopes: z.boolean().optional(), // App scopes diagnostic (default: true)
-  })
-  .strict()
-  .optional();
-
-/**
- * Topic session isolation mode for group chats.
- * - "disabled" (default): All messages in a group share one session
- * - "enabled": Messages in different topics get separate sessions
- *
- * When enabled, the session key becomes `chat:{chatId}:topic:{rootId}`
- * for messages within a topic thread, allowing isolated conversations.
- */
-const TopicSessionModeSchema = z.enum(["disabled", "enabled"]).optional();
-
-export const FeishuGroupSchema = z
-  .object({
-    requireMention: z.boolean().optional(),
-    tools: ToolPolicySchema,
-    skills: z.array(z.string()).optional(),
-    enabled: z.boolean().optional(),
-    allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
-    systemPrompt: z.string().optional(),
-    topicSessionMode: TopicSessionModeSchema,
-  })
-  .strict();
-
-const FeishuSharedConfigShape = {
-  webhookHost: z.string().optional(),
-  webhookPort: z.number().int().positive().optional(),
-  capabilities: z.array(z.string()).optional(),
-  markdown: MarkdownConfigSchema,
-  configWrites: z.boolean().optional(),
-  dmPolicy: DmPolicySchema.optional(),
-  allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
-  groupPolicy: GroupPolicySchema.optional(),
-  groupAllowFrom: z.array(z.union([z.string(), z.number()])).optional(),
-  requireMention: z.boolean().optional(),
-  groups: z.record(z.string(), FeishuGroupSchema.optional()).optional(),
-  historyLimit: z.number().int().min(0).optional(),
-  dmHistoryLimit: z.number().int().min(0).optional(),
-  dms: z.record(z.string(), DmConfigSchema).optional(),
-  textChunkLimit: z.number().int().positive().optional(),
-  chunkMode: z.enum(["length", "newline"]).optional(),
-  blockStreamingCoalesce: BlockStreamingCoalesceSchema,
-  mediaMaxMb: z.number().positive().optional(),
-  heartbeat: ChannelHeartbeatVisibilitySchema,
-  renderMode: RenderModeSchema,
-  streaming: StreamingModeSchema,
-  tools: FeishuToolsConfigSchema,
-};
-
-/**
- * Per-account configuration.
- * All fields are optional - missing fields inherit from top-level config.
- */
-export const FeishuAccountConfigSchema = z
-  .object({
-    enabled: z.boolean().optional(),
-    name: z.string().optional(), // Display name for this account
-    appId: z.string().optional(),
-    appSecret: z.string().optional(),
-    encryptKey: z.string().optional(),
-    verificationToken: z.string().optional(),
-    domain: FeishuDomainSchema.optional(),
-    connectionMode: FeishuConnectionModeSchema.optional(),
-    webhookPath: z.string().optional(),
-    ...FeishuSharedConfigShape,
-  })
-  .strict();
-
-export const FeishuConfigSchema = z
-  .object({
-    enabled: z.boolean().optional(),
-    // Top-level credentials (backward compatible for single-account mode)
-    appId: z.string().optional(),
-    appSecret: z.string().optional(),
-    encryptKey: z.string().optional(),
-    verificationToken: z.string().optional(),
-    domain: FeishuDomainSchema.optional().default("feishu"),
-    connectionMode: FeishuConnectionModeSchema.optional().default("websocket"),
-    webhookPath: z.string().optional().default("/feishu/events"),
-    ...FeishuSharedConfigShape,
-    dmPolicy: DmPolicySchema.optional().default("pairing"),
-    groupPolicy: GroupPolicySchema.optional().default("allowlist"),
-    requireMention: z.boolean().optional().default(true),
-    topicSessionMode: TopicSessionModeSchema,
-    // Dynamic agent creation for DM users
-    dynamicAgentCreation: DynamicAgentCreationSchema,
-    // Multi-account configuration
-    accounts: z.record(z.string(), FeishuAccountConfigSchema.optional()).optional(),
-  })
-  .strict()
-  .superRefine((value, ctx) => {
-    const defaultConnectionMode = value.connectionMode ?? "websocket";
-    const defaultVerificationToken = value.verificationToken?.trim();
-    if (defaultConnectionMode === "webhook" && !defaultVerificationToken) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        path: ["verificationToken"],
-        message:
-          'channels.feishu.connectionMode="webhook" requires channels.feishu.verificationToken',
-      });
-    }
-
-    for (const [accountId, account] of Object.entries(value.accounts ?? {})) {
-      if (!account) {
-        continue;
-      }
-      const accountConnectionMode = account.connectionMode ?? defaultConnectionMode;
-      if (accountConnectionMode !== "webhook") {
-        continue;
-      }
-      const accountVerificationToken =
-        account.verificationToken?.trim() || defaultVerificationToken;
-      if (!accountVerificationToken) {
-        ctx.addIssue({
-          code: z.ZodIssueCode.custom,
-          path: ["accounts", accountId, "verificationToken"],
-          message:
-            `channels.feishu.accounts.${accountId}.connectionMode="webhook" requires ` +
-            "a verificationToken (account-level or top-level)",
-        });
-      }
-    }
-
-    if (value.dmPolicy === "open") {
-      const allowFrom = value.allowFrom ?? [];
-      const hasWildcard = allowFrom.some((entry) => String(entry).trim() === "*");
-      if (!hasWildcard) {
-        ctx.addIssue({
-          code: z.ZodIssueCode.custom,
-          path: ["allowFrom"],
-          message:
-            'channels.feishu.dmPolicy="open" requires channels.feishu.allowFrom to include "*"',
-        });
-      }
-    }
-  });