441 lines
12 KiB
TypeScript
441 lines
12 KiB
TypeScript
import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
|
|
import type { ChannelOutboundAdapter, ChannelPlugin } from "../../channels/plugins/types.js";
|
|
import { setActivePluginRegistry } from "../../plugins/runtime.js";
|
|
import {
|
|
createChannelTestPluginBase,
|
|
createMSTeamsTestPlugin,
|
|
createTestRegistry,
|
|
} from "../../test-utils/channel-plugins.js";
|
|
import { createIMessageTestPlugin } from "../../test-utils/imessage-test-plugin.js";
|
|
import { GATEWAY_CLIENT_MODES, GATEWAY_CLIENT_NAMES } from "../../utils/message-channel.js";
|
|
|
|
const setRegistry = (registry: ReturnType<typeof createTestRegistry>) => {
|
|
setActivePluginRegistry(registry);
|
|
};
|
|
|
|
const callGatewayMock = vi.fn();
|
|
vi.mock("../../gateway/call.js", () => ({
|
|
callGateway: (...args: unknown[]) => callGatewayMock(...args),
|
|
callGatewayLeastPrivilege: (...args: unknown[]) => callGatewayMock(...args),
|
|
randomIdempotencyKey: () => "idem-1",
|
|
}));
|
|
|
|
let sendMessage: typeof import("./message.js").sendMessage;
|
|
let sendPoll: typeof import("./message.js").sendPoll;
|
|
|
|
beforeAll(async () => {
|
|
({ sendMessage, sendPoll } = await import("./message.js"));
|
|
});
|
|
|
|
beforeEach(() => {
|
|
callGatewayMock.mockClear();
|
|
setRegistry(emptyRegistry);
|
|
});
|
|
|
|
afterEach(() => {
|
|
setRegistry(emptyRegistry);
|
|
});
|
|
|
|
describe("sendMessage channel normalization", () => {
|
|
it("threads resolved cfg through alias + target normalization in outbound dispatch", async () => {
|
|
const resolvedCfg = {
|
|
__resolvedCfgMarker: "cfg-from-secret-resolution",
|
|
channels: {},
|
|
} as Record<string, unknown>;
|
|
const seen: {
|
|
resolveCfg?: unknown;
|
|
sendCfg?: unknown;
|
|
to?: string;
|
|
} = {};
|
|
const imessageAliasPlugin: ChannelPlugin = {
|
|
id: "imessage",
|
|
meta: {
|
|
id: "imessage",
|
|
label: "iMessage",
|
|
selectionLabel: "iMessage",
|
|
docsPath: "/channels/imessage",
|
|
blurb: "iMessage test stub.",
|
|
aliases: ["imsg"],
|
|
},
|
|
capabilities: { chatTypes: ["direct"] },
|
|
config: {
|
|
listAccountIds: () => [],
|
|
resolveAccount: () => ({}),
|
|
},
|
|
outbound: {
|
|
deliveryMode: "direct",
|
|
resolveTarget: ({ to, cfg }) => {
|
|
seen.resolveCfg = cfg;
|
|
const normalized = String(to ?? "")
|
|
.trim()
|
|
.replace(/^imessage:/i, "");
|
|
return { ok: true, to: normalized };
|
|
},
|
|
sendText: async ({ cfg, to }) => {
|
|
seen.sendCfg = cfg;
|
|
seen.to = to;
|
|
return { channel: "imessage", messageId: "i-resolved" };
|
|
},
|
|
sendMedia: async ({ cfg, to }) => {
|
|
seen.sendCfg = cfg;
|
|
seen.to = to;
|
|
return { channel: "imessage", messageId: "i-resolved-media" };
|
|
},
|
|
},
|
|
};
|
|
|
|
setRegistry(
|
|
createTestRegistry([
|
|
{
|
|
pluginId: "imessage",
|
|
source: "test",
|
|
plugin: imessageAliasPlugin,
|
|
},
|
|
]),
|
|
);
|
|
|
|
const result = await sendMessage({
|
|
cfg: resolvedCfg,
|
|
to: " imessage:+15551234567 ",
|
|
content: "hi",
|
|
channel: "imsg",
|
|
});
|
|
|
|
expect(result.channel).toBe("imessage");
|
|
expect(seen.resolveCfg).toBe(resolvedCfg);
|
|
expect(seen.sendCfg).toBe(resolvedCfg);
|
|
expect(seen.to).toBe("+15551234567");
|
|
});
|
|
|
|
it.each([
|
|
{
|
|
name: "normalizes Teams aliases",
|
|
registry: createTestRegistry([
|
|
{
|
|
pluginId: "msteams",
|
|
source: "test",
|
|
plugin: createMSTeamsTestPlugin({
|
|
outbound: createMSTeamsOutbound(),
|
|
aliases: ["teams"],
|
|
}),
|
|
},
|
|
]),
|
|
params: {
|
|
to: "conversation:19:abc@thread.tacv2",
|
|
channel: "teams",
|
|
deps: {
|
|
sendMSTeams: vi.fn(async () => ({
|
|
messageId: "m1",
|
|
conversationId: "c1",
|
|
})),
|
|
},
|
|
},
|
|
assertDeps: (deps: { sendMSTeams?: ReturnType<typeof vi.fn> }) => {
|
|
expect(deps.sendMSTeams).toHaveBeenCalledWith("conversation:19:abc@thread.tacv2", "hi");
|
|
},
|
|
expectedChannel: "msteams",
|
|
},
|
|
{
|
|
name: "normalizes iMessage aliases",
|
|
registry: createTestRegistry([
|
|
{
|
|
pluginId: "imessage",
|
|
source: "test",
|
|
plugin: createIMessageTestPlugin(),
|
|
},
|
|
]),
|
|
params: {
|
|
to: "someone@example.com",
|
|
channel: "imsg",
|
|
deps: {
|
|
sendIMessage: vi.fn(async () => ({ messageId: "i1" })),
|
|
},
|
|
},
|
|
assertDeps: (deps: { sendIMessage?: ReturnType<typeof vi.fn> }) => {
|
|
expect(deps.sendIMessage).toHaveBeenCalledWith(
|
|
"someone@example.com",
|
|
"hi",
|
|
expect.any(Object),
|
|
);
|
|
},
|
|
expectedChannel: "imessage",
|
|
},
|
|
])("$name", async ({ registry, params, assertDeps, expectedChannel }) => {
|
|
setRegistry(registry);
|
|
|
|
const result = await sendMessage({
|
|
cfg: {},
|
|
content: "hi",
|
|
...params,
|
|
});
|
|
|
|
assertDeps(params.deps);
|
|
expect(result.channel).toBe(expectedChannel);
|
|
});
|
|
});
|
|
|
|
describe("sendMessage replyToId threading", () => {
|
|
const setupMattermostCapture = () => {
|
|
const capturedCtx: Record<string, unknown>[] = [];
|
|
const plugin = createMattermostLikePlugin({
|
|
onSendText: (ctx) => {
|
|
capturedCtx.push(ctx);
|
|
},
|
|
});
|
|
setRegistry(createTestRegistry([{ pluginId: "mattermost", source: "test", plugin }]));
|
|
return capturedCtx;
|
|
};
|
|
|
|
it.each([
|
|
{
|
|
name: "passes replyToId through to the outbound adapter",
|
|
params: { content: "thread reply", replyToId: "post123" },
|
|
field: "replyToId",
|
|
expected: "post123",
|
|
},
|
|
{
|
|
name: "passes threadId through to the outbound adapter",
|
|
params: { content: "topic reply", threadId: "topic456" },
|
|
field: "threadId",
|
|
expected: "topic456",
|
|
},
|
|
])("$name", async ({ params, field, expected }) => {
|
|
const capturedCtx = setupMattermostCapture();
|
|
|
|
await sendMessage({
|
|
cfg: {},
|
|
to: "channel:town-square",
|
|
channel: "mattermost",
|
|
...params,
|
|
});
|
|
|
|
expect(capturedCtx).toHaveLength(1);
|
|
expect(capturedCtx[0]?.[field]).toBe(expected);
|
|
});
|
|
});
|
|
|
|
describe("sendPoll channel normalization", () => {
|
|
it("normalizes Teams alias for polls", async () => {
|
|
callGatewayMock.mockResolvedValueOnce({ messageId: "p1" });
|
|
setRegistry(
|
|
createTestRegistry([
|
|
{
|
|
pluginId: "msteams",
|
|
source: "test",
|
|
plugin: createMSTeamsTestPlugin({
|
|
aliases: ["teams"],
|
|
outbound: createMSTeamsOutbound({ includePoll: true }),
|
|
}),
|
|
},
|
|
]),
|
|
);
|
|
|
|
const result = await sendPoll({
|
|
cfg: {},
|
|
to: "conversation:19:abc@thread.tacv2",
|
|
question: "Lunch?",
|
|
options: ["Pizza", "Sushi"],
|
|
channel: "Teams",
|
|
});
|
|
|
|
const call = callGatewayMock.mock.calls[0]?.[0] as {
|
|
params?: Record<string, unknown>;
|
|
};
|
|
expect(call?.params?.channel).toBe("msteams");
|
|
expect(result.channel).toBe("msteams");
|
|
});
|
|
});
|
|
|
|
describe("implicit single-channel selection", () => {
|
|
it("keeps single configured channel fallback for sendMessage when channel is omitted", async () => {
|
|
const sendText = vi.fn(async () => ({ channel: "msteams", messageId: "m1" }));
|
|
setRegistry(
|
|
createTestRegistry([
|
|
{
|
|
pluginId: "msteams",
|
|
source: "test",
|
|
plugin: {
|
|
...createChannelTestPluginBase({
|
|
id: "msteams",
|
|
label: "Microsoft Teams",
|
|
docsPath: "/channels/msteams",
|
|
config: {
|
|
listAccountIds: () => ["default"],
|
|
resolveAccount: () => ({}),
|
|
isConfigured: () => true,
|
|
},
|
|
}),
|
|
outbound: {
|
|
...createMSTeamsOutbound(),
|
|
sendText,
|
|
},
|
|
},
|
|
},
|
|
]),
|
|
);
|
|
|
|
const result = await sendMessage({
|
|
cfg: {},
|
|
to: "conversation:19:abc@thread.tacv2",
|
|
content: "hi",
|
|
});
|
|
|
|
expect(result.channel).toBe("msteams");
|
|
expect(sendText).toHaveBeenCalled();
|
|
});
|
|
|
|
it("keeps single configured channel fallback for sendPoll when channel is omitted", async () => {
|
|
setRegistry(
|
|
createTestRegistry([
|
|
{
|
|
pluginId: "msteams",
|
|
source: "test",
|
|
plugin: {
|
|
...createChannelTestPluginBase({
|
|
id: "msteams",
|
|
label: "Microsoft Teams",
|
|
docsPath: "/channels/msteams",
|
|
config: {
|
|
listAccountIds: () => ["default"],
|
|
resolveAccount: () => ({}),
|
|
isConfigured: () => true,
|
|
},
|
|
}),
|
|
outbound: createMSTeamsOutbound({ includePoll: true }),
|
|
},
|
|
},
|
|
]),
|
|
);
|
|
|
|
const result = await sendPoll({
|
|
cfg: {},
|
|
to: "conversation:19:abc@thread.tacv2",
|
|
question: "Lunch?",
|
|
options: ["Pizza", "Sushi"],
|
|
});
|
|
|
|
expect(result.channel).toBe("msteams");
|
|
});
|
|
});
|
|
|
|
const setMattermostGatewayRegistry = () => {
|
|
setRegistry(
|
|
createTestRegistry([
|
|
{
|
|
pluginId: "mattermost",
|
|
source: "test",
|
|
plugin: {
|
|
...createMattermostLikePlugin({ onSendText: () => {} }),
|
|
outbound: { deliveryMode: "gateway" },
|
|
},
|
|
},
|
|
]),
|
|
);
|
|
};
|
|
|
|
describe("gateway url override hardening", () => {
|
|
it("drops gateway url overrides in backend mode (SSRF hardening)", async () => {
|
|
setMattermostGatewayRegistry();
|
|
|
|
callGatewayMock.mockResolvedValueOnce({ messageId: "m1" });
|
|
await sendMessage({
|
|
cfg: {},
|
|
to: "channel:town-square",
|
|
content: "hi",
|
|
channel: "mattermost",
|
|
gateway: {
|
|
url: "ws://169.254.169.254:80/latest/meta-data/",
|
|
token: "t",
|
|
timeoutMs: 5000,
|
|
clientName: GATEWAY_CLIENT_NAMES.GATEWAY_CLIENT,
|
|
clientDisplayName: "agent",
|
|
mode: GATEWAY_CLIENT_MODES.BACKEND,
|
|
},
|
|
});
|
|
|
|
expect(callGatewayMock).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
url: undefined,
|
|
token: "t",
|
|
timeoutMs: 5000,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it("forwards explicit agentId in gateway send params", async () => {
|
|
setMattermostGatewayRegistry();
|
|
|
|
callGatewayMock.mockResolvedValueOnce({ messageId: "m-agent" });
|
|
await sendMessage({
|
|
cfg: {},
|
|
to: "channel:town-square",
|
|
content: "hi",
|
|
channel: "mattermost",
|
|
agentId: "work",
|
|
});
|
|
|
|
const call = callGatewayMock.mock.calls[0]?.[0] as {
|
|
params?: Record<string, unknown>;
|
|
};
|
|
expect(call.params?.agentId).toBe("work");
|
|
});
|
|
});
|
|
|
|
const emptyRegistry = createTestRegistry([]);
|
|
|
|
const createMSTeamsOutbound = (opts?: { includePoll?: boolean }): ChannelOutboundAdapter => ({
|
|
deliveryMode: "direct",
|
|
sendText: async ({ deps, to, text }) => {
|
|
const send = deps?.sendMSTeams as
|
|
| ((to: string, text: string, opts?: unknown) => Promise<{ messageId: string }>)
|
|
| undefined;
|
|
if (!send) {
|
|
throw new Error("sendMSTeams missing");
|
|
}
|
|
const result = await send(to, text);
|
|
return { channel: "msteams", ...result };
|
|
},
|
|
sendMedia: async ({ deps, to, text, mediaUrl }) => {
|
|
const send = deps?.sendMSTeams as
|
|
| ((to: string, text: string, opts?: unknown) => Promise<{ messageId: string }>)
|
|
| undefined;
|
|
if (!send) {
|
|
throw new Error("sendMSTeams missing");
|
|
}
|
|
const result = await send(to, text, { mediaUrl });
|
|
return { channel: "msteams", ...result };
|
|
},
|
|
...(opts?.includePoll
|
|
? {
|
|
pollMaxOptions: 12,
|
|
sendPoll: async () => ({ channel: "msteams", messageId: "p1" }),
|
|
}
|
|
: {}),
|
|
});
|
|
|
|
const createMattermostLikePlugin = (opts: {
|
|
onSendText: (ctx: Record<string, unknown>) => void;
|
|
}): ChannelPlugin => ({
|
|
id: "mattermost",
|
|
meta: {
|
|
id: "mattermost",
|
|
label: "Mattermost",
|
|
selectionLabel: "Mattermost",
|
|
docsPath: "/channels/mattermost",
|
|
blurb: "Mattermost test stub.",
|
|
},
|
|
capabilities: { chatTypes: ["direct", "channel"] },
|
|
config: {
|
|
listAccountIds: () => ["default"],
|
|
resolveAccount: () => ({}),
|
|
},
|
|
outbound: {
|
|
deliveryMode: "direct",
|
|
sendText: async (ctx) => {
|
|
opts.onSendText(ctx as unknown as Record<string, unknown>);
|
|
return { channel: "mattermost", messageId: "m1" };
|
|
},
|
|
sendMedia: async () => ({ channel: "mattermost", messageId: "m2" }),
|
|
},
|
|
});
|