@poolzin/pool-bot 2026.2.17 → 2026.2.19

package/extensions/discord/src/channel.js

@@ -0,0 +1,366 @@
+import { applyAccountNameToChannelSection, buildChannelConfigSchema, collectDiscordAuditChannelIds, collectDiscordStatusIssues, DEFAULT_ACCOUNT_ID, deleteAccountFromConfigSection, discordOnboardingAdapter, DiscordConfigSchema, formatPairingApproveHint, getChatChannelMeta, listDiscordAccountIds, listDiscordDirectoryGroupsFromConfig, listDiscordDirectoryPeersFromConfig, looksLikeDiscordTargetId, migrateBaseNameToDefaultAccount, normalizeAccountId, normalizeDiscordMessagingTarget, PAIRING_APPROVED_MESSAGE, resolveDiscordAccount, resolveDefaultDiscordAccountId, resolveDiscordGroupRequireMention, resolveDiscordGroupToolPolicy, setAccountEnabledInConfigSection, } from "poolbot/plugin-sdk";
+import { getDiscordRuntime } from "./runtime.js";
+const meta = getChatChannelMeta("discord");
+const discordMessageActions = {
+    listActions: (ctx) => getDiscordRuntime().channel.discord.messageActions.listActions(ctx),
+    extractToolSend: (ctx) => getDiscordRuntime().channel.discord.messageActions.extractToolSend(ctx),
+    handleAction: async (ctx) => await getDiscordRuntime().channel.discord.messageActions.handleAction(ctx),
+};
+export const discordPlugin = {
+    id: "discord",
+    meta: {
+        ...meta,
+    },
+    onboarding: discordOnboardingAdapter,
+    pairing: {
+        idLabel: "discordUserId",
+        normalizeAllowEntry: (entry) => entry.replace(/^(discord|user):/i, ""),
+        notifyApproval: async ({ id }) => {
+            await getDiscordRuntime().channel.discord.sendMessageDiscord(`user:${id}`, PAIRING_APPROVED_MESSAGE);
+        },
+    },
+    capabilities: {
+        chatTypes: ["direct", "channel", "thread"],
+        polls: true,
+        reactions: true,
+        threads: true,
+        media: true,
+        nativeCommands: true,
+    },
+    streaming: {
+        blockStreamingCoalesceDefaults: { minChars: 1500, idleMs: 1000 },
+    },
+    reload: { configPrefixes: ["channels.discord"] },
+    configSchema: buildChannelConfigSchema(DiscordConfigSchema),
+    config: {
+        listAccountIds: (cfg) => listDiscordAccountIds(cfg),
+        resolveAccount: (cfg, accountId) => resolveDiscordAccount({ cfg, accountId }),
+        defaultAccountId: (cfg) => resolveDefaultDiscordAccountId(cfg),
+        setAccountEnabled: ({ cfg, accountId, enabled }) => setAccountEnabledInConfigSection({
+            cfg,
+            sectionKey: "discord",
+            accountId,
+            enabled,
+            allowTopLevel: true,
+        }),
+        deleteAccount: ({ cfg, accountId }) => deleteAccountFromConfigSection({
+            cfg,
+            sectionKey: "discord",
+            accountId,
+            clearBaseFields: ["token", "name"],
+        }),
+        isConfigured: (account) => Boolean(account.token?.trim()),
+        describeAccount: (account) => ({
+            accountId: account.accountId,
+            name: account.name,
+            enabled: account.enabled,
+            configured: Boolean(account.token?.trim()),
+            tokenSource: account.tokenSource,
+        }),
+        resolveAllowFrom: ({ cfg, accountId }) => (resolveDiscordAccount({ cfg, accountId }).config.dm?.allowFrom ?? []).map((entry) => String(entry)),
+        formatAllowFrom: ({ allowFrom }) => allowFrom
+            .map((entry) => String(entry).trim())
+            .filter(Boolean)
+            .map((entry) => entry.toLowerCase()),
+    },
+    security: {
+        resolveDmPolicy: ({ cfg, accountId, account }) => {
+            const resolvedAccountId = accountId ?? account.accountId ?? DEFAULT_ACCOUNT_ID;
+            const useAccountPath = Boolean(cfg.channels?.discord?.accounts?.[resolvedAccountId]);
+            const allowFromPath = useAccountPath
+                ? `channels.discord.accounts.${resolvedAccountId}.dm.`
+                : "channels.discord.dm.";
+            return {
+                policy: account.config.dm?.policy ?? "pairing",
+                allowFrom: account.config.dm?.allowFrom ?? [],
+                allowFromPath,
+                approveHint: formatPairingApproveHint("discord"),
+                normalizeEntry: (raw) => raw.replace(/^(discord|user):/i, "").replace(/^<@!?(\d+)>$/, "$1"),
+            };
+        },
+        collectWarnings: ({ account, cfg }) => {
+            const warnings = [];
+            const defaultGroupPolicy = cfg.channels?.defaults?.groupPolicy;
+            const groupPolicy = account.config.groupPolicy ?? defaultGroupPolicy ?? "open";
+            const guildEntries = account.config.guilds ?? {};
+            const guildsConfigured = Object.keys(guildEntries).length > 0;
+            const channelAllowlistConfigured = guildsConfigured;
+            if (groupPolicy === "open") {
+                if (channelAllowlistConfigured) {
+                    warnings.push(`- Discord guilds: groupPolicy="open" allows any channel not explicitly denied to trigger (mention-gated). Set channels.discord.groupPolicy="allowlist" and configure channels.discord.guilds.<id>.channels.`);
+                }
+                else {
+                    warnings.push(`- Discord guilds: groupPolicy="open" with no guild/channel allowlist; any channel can trigger (mention-gated). Set channels.discord.groupPolicy="allowlist" and configure channels.discord.guilds.<id>.channels.`);
+                }
+            }
+            return warnings;
+        },
+    },
+    groups: {
+        resolveRequireMention: resolveDiscordGroupRequireMention,
+        resolveToolPolicy: resolveDiscordGroupToolPolicy,
+    },
+    mentions: {
+        stripPatterns: () => ["<@!?\\d+>"],
+    },
+    threading: {
+        resolveReplyToMode: ({ cfg }) => cfg.channels?.discord?.replyToMode ?? "off",
+    },
+    messaging: {
+        normalizeTarget: normalizeDiscordMessagingTarget,
+        targetResolver: {
+            looksLikeId: looksLikeDiscordTargetId,
+            hint: "<channelId|user:ID|channel:ID>",
+        },
+    },
+    directory: {
+        self: async () => null,
+        listPeers: async (params) => listDiscordDirectoryPeersFromConfig(params),
+        listGroups: async (params) => listDiscordDirectoryGroupsFromConfig(params),
+        listPeersLive: async (params) => getDiscordRuntime().channel.discord.listDirectoryPeersLive(params),
+        listGroupsLive: async (params) => getDiscordRuntime().channel.discord.listDirectoryGroupsLive(params),
+    },
+    resolver: {
+        resolveTargets: async ({ cfg, accountId, inputs, kind }) => {
+            const account = resolveDiscordAccount({ cfg, accountId });
+            const token = account.token?.trim();
+            if (!token) {
+                return inputs.map((input) => ({
+                    input,
+                    resolved: false,
+                    note: "missing Discord token",
+                }));
+            }
+            if (kind === "group") {
+                const resolved = await getDiscordRuntime().channel.discord.resolveChannelAllowlist({
+                    token,
+                    entries: inputs,
+                });
+                return resolved.map((entry) => ({
+                    input: entry.input,
+                    resolved: entry.resolved,
+                    id: entry.channelId ?? entry.guildId,
+                    name: entry.channelName ??
+                        entry.guildName ??
+                        (entry.guildId && !entry.channelId ? entry.guildId : undefined),
+                    note: entry.note,
+                }));
+            }
+            const resolved = await getDiscordRuntime().channel.discord.resolveUserAllowlist({
+                token,
+                entries: inputs,
+            });
+            return resolved.map((entry) => ({
+                input: entry.input,
+                resolved: entry.resolved,
+                id: entry.id,
+                name: entry.name,
+                note: entry.note,
+            }));
+        },
+    },
+    actions: discordMessageActions,
+    setup: {
+        resolveAccountId: ({ accountId }) => normalizeAccountId(accountId),
+        applyAccountName: ({ cfg, accountId, name }) => applyAccountNameToChannelSection({
+            cfg,
+            channelKey: "discord",
+            accountId,
+            name,
+        }),
+        validateInput: ({ accountId, input }) => {
+            if (input.useEnv && accountId !== DEFAULT_ACCOUNT_ID) {
+                return "DISCORD_BOT_TOKEN can only be used for the default account.";
+            }
+            if (!input.useEnv && !input.token) {
+                return "Discord requires token (or --use-env).";
+            }
+            return null;
+        },
+        applyAccountConfig: ({ cfg, accountId, input }) => {
+            const namedConfig = applyAccountNameToChannelSection({
+                cfg,
+                channelKey: "discord",
+                accountId,
+                name: input.name,
+            });
+            const next = accountId !== DEFAULT_ACCOUNT_ID
+                ? migrateBaseNameToDefaultAccount({
+                    cfg: namedConfig,
+                    channelKey: "discord",
+                })
+                : namedConfig;
+            if (accountId === DEFAULT_ACCOUNT_ID) {
+                return {
+                    ...next,
+                    channels: {
+                        ...next.channels,
+                        discord: {
+                            ...next.channels?.discord,
+                            enabled: true,
+                            ...(input.useEnv ? {} : input.token ? { token: input.token } : {}),
+                        },
+                    },
+                };
+            }
+            return {
+                ...next,
+                channels: {
+                    ...next.channels,
+                    discord: {
+                        ...next.channels?.discord,
+                        enabled: true,
+                        accounts: {
+                            ...next.channels?.discord?.accounts,
+                            [accountId]: {
+                                ...next.channels?.discord?.accounts?.[accountId],
+                                enabled: true,
+                                ...(input.token ? { token: input.token } : {}),
+                            },
+                        },
+                    },
+                },
+            };
+        },
+    },
+    outbound: {
+        deliveryMode: "direct",
+        chunker: null,
+        textChunkLimit: 2000,
+        pollMaxOptions: 10,
+        sendText: async ({ to, text, accountId, deps, replyToId }) => {
+            const send = deps?.sendDiscord ?? getDiscordRuntime().channel.discord.sendMessageDiscord;
+            const result = await send(to, text, {
+                verbose: false,
+                replyTo: replyToId ?? undefined,
+                accountId: accountId ?? undefined,
+            });
+            return { channel: "discord", ...result };
+        },
+        sendMedia: async ({ to, text, mediaUrl, accountId, deps, replyToId }) => {
+            const send = deps?.sendDiscord ?? getDiscordRuntime().channel.discord.sendMessageDiscord;
+            const result = await send(to, text, {
+                verbose: false,
+                mediaUrl,
+                replyTo: replyToId ?? undefined,
+                accountId: accountId ?? undefined,
+            });
+            return { channel: "discord", ...result };
+        },
+        sendPoll: async ({ to, poll, accountId }) => await getDiscordRuntime().channel.discord.sendPollDiscord(to, poll, {
+            accountId: accountId ?? undefined,
+        }),
+    },
+    status: {
+        defaultRuntime: {
+            accountId: DEFAULT_ACCOUNT_ID,
+            running: false,
+            lastStartAt: null,
+            lastStopAt: null,
+            lastError: null,
+        },
+        collectStatusIssues: collectDiscordStatusIssues,
+        buildChannelSummary: ({ snapshot }) => ({
+            configured: snapshot.configured ?? false,
+            tokenSource: snapshot.tokenSource ?? "none",
+            running: snapshot.running ?? false,
+            lastStartAt: snapshot.lastStartAt ?? null,
+            lastStopAt: snapshot.lastStopAt ?? null,
+            lastError: snapshot.lastError ?? null,
+            probe: snapshot.probe,
+            lastProbeAt: snapshot.lastProbeAt ?? null,
+        }),
+        probeAccount: async ({ account, timeoutMs }) => getDiscordRuntime().channel.discord.probeDiscord(account.token, timeoutMs, {
+            includeApplication: true,
+        }),
+        auditAccount: async ({ account, timeoutMs, cfg }) => {
+            const { channelIds, unresolvedChannels } = collectDiscordAuditChannelIds({
+                cfg,
+                accountId: account.accountId,
+            });
+            if (!channelIds.length && unresolvedChannels === 0)
+                return undefined;
+            const botToken = account.token?.trim();
+            if (!botToken) {
+                return {
+                    ok: unresolvedChannels === 0,
+                    checkedChannels: 0,
+                    unresolvedChannels,
+                    channels: [],
+                    elapsedMs: 0,
+                };
+            }
+            const audit = await getDiscordRuntime().channel.discord.auditChannelPermissions({
+                token: botToken,
+                accountId: account.accountId,
+                channelIds,
+                timeoutMs,
+            });
+            return { ...audit, unresolvedChannels };
+        },
+        buildAccountSnapshot: ({ account, runtime, probe, audit }) => {
+            const configured = Boolean(account.token?.trim());
+            const app = runtime?.application ?? probe?.application;
+            const bot = runtime?.bot ?? probe?.bot;
+            return {
+                accountId: account.accountId,
+                name: account.name,
+                enabled: account.enabled,
+                configured,
+                tokenSource: account.tokenSource,
+                running: runtime?.running ?? false,
+                lastStartAt: runtime?.lastStartAt ?? null,
+                lastStopAt: runtime?.lastStopAt ?? null,
+                lastError: runtime?.lastError ?? null,
+                application: app ?? undefined,
+                bot: bot ?? undefined,
+                probe,
+                audit,
+                lastInboundAt: runtime?.lastInboundAt ?? null,
+                lastOutboundAt: runtime?.lastOutboundAt ?? null,
+            };
+        },
+    },
+    gateway: {
+        startAccount: async (ctx) => {
+            const account = ctx.account;
+            const token = account.token.trim();
+            let discordBotLabel = "";
+            try {
+                const probe = await getDiscordRuntime().channel.discord.probeDiscord(token, 2500, {
+                    includeApplication: true,
+                });
+                const username = probe.ok ? probe.bot?.username?.trim() : null;
+                if (username)
+                    discordBotLabel = ` (@${username})`;
+                ctx.setStatus({
+                    accountId: account.accountId,
+                    bot: probe.bot,
+                    application: probe.application,
+                });
+                const messageContent = probe.application?.intents?.messageContent;
+                if (messageContent === "disabled") {
+                    ctx.log?.warn(`[${account.accountId}] Discord Message Content Intent is disabled; bot may not respond to channel messages. Enable it in Discord Dev Portal (Bot → Privileged Gateway Intents) or require mentions.`);
+                }
+                else if (messageContent === "limited") {
+                    ctx.log?.info(`[${account.accountId}] Discord Message Content Intent is limited; bots under 100 servers can use it without verification.`);
+                }
+            }
+            catch (err) {
+                if (getDiscordRuntime().logging.shouldLogVerbose()) {
+                    ctx.log?.debug?.(`[${account.accountId}] bot probe failed: ${String(err)}`);
+                }
+            }
+            ctx.log?.info(`[${account.accountId}] starting provider${discordBotLabel}`);
+            return getDiscordRuntime().channel.discord.monitorDiscordProvider({
+                token,
+                accountId: account.accountId,
+                config: ctx.cfg,
+                runtime: ctx.runtime,
+                abortSignal: ctx.abortSignal,
+                mediaMaxMb: account.config.mediaMaxMb,
+                historyLimit: account.config.historyLimit,
+            });
+        },
+    },
+};

