Download src/channels/plugins/plugins-core.test.ts from shimen/shinclaw: direct link, hf CLI and curl.
- Browser
- Download file 11.8 kB
-
https://huggingface.co/spaces/shimen/shinclaw/resolve/main/src/channels/plugins/plugins-core.test.ts
- Command line
-
hf download hf://spaces/shimen/shinclaw/src/channels/plugins/plugins-core.test.ts
-
curl -L -o plugins-core.test.ts https://huggingface.co/spaces/shimen/shinclaw/resolve/main/src/channels/plugins/plugins-core.test.ts
11.8 kB
| import fs from "node:fs"; | |
| import os from "node:os"; | |
| import path from "node:path"; | |
| import { afterEach, beforeEach, describe, expect, expectTypeOf, it } from "vitest"; | |
| import type { DiscordProbe } from "../../discord/probe.js"; | |
| import type { DiscordTokenResolution } from "../../discord/token.js"; | |
| import type { IMessageProbe } from "../../imessage/probe.js"; | |
| import type { LineProbeResult } from "../../line/types.js"; | |
| import type { PluginRegistry } from "../../plugins/registry.js"; | |
| import type { SignalProbe } from "../../signal/probe.js"; | |
| import type { SlackProbe } from "../../slack/probe.js"; | |
| import type { TelegramProbe } from "../../telegram/probe.js"; | |
| import type { TelegramTokenResolution } from "../../telegram/token.js"; | |
| import type { ChannelOutboundAdapter, ChannelPlugin } from "./types.js"; | |
| import type { BaseProbeResult, BaseTokenResolution } from "./types.js"; | |
| import { setActivePluginRegistry } from "../../plugins/runtime.js"; | |
| import { createTestRegistry } from "../../test-utils/channel-plugins.js"; | |
| import { getChannelPluginCatalogEntry, listChannelPluginCatalogEntries } from "./catalog.js"; | |
| import { resolveChannelConfigWrites } from "./config-writes.js"; | |
| import { | |
| listDiscordDirectoryGroupsFromConfig, | |
| listDiscordDirectoryPeersFromConfig, | |
| listSlackDirectoryGroupsFromConfig, | |
| listSlackDirectoryPeersFromConfig, | |
| listTelegramDirectoryGroupsFromConfig, | |
| listTelegramDirectoryPeersFromConfig, | |
| listWhatsAppDirectoryGroupsFromConfig, | |
| listWhatsAppDirectoryPeersFromConfig, | |
| } from "./directory-config.js"; | |
| import { listChannelPlugins } from "./index.js"; | |
| import { loadChannelPlugin } from "./load.js"; | |
| import { loadChannelOutboundAdapter } from "./outbound/load.js"; | |
| describe("channel plugin registry", () => { | |
| const emptyRegistry = createTestRegistry([]); | |
| const createPlugin = (id: string): ChannelPlugin => ({ | |
| id, | |
| meta: { | |
| id, | |
| label: id, | |
| selectionLabel: id, | |
| docsPath: `/channels/${id}`, | |
| blurb: "test", | |
| }, | |
| capabilities: { chatTypes: ["direct"] }, | |
| config: { | |
| listAccountIds: () => [], | |
| resolveAccount: () => ({}), | |
| }, | |
| }); | |
| beforeEach(() => { | |
| setActivePluginRegistry(emptyRegistry); | |
| }); | |
| afterEach(() => { | |
| setActivePluginRegistry(emptyRegistry); | |
| }); | |
| it("sorts channel plugins by configured order", () => { | |
| const registry = createTestRegistry( | |
| ["slack", "telegram", "signal"].map((id) => ({ | |
| pluginId: id, | |
| plugin: createPlugin(id), | |
| source: "test", | |
| })), | |
| ); | |
| setActivePluginRegistry(registry); | |
| const pluginIds = listChannelPlugins().map((plugin) => plugin.id); | |
| expect(pluginIds).toEqual(["telegram", "slack", "signal"]); | |
| }); | |
| }); | |
| describe("channel plugin catalog", () => { | |
| it("includes Microsoft Teams", () => { | |
| const entry = getChannelPluginCatalogEntry("msteams"); | |
| expect(entry?.install.npmSpec).toBe("@openclaw/msteams"); | |
| expect(entry?.meta.aliases).toContain("teams"); | |
| }); | |
| it("lists plugin catalog entries", () => { | |
| const ids = listChannelPluginCatalogEntries().map((entry) => entry.id); | |
| expect(ids).toContain("msteams"); | |
| }); | |
| it("includes external catalog entries", () => { | |
| const dir = fs.mkdtempSync(path.join(os.tmpdir(), "openclaw-catalog-")); | |
| const catalogPath = path.join(dir, "catalog.json"); | |
| fs.writeFileSync( | |
| catalogPath, | |
| JSON.stringify({ | |
| entries: [ | |
| { | |
| name: "@openclaw/demo-channel", | |
| openclaw: { | |
| channel: { | |
| id: "demo-channel", | |
| label: "Demo Channel", | |
| selectionLabel: "Demo Channel", | |
| docsPath: "/channels/demo-channel", | |
| blurb: "Demo entry", | |
| order: 999, | |
| }, | |
| install: { | |
| npmSpec: "@openclaw/demo-channel", | |
| }, | |
| }, | |
| }, | |
| ], | |
| }), | |
| ); | |
| const ids = listChannelPluginCatalogEntries({ catalogPaths: [catalogPath] }).map( | |
| (entry) => entry.id, | |
| ); | |
| expect(ids).toContain("demo-channel"); | |
| }); | |
| }); | |
| const createRegistry = (channels: PluginRegistry["channels"]): PluginRegistry => ({ | |
| plugins: [], | |
| tools: [], | |
| channels, | |
| providers: [], | |
| gatewayHandlers: {}, | |
| httpHandlers: [], | |
| httpRoutes: [], | |
| cliRegistrars: [], | |
| services: [], | |
| diagnostics: [], | |
| }); | |
| const emptyRegistry = createRegistry([]); | |
| const msteamsOutbound: ChannelOutboundAdapter = { | |
| deliveryMode: "direct", | |
| sendText: async () => ({ channel: "msteams", messageId: "m1" }), | |
| sendMedia: async () => ({ channel: "msteams", messageId: "m2" }), | |
| }; | |
| const msteamsPlugin: ChannelPlugin = { | |
| id: "msteams", | |
| meta: { | |
| id: "msteams", | |
| label: "Microsoft Teams", | |
| selectionLabel: "Microsoft Teams (Bot Framework)", | |
| docsPath: "/channels/msteams", | |
| blurb: "Bot Framework; enterprise support.", | |
| aliases: ["teams"], | |
| }, | |
| capabilities: { chatTypes: ["direct"] }, | |
| config: { | |
| listAccountIds: () => [], | |
| resolveAccount: () => ({}), | |
| }, | |
| outbound: msteamsOutbound, | |
| }; | |
| const registryWithMSTeams = createRegistry([ | |
| { pluginId: "msteams", plugin: msteamsPlugin, source: "test" }, | |
| ]); | |
| describe("channel plugin loader", () => { | |
| beforeEach(() => { | |
| setActivePluginRegistry(emptyRegistry); | |
| }); | |
| afterEach(() => { | |
| setActivePluginRegistry(emptyRegistry); | |
| }); | |
| it("loads channel plugins from the active registry", async () => { | |
| setActivePluginRegistry(registryWithMSTeams); | |
| const plugin = await loadChannelPlugin("msteams"); | |
| expect(plugin).toBe(msteamsPlugin); | |
| }); | |
| it("loads outbound adapters from registered plugins", async () => { | |
| setActivePluginRegistry(registryWithMSTeams); | |
| const outbound = await loadChannelOutboundAdapter("msteams"); | |
| expect(outbound).toBe(msteamsOutbound); | |
| }); | |
| }); | |
| describe("BaseProbeResult assignability", () => { | |
| it("TelegramProbe satisfies BaseProbeResult", () => { | |
| expectTypeOf<TelegramProbe>().toMatchTypeOf<BaseProbeResult>(); | |
| }); | |
| it("DiscordProbe satisfies BaseProbeResult", () => { | |
| expectTypeOf<DiscordProbe>().toMatchTypeOf<BaseProbeResult>(); | |
| }); | |
| it("SlackProbe satisfies BaseProbeResult", () => { | |
| expectTypeOf<SlackProbe>().toMatchTypeOf<BaseProbeResult>(); | |
| }); | |
| it("SignalProbe satisfies BaseProbeResult", () => { | |
| expectTypeOf<SignalProbe>().toMatchTypeOf<BaseProbeResult>(); | |
| }); | |
| it("IMessageProbe satisfies BaseProbeResult", () => { | |
| expectTypeOf<IMessageProbe>().toMatchTypeOf<BaseProbeResult>(); | |
| }); | |
| it("LineProbeResult satisfies BaseProbeResult", () => { | |
| expectTypeOf<LineProbeResult>().toMatchTypeOf<BaseProbeResult>(); | |
| }); | |
| }); | |
| describe("BaseTokenResolution assignability", () => { | |
| it("TelegramTokenResolution satisfies BaseTokenResolution", () => { | |
| expectTypeOf<TelegramTokenResolution>().toMatchTypeOf<BaseTokenResolution>(); | |
| }); | |
| it("DiscordTokenResolution satisfies BaseTokenResolution", () => { | |
| expectTypeOf<DiscordTokenResolution>().toMatchTypeOf<BaseTokenResolution>(); | |
| }); | |
| }); | |
| describe("resolveChannelConfigWrites", () => { | |
| it("defaults to allow when unset", () => { | |
| const cfg = {}; | |
| expect(resolveChannelConfigWrites({ cfg, channelId: "slack" })).toBe(true); | |
| }); | |
| it("blocks when channel config disables writes", () => { | |
| const cfg = { channels: { slack: { configWrites: false } } }; | |
| expect(resolveChannelConfigWrites({ cfg, channelId: "slack" })).toBe(false); | |
| }); | |
| it("account override wins over channel default", () => { | |
| const cfg = { | |
| channels: { | |
| slack: { | |
| configWrites: true, | |
| accounts: { | |
| work: { configWrites: false }, | |
| }, | |
| }, | |
| }, | |
| }; | |
| expect(resolveChannelConfigWrites({ cfg, channelId: "slack", accountId: "work" })).toBe(false); | |
| }); | |
| it("matches account ids case-insensitively", () => { | |
| const cfg = { | |
| channels: { | |
| slack: { | |
| configWrites: true, | |
| accounts: { | |
| Work: { configWrites: false }, | |
| }, | |
| }, | |
| }, | |
| }; | |
| expect(resolveChannelConfigWrites({ cfg, channelId: "slack", accountId: "work" })).toBe(false); | |
| }); | |
| }); | |
| describe("directory (config-backed)", () => { | |
| it("lists Slack peers/groups from config", async () => { | |
| const cfg = { | |
| channels: { | |
| slack: { | |
| botToken: "xoxb-test", | |
| appToken: "xapp-test", | |
| dm: { allowFrom: ["U123", "user:U999"] }, | |
| dms: { U234: {} }, | |
| channels: { C111: { users: ["U777"] } }, | |
| }, | |
| }, | |
| // oxlint-disable-next-line typescript/no-explicit-any | |
| } as any; | |
| const peers = await listSlackDirectoryPeersFromConfig({ | |
| cfg, | |
| accountId: "default", | |
| query: null, | |
| limit: null, | |
| }); | |
| expect(peers?.map((e) => e.id).toSorted()).toEqual([ | |
| "user:u123", | |
| "user:u234", | |
| "user:u777", | |
| "user:u999", | |
| ]); | |
| const groups = await listSlackDirectoryGroupsFromConfig({ | |
| cfg, | |
| accountId: "default", | |
| query: null, | |
| limit: null, | |
| }); | |
| expect(groups?.map((e) => e.id)).toEqual(["channel:c111"]); | |
| }); | |
| it("lists Discord peers/groups from config (numeric ids only)", async () => { | |
| const cfg = { | |
| channels: { | |
| discord: { | |
| token: "discord-test", | |
| dm: { allowFrom: ["<@111>", "nope"] }, | |
| dms: { "222": {} }, | |
| guilds: { | |
| "123": { | |
| users: ["<@12345>", "not-an-id"], | |
| channels: { | |
| "555": {}, | |
| "channel:666": {}, | |
| general: {}, | |
| }, | |
| }, | |
| }, | |
| }, | |
| }, | |
| // oxlint-disable-next-line typescript/no-explicit-any | |
| } as any; | |
| const peers = await listDiscordDirectoryPeersFromConfig({ | |
| cfg, | |
| accountId: "default", | |
| query: null, | |
| limit: null, | |
| }); | |
| expect(peers?.map((e) => e.id).toSorted()).toEqual(["user:111", "user:12345", "user:222"]); | |
| const groups = await listDiscordDirectoryGroupsFromConfig({ | |
| cfg, | |
| accountId: "default", | |
| query: null, | |
| limit: null, | |
| }); | |
| expect(groups?.map((e) => e.id).toSorted()).toEqual(["channel:555", "channel:666"]); | |
| }); | |
| it("lists Telegram peers/groups from config", async () => { | |
| const cfg = { | |
| channels: { | |
| telegram: { | |
| botToken: "telegram-test", | |
| allowFrom: ["123", "alice", "tg:@bob"], | |
| dms: { "456": {} }, | |
| groups: { "-1001": {}, "*": {} }, | |
| }, | |
| }, | |
| // oxlint-disable-next-line typescript/no-explicit-any | |
| } as any; | |
| const peers = await listTelegramDirectoryPeersFromConfig({ | |
| cfg, | |
| accountId: "default", | |
| query: null, | |
| limit: null, | |
| }); | |
| expect(peers?.map((e) => e.id).toSorted()).toEqual(["123", "456", "@alice", "@bob"]); | |
| const groups = await listTelegramDirectoryGroupsFromConfig({ | |
| cfg, | |
| accountId: "default", | |
| query: null, | |
| limit: null, | |
| }); | |
| expect(groups?.map((e) => e.id)).toEqual(["-1001"]); | |
| }); | |
| it("lists WhatsApp peers/groups from config", async () => { | |
| const cfg = { | |
| channels: { | |
| whatsapp: { | |
| allowFrom: ["+15550000000", "*", "123@g.us"], | |
| groups: { "999@g.us": { requireMention: true }, "*": {} }, | |
| }, | |
| }, | |
| // oxlint-disable-next-line typescript/no-explicit-any | |
| } as any; | |
| const peers = await listWhatsAppDirectoryPeersFromConfig({ | |
| cfg, | |
| accountId: "default", | |
| query: null, | |
| limit: null, | |
| }); | |
| expect(peers?.map((e) => e.id)).toEqual(["+15550000000"]); | |
| const groups = await listWhatsAppDirectoryGroupsFromConfig({ | |
| cfg, | |
| accountId: "default", | |
| query: null, | |
| limit: null, | |
| }); | |
| expect(groups?.map((e) => e.id)).toEqual(["999@g.us"]); | |
| }); | |
| }); | |