@poolzin/pool-bot 2026.2.11 → 2026.2.18

package/extensions/feishu/src/wiki.ts

@@ -0,0 +1,232 @@
+import type * as Lark from "@larksuiteoapi/node-sdk";
+import type { PoolBotPluginApi } from "poolbot/plugin-sdk";
+import { listEnabledFeishuAccounts } from "./accounts.js";
+import { createFeishuClient } from "./client.js";
+import { resolveToolsConfig } from "./tools-config.js";
+import { FeishuWikiSchema, type FeishuWikiParams } from "./wiki-schema.js";
+
+// ============ Helpers ============
+
+function json(data: unknown) {
+  return {
+    content: [{ type: "text" as const, text: JSON.stringify(data, null, 2) }],
+    details: data,
+  };
+}
+
+type ObjType = "doc" | "sheet" | "mindnote" | "bitable" | "file" | "docx" | "slides";
+
+// ============ Actions ============
+
+const WIKI_ACCESS_HINT =
+  "To grant wiki access: Open wiki space → Settings → Members → Add the bot. " +
+  "See: https://open.feishu.cn/document/server-docs/docs/wiki-v2/wiki-qa#a40ad4ca";
+
+async function listSpaces(client: Lark.Client) {
+  const res = await client.wiki.space.list({});
+  if (res.code !== 0) {
+    throw new Error(res.msg);
+  }
+
+  const spaces =
+    res.data?.items?.map((s) => ({
+      space_id: s.space_id,
+      name: s.name,
+      description: s.description,
+      visibility: s.visibility,
+    })) ?? [];
+
+  return {
+    spaces,
+    ...(spaces.length === 0 && { hint: WIKI_ACCESS_HINT }),
+  };
+}
+
+async function listNodes(client: Lark.Client, spaceId: string, parentNodeToken?: string) {
+  const res = await client.wiki.spaceNode.list({
+    path: { space_id: spaceId },
+    params: { parent_node_token: parentNodeToken },
+  });
+  if (res.code !== 0) {
+    throw new Error(res.msg);
+  }
+
+  return {
+    nodes:
+      res.data?.items?.map((n) => ({
+        node_token: n.node_token,
+        obj_token: n.obj_token,
+        obj_type: n.obj_type,
+        title: n.title,
+        has_child: n.has_child,
+      })) ?? [],
+  };
+}
+
+async function getNode(client: Lark.Client, token: string) {
+  const res = await client.wiki.space.getNode({
+    params: { token },
+  });
+  if (res.code !== 0) {
+    throw new Error(res.msg);
+  }
+
+  const node = res.data?.node;
+  return {
+    node_token: node?.node_token,
+    space_id: node?.space_id,
+    obj_token: node?.obj_token,
+    obj_type: node?.obj_type,
+    title: node?.title,
+    parent_node_token: node?.parent_node_token,
+    has_child: node?.has_child,
+    creator: node?.creator,
+    create_time: node?.node_create_time,
+  };
+}
+
+async function createNode(
+  client: Lark.Client,
+  spaceId: string,
+  title: string,
+  objType?: string,
+  parentNodeToken?: string,
+) {
+  const res = await client.wiki.spaceNode.create({
+    path: { space_id: spaceId },
+    data: {
+      obj_type: (objType as ObjType) || "docx",
+      node_type: "origin" as const,
+      title,
+      parent_node_token: parentNodeToken,
+    },
+  });
+  if (res.code !== 0) {
+    throw new Error(res.msg);
+  }
+
+  const node = res.data?.node;
+  return {
+    node_token: node?.node_token,
+    obj_token: node?.obj_token,
+    obj_type: node?.obj_type,
+    title: node?.title,
+  };
+}
+
+async function moveNode(
+  client: Lark.Client,
+  spaceId: string,
+  nodeToken: string,
+  targetSpaceId?: string,
+  targetParentToken?: string,
+) {
+  const res = await client.wiki.spaceNode.move({
+    path: { space_id: spaceId, node_token: nodeToken },
+    data: {
+      target_space_id: targetSpaceId || spaceId,
+      target_parent_token: targetParentToken,
+    },
+  });
+  if (res.code !== 0) {
+    throw new Error(res.msg);
+  }
+
+  return {
+    success: true,
+    node_token: res.data?.node?.node_token,
+  };
+}
+
+async function renameNode(client: Lark.Client, spaceId: string, nodeToken: string, title: string) {
+  const res = await client.wiki.spaceNode.updateTitle({
+    path: { space_id: spaceId, node_token: nodeToken },
+    data: { title },
+  });
+  if (res.code !== 0) {
+    throw new Error(res.msg);
+  }
+
+  return {
+    success: true,
+    node_token: nodeToken,
+    title,
+  };
+}
+
+// ============ Tool Registration ============
+
+export function registerFeishuWikiTools(api: PoolBotPluginApi) {
+  if (!api.config) {
+    api.logger.debug?.("feishu_wiki: No config available, skipping wiki tools");
+    return;
+  }
+
+  const accounts = listEnabledFeishuAccounts(api.config);
+  if (accounts.length === 0) {
+    api.logger.debug?.("feishu_wiki: No Feishu accounts configured, skipping wiki tools");
+    return;
+  }
+
+  const firstAccount = accounts[0];
+  const toolsCfg = resolveToolsConfig(firstAccount.config.tools);
+  if (!toolsCfg.wiki) {
+    api.logger.debug?.("feishu_wiki: wiki tool disabled in config");
+    return;
+  }
+
+  const getClient = () => createFeishuClient(firstAccount);
+
+  api.registerTool(
+    {
+      name: "feishu_wiki",
+      label: "Feishu Wiki",
+      description:
+        "Feishu knowledge base operations. Actions: spaces, nodes, get, create, move, rename",
+      parameters: FeishuWikiSchema,
+      async execute(_toolCallId, params) {
+        const p = params as FeishuWikiParams;
+        try {
+          const client = getClient();
+          switch (p.action) {
+            case "spaces":
+              return json(await listSpaces(client));
+            case "nodes":
+              return json(await listNodes(client, p.space_id, p.parent_node_token));
+            case "get":
+              return json(await getNode(client, p.token));
+            case "search":
+              return json({
+                error:
+                  "Search is not available. Use feishu_wiki with action: 'nodes' to browse or action: 'get' to lookup by token.",
+              });
+            case "create":
+              return json(
+                await createNode(client, p.space_id, p.title, p.obj_type, p.parent_node_token),
+              );
+            case "move":
+              return json(
+                await moveNode(
+                  client,
+                  p.space_id,
+                  p.node_token,
+                  p.target_space_id,
+                  p.target_parent_token,
+                ),
+              );
+            case "rename":
+              return json(await renameNode(client, p.space_id, p.node_token, p.title));
+            default:
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any -- exhaustive check fallback
+              return json({ error: `Unknown action: ${(p as any).action}` });
+          }
+        } catch (err) {
+          return json({ error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    },
+    { name: "feishu_wiki" },
+  );
+
+  api.logger.info?.(`feishu_wiki: Registered feishu_wiki tool`);
+}

package/extensions/google-antigravity-auth/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poolbot/google-antigravity-auth",
-  "version": "2026.1.26",
+  "version": "2026.2.17",
   "type": "module",
   "description": "Poolbot Google Antigravity OAuth provider plugin",
   "poolbot": {

package/extensions/google-gemini-cli-auth/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poolbot/google-gemini-cli-auth",
-  "version": "2026.1.26",
+  "version": "2026.2.17",
   "type": "module",
   "description": "Poolbot Gemini CLI OAuth provider plugin",
   "poolbot": {

package/extensions/googlechat/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poolbot/googlechat",
-  "version": "2026.1.26",
+  "version": "2026.2.17",
   "type": "module",
   "description": "Poolbot Google Chat channel plugin",
   "poolbot": {

package/extensions/imessage/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poolbot/imessage",
-  "version": "2026.1.26",
+  "version": "2026.2.17",
   "type": "module",
   "description": "Poolbot iMessage channel plugin",
   "poolbot": {

package/extensions/imessage/src/channel.js

@@ -0,0 +1,253 @@
+import { applyAccountNameToChannelSection, buildChannelConfigSchema, DEFAULT_ACCOUNT_ID, deleteAccountFromConfigSection, formatPairingApproveHint, getChatChannelMeta, imessageOnboardingAdapter, IMessageConfigSchema, listIMessageAccountIds, looksLikeIMessageTargetId, migrateBaseNameToDefaultAccount, normalizeAccountId, normalizeIMessageMessagingTarget, PAIRING_APPROVED_MESSAGE, resolveChannelMediaMaxBytes, resolveDefaultIMessageAccountId, resolveIMessageAccount, resolveIMessageGroupRequireMention, resolveIMessageGroupToolPolicy, setAccountEnabledInConfigSection, } from "poolbot/plugin-sdk";
+import { getIMessageRuntime } from "./runtime.js";
+const meta = getChatChannelMeta("imessage");
+export const imessagePlugin = {
+    id: "imessage",
+    meta: {
+        ...meta,
+        aliases: ["imsg"],
+        showConfigured: false,
+    },
+    onboarding: imessageOnboardingAdapter,
+    pairing: {
+        idLabel: "imessageSenderId",
+        notifyApproval: async ({ id }) => {
+            await getIMessageRuntime().channel.imessage.sendMessageIMessage(id, PAIRING_APPROVED_MESSAGE);
+        },
+    },
+    capabilities: {
+        chatTypes: ["direct", "group"],
+        media: true,
+    },
+    reload: { configPrefixes: ["channels.imessage"] },
+    configSchema: buildChannelConfigSchema(IMessageConfigSchema),
+    config: {
+        listAccountIds: (cfg) => listIMessageAccountIds(cfg),
+        resolveAccount: (cfg, accountId) => resolveIMessageAccount({ cfg, accountId }),
+        defaultAccountId: (cfg) => resolveDefaultIMessageAccountId(cfg),
+        setAccountEnabled: ({ cfg, accountId, enabled }) => setAccountEnabledInConfigSection({
+            cfg,
+            sectionKey: "imessage",
+            accountId,
+            enabled,
+            allowTopLevel: true,
+        }),
+        deleteAccount: ({ cfg, accountId }) => deleteAccountFromConfigSection({
+            cfg,
+            sectionKey: "imessage",
+            accountId,
+            clearBaseFields: ["cliPath", "dbPath", "service", "region", "name"],
+        }),
+        isConfigured: (account) => account.configured,
+        describeAccount: (account) => ({
+            accountId: account.accountId,
+            name: account.name,
+            enabled: account.enabled,
+            configured: account.configured,
+        }),
+        resolveAllowFrom: ({ cfg, accountId }) => (resolveIMessageAccount({ cfg, accountId }).config.allowFrom ?? []).map((entry) => String(entry)),
+        formatAllowFrom: ({ allowFrom }) => allowFrom.map((entry) => String(entry).trim()).filter(Boolean),
+    },
+    security: {
+        resolveDmPolicy: ({ cfg, accountId, account }) => {
+            const resolvedAccountId = accountId ?? account.accountId ?? DEFAULT_ACCOUNT_ID;
+            const useAccountPath = Boolean(cfg.channels?.imessage?.accounts?.[resolvedAccountId]);
+            const basePath = useAccountPath
+                ? `channels.imessage.accounts.${resolvedAccountId}.`
+                : "channels.imessage.";
+            return {
+                policy: account.config.dmPolicy ?? "pairing",
+                allowFrom: account.config.allowFrom ?? [],
+                policyPath: `${basePath}dmPolicy`,
+                allowFromPath: basePath,
+                approveHint: formatPairingApproveHint("imessage"),
+            };
+        },
+        collectWarnings: ({ account, cfg }) => {
+            const defaultGroupPolicy = cfg.channels?.defaults?.groupPolicy;
+            const groupPolicy = account.config.groupPolicy ?? defaultGroupPolicy ?? "allowlist";
+            if (groupPolicy !== "open")
+                return [];
+            return [
+                `- iMessage groups: groupPolicy="open" allows any member to trigger the bot. Set channels.imessage.groupPolicy="allowlist" + channels.imessage.groupAllowFrom to restrict senders.`,
+            ];
+        },
+    },
+    groups: {
+        resolveRequireMention: resolveIMessageGroupRequireMention,
+        resolveToolPolicy: resolveIMessageGroupToolPolicy,
+    },
+    messaging: {
+        normalizeTarget: normalizeIMessageMessagingTarget,
+        targetResolver: {
+            looksLikeId: looksLikeIMessageTargetId,
+            hint: "<handle|chat_id:ID>",
+        },
+    },
+    setup: {
+        resolveAccountId: ({ accountId }) => normalizeAccountId(accountId),
+        applyAccountName: ({ cfg, accountId, name }) => applyAccountNameToChannelSection({
+            cfg,
+            channelKey: "imessage",
+            accountId,
+            name,
+        }),
+        applyAccountConfig: ({ cfg, accountId, input }) => {
+            const namedConfig = applyAccountNameToChannelSection({
+                cfg,
+                channelKey: "imessage",
+                accountId,
+                name: input.name,
+            });
+            const next = accountId !== DEFAULT_ACCOUNT_ID
+                ? migrateBaseNameToDefaultAccount({
+                    cfg: namedConfig,
+                    channelKey: "imessage",
+                })
+                : namedConfig;
+            if (accountId === DEFAULT_ACCOUNT_ID) {
+                return {
+                    ...next,
+                    channels: {
+                        ...next.channels,
+                        imessage: {
+                            ...next.channels?.imessage,
+                            enabled: true,
+                            ...(input.cliPath ? { cliPath: input.cliPath } : {}),
+                            ...(input.dbPath ? { dbPath: input.dbPath } : {}),
+                            ...(input.service ? { service: input.service } : {}),
+                            ...(input.region ? { region: input.region } : {}),
+                        },
+                    },
+                };
+            }
+            return {
+                ...next,
+                channels: {
+                    ...next.channels,
+                    imessage: {
+                        ...next.channels?.imessage,
+                        enabled: true,
+                        accounts: {
+                            ...next.channels?.imessage?.accounts,
+                            [accountId]: {
+                                ...next.channels?.imessage?.accounts?.[accountId],
+                                enabled: true,
+                                ...(input.cliPath ? { cliPath: input.cliPath } : {}),
+                                ...(input.dbPath ? { dbPath: input.dbPath } : {}),
+                                ...(input.service ? { service: input.service } : {}),
+                                ...(input.region ? { region: input.region } : {}),
+                            },
+                        },
+                    },
+                },
+            };
+        },
+    },
+    outbound: {
+        deliveryMode: "direct",
+        chunker: (text, limit) => getIMessageRuntime().channel.text.chunkText(text, limit),
+        chunkerMode: "text",
+        textChunkLimit: 4000,
+        sendText: async ({ cfg, to, text, accountId, deps }) => {
+            const send = deps?.sendIMessage ?? getIMessageRuntime().channel.imessage.sendMessageIMessage;
+            const maxBytes = resolveChannelMediaMaxBytes({
+                cfg,
+                resolveChannelLimitMb: ({ cfg, accountId }) => cfg.channels?.imessage?.accounts?.[accountId]?.mediaMaxMb ??
+                    cfg.channels?.imessage?.mediaMaxMb,
+                accountId,
+            });
+            const result = await send(to, text, {
+                maxBytes,
+                accountId: accountId ?? undefined,
+            });
+            return { channel: "imessage", ...result };
+        },
+        sendMedia: async ({ cfg, to, text, mediaUrl, accountId, deps }) => {
+            const send = deps?.sendIMessage ?? getIMessageRuntime().channel.imessage.sendMessageIMessage;
+            const maxBytes = resolveChannelMediaMaxBytes({
+                cfg,
+                resolveChannelLimitMb: ({ cfg, accountId }) => cfg.channels?.imessage?.accounts?.[accountId]?.mediaMaxMb ??
+                    cfg.channels?.imessage?.mediaMaxMb,
+                accountId,
+            });
+            const result = await send(to, text, {
+                mediaUrl,
+                maxBytes,
+                accountId: accountId ?? undefined,
+            });
+            return { channel: "imessage", ...result };
+        },
+    },
+    status: {
+        defaultRuntime: {
+            accountId: DEFAULT_ACCOUNT_ID,
+            running: false,
+            lastStartAt: null,
+            lastStopAt: null,
+            lastError: null,
+            cliPath: null,
+            dbPath: null,
+        },
+        collectStatusIssues: (accounts) => accounts.flatMap((account) => {
+            const lastError = typeof account.lastError === "string" ? account.lastError.trim() : "";
+            if (!lastError)
+                return [];
+            return [
+                {
+                    channel: "imessage",
+                    accountId: account.accountId,
+                    kind: "runtime",
+                    message: `Channel error: ${lastError}`,
+                },
+            ];
+        }),
+        buildChannelSummary: ({ snapshot }) => ({
+            configured: snapshot.configured ?? false,
+            running: snapshot.running ?? false,
+            lastStartAt: snapshot.lastStartAt ?? null,
+            lastStopAt: snapshot.lastStopAt ?? null,
+            lastError: snapshot.lastError ?? null,
+            cliPath: snapshot.cliPath ?? null,
+            dbPath: snapshot.dbPath ?? null,
+            probe: snapshot.probe,
+            lastProbeAt: snapshot.lastProbeAt ?? null,
+        }),
+        probeAccount: async ({ timeoutMs }) => getIMessageRuntime().channel.imessage.probeIMessage(timeoutMs),
+        buildAccountSnapshot: ({ account, runtime, probe }) => ({
+            accountId: account.accountId,
+            name: account.name,
+            enabled: account.enabled,
+            configured: account.configured,
+            running: runtime?.running ?? false,
+            lastStartAt: runtime?.lastStartAt ?? null,
+            lastStopAt: runtime?.lastStopAt ?? null,
+            lastError: runtime?.lastError ?? null,
+            cliPath: runtime?.cliPath ?? account.config.cliPath ?? null,
+            dbPath: runtime?.dbPath ?? account.config.dbPath ?? null,
+            probe,
+            lastInboundAt: runtime?.lastInboundAt ?? null,
+            lastOutboundAt: runtime?.lastOutboundAt ?? null,
+        }),
+        resolveAccountState: ({ enabled }) => (enabled ? "enabled" : "disabled"),
+    },
+    gateway: {
+        startAccount: async (ctx) => {
+            const account = ctx.account;
+            const cliPath = account.config.cliPath?.trim() || "imsg";
+            const dbPath = account.config.dbPath?.trim();
+            ctx.setStatus({
+                accountId: account.accountId,
+                cliPath,
+                dbPath: dbPath ?? null,
+            });
+            ctx.log?.info(`[${account.accountId}] starting provider (${cliPath}${dbPath ? ` db=${dbPath}` : ""})`);
+            return getIMessageRuntime().channel.imessage.monitorIMessageProvider({
+                accountId: account.accountId,
+                config: ctx.cfg,
+                runtime: ctx.runtime,
+                abortSignal: ctx.abortSignal,
+            });
+        },
+    },
+};

package/extensions/imessage/src/runtime.js

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

package/extensions/irc/index.ts

@@ -0,0 +1,17 @@
+import type { ChannelPlugin, PoolBotPluginApi } from "poolbot/plugin-sdk";
+import { emptyPluginConfigSchema } from "poolbot/plugin-sdk";
+import { ircPlugin } from "./src/channel.js";
+import { setIrcRuntime } from "./src/runtime.js";
+
+const plugin = {
+  id: "irc",
+  name: "IRC",
+  description: "IRC channel plugin",
+  configSchema: emptyPluginConfigSchema(),
+  register(api: PoolBotPluginApi) {
+    setIrcRuntime(api.runtime);
+    api.registerChannel({ plugin: ircPlugin as ChannelPlugin });
+  },
+};
+
+export default plugin;