package/extensions/discord/src/runtime.js

@@ -0,0 +1,10 @@
+let runtime = null;
+export function setDiscordRuntime(next) {
+    runtime = next;
+}
+export function getDiscordRuntime() {
+    if (!runtime) {
+        throw new Error("Discord runtime not initialized");
+    }
+    return runtime;
+}

package/extensions/feishu/index.ts

@@ -0,0 +1,63 @@
+import type { PoolBotPluginApi } from "poolbot/plugin-sdk";
+import { emptyPluginConfigSchema } from "poolbot/plugin-sdk";
+import { registerFeishuBitableTools } from "./src/bitable.js";
+import { feishuPlugin } from "./src/channel.js";
+import { registerFeishuDocTools } from "./src/docx.js";
+import { registerFeishuDriveTools } from "./src/drive.js";
+import { registerFeishuPermTools } from "./src/perm.js";
+import { setFeishuRuntime } from "./src/runtime.js";
+import { registerFeishuWikiTools } from "./src/wiki.js";
+
+export { monitorFeishuProvider } from "./src/monitor.js";
+export {
+  sendMessageFeishu,
+  sendCardFeishu,
+  updateCardFeishu,
+  editMessageFeishu,
+  getMessageFeishu,
+} from "./src/send.js";
+export {
+  uploadImageFeishu,
+  uploadFileFeishu,
+  sendImageFeishu,
+  sendFileFeishu,
+  sendMediaFeishu,
+} from "./src/media.js";
+export { probeFeishu } from "./src/probe.js";
+export {
+  addReactionFeishu,
+  removeReactionFeishu,
+  listReactionsFeishu,
+  FeishuEmoji,
+} from "./src/reactions.js";
+export {
+  extractMentionTargets,
+  extractMessageBody,
+  isMentionForwardRequest,
+  formatMentionForText,
+  formatMentionForCard,
+  formatMentionAllForText,
+  formatMentionAllForCard,
+  buildMentionedMessage,
+  buildMentionedCardContent,
+  type MentionTarget,
+} from "./src/mention.js";
+export { feishuPlugin } from "./src/channel.js";
+
+const plugin = {
+  id: "feishu",
+  name: "Feishu",
+  description: "Feishu/Lark channel plugin",
+  configSchema: emptyPluginConfigSchema(),
+  register(api: PoolBotPluginApi) {
+    setFeishuRuntime(api.runtime);
+    api.registerChannel({ plugin: feishuPlugin });
+    registerFeishuDocTools(api);
+    registerFeishuWikiTools(api);
+    registerFeishuDriveTools(api);
+    registerFeishuPermTools(api);
+    registerFeishuBitableTools(api);
+  },
+};
+
+export default plugin;

package/extensions/feishu/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@poolzin/feishu",
+  "version": "2026.2.18",
+  "description": "Pool Bot Feishu/Lark channel plugin (community maintained by @m1heng)",
+  "type": "module",
+  "dependencies": {
+    "@larksuiteoapi/node-sdk": "^1.59.0",
+    "@sinclair/typebox": "0.34.48",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "poolbot": "workspace:*"
+  },
+  "poolbot": {
+    "extensions": [
+      "./index.ts"
+    ],
+    "channel": {
+      "id": "feishu",
+      "label": "Feishu",
+      "selectionLabel": "Feishu/Lark (飞书)",
+      "docsPath": "/channels/feishu",
+      "docsLabel": "feishu",
+      "blurb": "飞书/Lark enterprise messaging with doc/wiki/drive tools.",
+      "aliases": [
+        "lark"
+      ],
+      "order": 35,
+      "quickstartAllowFrom": true
+    },
+    "install": {
+      "npmSpec": "@poolzin/feishu",
+      "localPath": "extensions/feishu",
+      "defaultChoice": "npm"
+    }
+  }
+}

package/extensions/feishu/poolbot.plugin.json

@@ -0,0 +1,10 @@
+{
+  "id": "feishu",
+  "channels": ["feishu"],
+  "skills": ["./skills"],
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  }
+}

package/extensions/feishu/skills/feishu-doc/SKILL.md

@@ -0,0 +1,105 @@
+---
+name: feishu-doc
+description: |
+  Feishu document read/write operations. Activate when user mentions Feishu docs, cloud docs, or docx links.
+---
+
+# Feishu Document Tool
+
+Single tool `feishu_doc` with action parameter for all document operations.
+
+## Token Extraction
+
+From URL `https://xxx.feishu.cn/docx/ABC123def` → `doc_token` = `ABC123def`
+
+## Actions
+
+### Read Document
+
+```json
+{ "action": "read", "doc_token": "ABC123def" }
+```
+
+Returns: title, plain text content, block statistics. Check `hint` field - if present, structured content (tables, images) exists that requires `list_blocks`.
+
+### Write Document (Replace All)
+
+```json
+{ "action": "write", "doc_token": "ABC123def", "content": "# Title\n\nMarkdown content..." }
+```
+
+Replaces entire document with markdown content. Supports: headings, lists, code blocks, quotes, links, images (`![](url)` auto-uploaded), bold/italic/strikethrough.
+
+**Limitation:** Markdown tables are NOT supported.
+
+### Append Content
+
+```json
+{ "action": "append", "doc_token": "ABC123def", "content": "Additional content" }
+```
+
+Appends markdown to end of document.
+
+### Create Document
+
+```json
+{ "action": "create", "title": "New Document" }
+```
+
+With folder:
+
+```json
+{ "action": "create", "title": "New Document", "folder_token": "fldcnXXX" }
+```
+
+### List Blocks
+
+```json
+{ "action": "list_blocks", "doc_token": "ABC123def" }
+```
+
+Returns full block data including tables, images. Use this to read structured content.
+
+### Get Single Block
+
+```json
+{ "action": "get_block", "doc_token": "ABC123def", "block_id": "doxcnXXX" }
+```
+
+### Update Block Text
+
+```json
+{
+  "action": "update_block",
+  "doc_token": "ABC123def",
+  "block_id": "doxcnXXX",
+  "content": "New text"
+}
+```
+
+### Delete Block
+
+```json
+{ "action": "delete_block", "doc_token": "ABC123def", "block_id": "doxcnXXX" }
+```
+
+## Reading Workflow
+
+1. Start with `action: "read"` - get plain text + statistics
+2. Check `block_types` in response for Table, Image, Code, etc.
+3. If structured content exists, use `action: "list_blocks"` for full data
+
+## Configuration
+
+```yaml
+channels:
+  feishu:
+    tools:
+      doc: true # default: true
+```
+
+**Note:** `feishu_wiki` depends on this tool - wiki page content is read/written via `feishu_doc`.
+
+## Permissions
+
+Required: `docx:document`, `docx:document:readonly`, `docx:document.block:convert`, `drive:drive`