Your lightweight open-source personal agent.
Python agent-frameworkai-agentai-agentschatbotchatopsdiscord-botllm-agentsllmslocal-llmmcpmodel-context-protocolmulti-agentopenai-compatibleopenclawpersonal-ai-assistantpythonself-hostedtelegram-bot-ai-assistantwebuiworkflow-automation
import { act, fireEvent, screen, waitFor, within } from "@testing-library/react";
import userEvent from "@testing-library/user-event";
import { expect, it, vi } from "vitest";
import type {
ChannelSetupContract,
ChannelSetupContractField,
NanobotFeatureInfo,
NanobotFeaturesPayload,
} from "@/lib/types";
import { requestMutationMock, jsonResponse, settingsPayload, renderSettingsView, installSettingsViewTestHooks } from "@/tests/settings-test-utils";
function channelSetupField(
channel: string,
field: string,
kind: ChannelSetupContractField["kind"] = "string",
options: {
required?: boolean;
choices?: string[];
defaultValue?: string;
} = {},
): ChannelSetupContractField {
return {
key: `channels.${channel}.${field}`,
field,
kind,
choices: options.choices ?? [],
required: options.required ?? false,
...(options.defaultValue === undefined ? {} : { default_value: options.defaultValue }),
};
}
function channelSetupContract(
channel: "discord" | "email" | "feishu" | "matrix" | "qq",
): ChannelSetupContract {
const field = (
name: string,
kind: ChannelSetupContractField["kind"] = "string",
options: Parameters<typeof channelSetupField>[3] = {},
) => channelSetupField(channel, name, kind, options);
switch (channel) {
case "discord":
return {
official_url: "https://discord.com/developers/applications",
fields: [
field("token", "secret", { required: true }),
field("allowFrom", "list"),
field("allowChannels", "list"),
field("groupPolicy", "enum", {
choices: ["mention", "open"],
defaultValue: "mention",
}),
],
requirements: [
{ alternatives: [["channels.discord.token"]] },
],
};
case "email":
return {
official_url: "https://support.google.com/accounts/answer/185833",
fields: [
field("consentGranted", "bool", { required: true, defaultValue: "false" }),
field("imapHost", "string", { required: true }),
field("imapPort", "int"),
field("imapUsername", "string", { required: true }),
field("imapPassword", "secret", { required: true }),
field("smtpHost", "string", { required: true }),
field("smtpPort", "int"),
field("smtpUsername", "string", { required: true }),
field("smtpPassword", "secret", { required: true }),
field("fromAddress"),
field("pollIntervalSeconds", "int"),
field("allowFrom", "list"),
field("verifyDkim", "bool", { defaultValue: "true" }),
field("verifySpf", "bool", { defaultValue: "true" }),
field("trustedAuthservIds", "list"),
],
requirements: [
{ alternatives: [["channels.email.consentGranted"]] },
{ alternatives: [["channels.email.imapHost"]] },
{ alternatives: [["channels.email.imapUsername"]] },
{ alternatives: [["channels.email.imapPassword"]] },
{ alternatives: [["channels.email.smtpHost"]] },
{ alternatives: [["channels.email.smtpUsername"]] },
{ alternatives: [["channels.email.smtpPassword"]] },
],
};
case "feishu":
return {
official_url: "https://open.feishu.cn/app",
fields: [
field("appId", "string", { required: true }),
field("appSecret", "secret", { required: true }),
field("domain", "enum", {
choices: ["feishu", "lark"],
defaultValue: "feishu",
}),
field("groupPolicy", "enum", {
choices: ["mention", "open"],
defaultValue: "mention",
}),
field("allowFrom", "list"),
field("topicIsolation", "bool"),
],
requirements: [
{ alternatives: [["channels.feishu.appId"]] },
{ alternatives: [["channels.feishu.appSecret"]] },
],
};
case "matrix":
return {
official_url: "https://matrix.org/ecosystem/clients/",
fields: [
field("homeserver", "string", { required: true }),
field("userId", "string", { required: true }),
field("password", "secret"),
field("accessToken", "secret"),
field("deviceId"),
field("groupPolicy", "enum", {
choices: ["allowlist", "mention", "open"],
defaultValue: "open",
}),
],
requirements: [
{ alternatives: [["channels.matrix.homeserver"]] },
{ alternatives: [["channels.matrix.userId"]] },
{
alternatives: [
["channels.matrix.password"],
["channels.matrix.accessToken", "channels.matrix.deviceId"],
],
},
],
};
case "qq":
return {
official_url: "https://q.qq.com/",
fields: [
field("appId", "string", { required: true }),
field("secret", "secret", { required: true }),
field("allowFrom", "list"),
field("msgFormat", "enum", {
choices: ["markdown", "plain"],
defaultValue: "plain",
}),
field("ackMessage", "string", { defaultValue: "⏳ Processing..." }),
field("showCompactionNotices", "bool", { choices: ["true", "false"] }),
field("mediaDir", "string"),
field("downloadChunkSize", "int", { defaultValue: "262144" }),
field("downloadMaxBytes", "int", { defaultValue: "209715200" }),
],
requirements: [
{ alternatives: [["channels.qq.appId"]] },
{ alternatives: [["channels.qq.secret"]] },
],
};
}
}
function uninstalledConnectFeature(
name: "feishu" | "weixin" | "whatsapp",
): NanobotFeatureInfo {
const displayNames = {
feishu: "Feishu",
weixin: "WeChat",
whatsapp: "WhatsApp",
};
return {
name,
display_name: displayNames[name],
webui: "webui/index.tsx",
type: "channel",
enabled: false,
configured: false,
installed: false,
requires_dependencies: true,
ready: false,
runtime_status: "stopped",
status: "not_enabled",
install_supported: true,
requires_restart: true,
...(name === "feishu"
? {
instances: [{
id: "default",
name: "nanobot",
enabled: false,
runtime_status: "stopped",
configured: false,
config_values: {},
configured_fields: [],
}],
}
: {}),
};
}
function catalogFeature(
name: string,
enabled: boolean,
requiresDependencies = false,
): NanobotFeatureInfo {
return {
name,
display_name: name,
type: "channel",
enabled,
configured: enabled,
installed: true,
requires_dependencies: requiresDependencies,
ready: enabled,
status: enabled ? "enabled" : "not_enabled",
install_supported: true,
requires_restart: false,
};
}
function configuredEmailFeature(overrides: Partial<NanobotFeatureInfo> = {}): NanobotFeatureInfo {
return {
...catalogFeature("email", true),
display_name: "Email",
webui: "webui/index.ts",
config_values: {
"channels.email.consentGranted": "true",
"channels.email.imapHost": "imap.example.com",
"channels.email.imapUsername": "[email protected]",
"channels.email.smtpHost": "smtp.example.com",
"channels.email.smtpUsername": "[email protected]",
},
configured_fields: [
"channels.email.consentGranted",
"channels.email.imapHost",
"channels.email.imapUsername",
"channels.email.imapPassword",
"channels.email.smtpHost",
"channels.email.smtpUsername",
"channels.email.smtpPassword",
],
setup: channelSetupContract("email"),
...overrides,
};
}
describe("Settings channels", () => {
installSettingsViewTestHooks();
it("shows agent chat privacy before entering credentials or enabling the channel", async () => {
vi.stubGlobal("fetch", vi.fn(async (input: RequestInfo | URL) => {
const url = String(input);
if (url === "/api/settings") return jsonResponse(settingsPayload());
if (url === "/api/settings/nanobot-features") return jsonResponse({
features: [{
...catalogFeature("whatsapp_agent", false),
display_name: "WhatsApp Agent Platform",
webui: "webui/index.ts",
setup: {
verifies_connection: true,
fields: [channelSetupField("whatsapp_agent", "token", "secret", { required: true })],
requirements: [{ alternatives: [["channels.whatsapp_agent.token"]] }],
},
}],
enabled_count: 0,
});
return jsonResponse({});
}));
renderSettingsView({ initialSection: "channels" });
fireEvent.click(await screen.findByRole("button", { name: "View WhatsApp Agent Platform settings" }));
const privacy = screen.getByText(/Agent chats are not end-to-end encrypted/);
expect(privacy).toBeVisible();
expect(privacy).toHaveTextContent("nanobot and your configured model provider");
const token = screen.getByLabelText("API token");
expect(token).toHaveValue("");
expect(privacy.compareDocumentPosition(token) & Node.DOCUMENT_POSITION_FOLLOWING).toBeTruthy();
expect(screen.getByRole("switch", { name: "Enable channel" })).not.toBeChecked();
expect(requestMutationMock).not.toHaveBeenCalled();
});
it.each([
{
name: "telegram",
displayName: "Telegram",
identity: "nano_test0001bot",
checks: [
{ id: "token_format", label: "Token format", status: "pass" },
{ id: "get_me", label: "Bot identity", status: "pass" },
],
},
{
name: "discord",
displayName: "Discord",
identity: "nanobot-test",
checks: [
{ id: "bot_token", label: "Bot token", status: "pass" },
{
id: "invite",
label: "Server invite",
status: "pass",
action_url: "https://discord.com/oauth2/authorize?client_id=123",
},
],
},
])("reveals $displayName connection checks before confirming the identity", async ({
name,
displayName,
identity,
checks,
}) => {
vi.stubGlobal("fetch", vi.fn(async (input: RequestInfo | URL) => {
const url = String(input);
if (url === "/api/settings") return jsonResponse(settingsPayload());
if (url === "/api/settings/nanobot-features") {
return jsonResponse({
features: [{
name,
display_name: displayName,
webui: "webui/index.ts",
type: "channel",
enabled: true,
running: true,
runtime_status: "running",
configured: true,
installed: true,
ready: true,
status: "enabled",
install_supported: true,
requires_restart: false,
setup: {
verifies_connection: true,
fields: [channelSetupField(name, "token", "secret", { required: true })],
requirements: [{ alternatives: [[`channels.${name}.token`]] }],
},
configured_fields: [`channels.${name}.token`],
}],
enabled_count: 1,
});
}
return jsonResponse({});
}));
requestMutationMock.mockResolvedValueOnce({
name,
status: "connected",
checks,
identity: { name: identity },
missing_fields: [],
can_enable: true,
requires_restart: false,
});
renderSettingsView({ initialSection: "channels" });
fireEvent.click(await screen.findByRole("button", { name: `View ${displayName} settings` }));
const checkButton = screen.getByRole("button", { name: "Check connection" });
expect(checkButton.parentElement).toBe(
screen.getByRole("switch", { name: "Enable channel" }).parentElement,
);
vi.useFakeTimers();
try {
fireEvent.click(checkButton);
await act(async () => {});
const progress = screen.getAllByRole("status").find(
(element) => element.textContent?.includes(checks[0].label),
);
expect(progress).toBeDefined();
expect(within(progress!).getByText(checks[0].label)).toBeVisible();
expect(within(progress!).queryByText(checks[1].label)).not.toBeInTheDocument();
expect(within(progress!).queryByText(identity)).not.toBeInTheDocument();
act(() => vi.advanceTimersByTime(260));
expect(within(progress!).getByText(checks[1].label)).toBeVisible();
expect(within(progress!).queryByText(identity)).not.toBeInTheDocument();
act(() => vi.advanceTimersByTime(260));
expect(within(progress!).getByText(identity)).toBeVisible();
expect(within(progress!).getByText("Connected")).toBeVisible();
if (name === "discord") {
const checkLabel = within(progress!).getByText("Server invite");
expect(checkLabel.parentElement).toContainElement(
within(progress!).getByRole("link", { name: "Open" }),
);
}
expect(screen.queryByText("Connection verified.")).not.toBeInTheDocument();
} finally {
vi.useRealTimers();
}
});
it("shows enabled channels by default when any are enabled", async () => {
const enabled = catalogFeature("Enabled channel", true);
const enabledWithDependencies = catalogFeature("Enabled dependency channel", true, true);
const disabled = catalogFeature("Disabled channel", false);
vi.stubGlobal("fetch", vi.fn(async (input: RequestInfo | URL) => {
const url = String(input);
if (url === "/api/settings") return jsonResponse(settingsPayload());
if (url === "/api/settings/nanobot-features") {
return jsonResponse({ features: [enabled, enabledWithDependencies, disabled], enabled_count: 2 });
}
return jsonResponse({});
}));
renderSettingsView({ initialSection: "channels" });
expect(await screen.findByRole("button", { name: "View Enabled channel settings" })).toBeInTheDocument();
expect(screen.getByRole("button", { name: "View Enabled dependency channel settings" })).toBeInTheDocument();
expect(screen.queryByRole("button", { name: "View Disabled channel settings" })).not.toBeInTheDocument();
expect(screen.getByRole("button", { name: "Enabled" })).toHaveAttribute("aria-pressed", "true");
expect(screen.queryByText("No installation needed")).not.toBeInTheDocument();
expect(screen.queryByText("Requires dependencies")).not.toBeInTheDocument();
fireEvent.click(screen.getByRole("button", { name: "All" }));
expect(screen.getByRole("button", { name: "View Disabled channel settings" })).toBeInTheDocument();
});
it("shows all channels by default when none are enabled", async () => {
const first = catalogFeature("First channel", false);
const second = catalogFeature("Second channel", false);
vi.stubGlobal("fetch", vi.fn(async (input: RequestInfo | URL) => {
const url = String(input);
if (url === "/api/settings") return jsonResponse(settingsPayload());
if (url === "/api/settings/nanobot-features") {
return jsonResponse({ features: [first, second], enabled_count: 0 });
}
return jsonResponse({});
}));
renderSettingsView({ initialSection: "channels" });
expect(await screen.findByRole("button", { name: "View First channel settings" })).toBeInTheDocument();
expect(screen.getByRole("button", { name: "View Second channel settings" })).toBeInTheDocument();
expect(screen.getByRole("button", { name: "All" })).toHaveAttribute("aria-pressed", "true");
});
it("shows all channels by default when only the always-enabled WebUI is enabled", async () => {
const websocket = {
...catalogFeature("websocket", true),
display_name: "nanobot WebUI",
capabilities: ["always_enabled"],
};
const disabled = catalogFeature("Disabled channel", false);
vi.stubGlobal("fetch", vi.fn(async (input: RequestInfo | URL) => {
const url = String(input);
if (url === "/api/settings") return jsonResponse(settingsPayload());
if (url === "/api/settings/nanobot-features") {
return jsonResponse({ features: [websocket, disabled], enabled_count: 1 });
}
return jsonResponse({});
}));
renderSettingsView({ initialSection: "channels" });
expect(await screen.findByText("nanobot WebUI")).toBeInTheDocument();
expect(screen.getByRole("button", { name: "View Disabled channel settings" })).toBeInTheDocument();
expect(screen.getByRole("button", { name: "All" })).toHaveAttribute("aria-pressed", "true");
});
it("replaces the installed channel switch with an in-row restart action", async () => {
const restart = vi.fn();
const whatsappFeature = {
name: "whatsapp",
display_name: "WhatsApp",
webui: "webui/index.tsx",
type: "channel",
enabled: false,
configured: false,
installed: false,
requires_dependencies: true,
ready: false,
status: "not_enabled",
install_supported: true,
requires_restart: false,
} as const;
const weixinFeature = uninstalledConnectFeature("weixin");
vi.stubGlobal(
"fetch",
vi.fn(async (input: RequestInfo | URL) => {
const url = String(input);
if (url === "/api/settings") return jsonResponse(settingsPayload());
if (url === "/api/settings/cli-apps") return jsonResponse({ apps: [], installed_count: 0 });
if (url === "/api/settings/mcp-presets") return jsonResponse({ presets: [], installed_count: 0 });
if (url === "/api/settings/nanobot-features") {
return jsonResponse({ features: [whatsappFeature, weixinFeature], enabled_count: 0 });
}
return { ok: false, status: 404, json: async () => ({}) } as Response;
}),
);
let finishInstall: (payload: NanobotFeaturesPayload) => void = () => {};
requestMutationMock.mockImplementationOnce(() => new Promise((resolve) => {
finishInstall = resolve;
}));
const installedPayload = {
features: [{ ...whatsappFeature, installed: true, restart_pending: true }, weixinFeature],
enabled_count: 0,
requires_restart: true,
last_action: {
ok: true,
message: "Installed support for channel 'whatsapp'",
enabled: false,
},
};
renderSettingsView({ initialSection: "channels", onRestart: restart });
requestMutationMock.mockResolvedValueOnce({ status: "pending", session_id: "test-link" });
expect(screen.queryByRole("switch", { name: "WhatsApp channel" })).not.toBeInTheDocument();
const installationGroup = await screen.findByRole("region", { name: "Requires dependencies" });
fireEvent.click(within(installationGroup).getByRole("button", { name: "Install WhatsApp" }));
const secondInstall = within(installationGroup).getByRole("button", { name: "Install WeChat" });
expect(secondInstall).toBeDisabled();
fireEvent.click(secondInstall);
expect(requestMutationMock).toHaveBeenCalledTimes(1);
await waitFor(() =>
expect(requestMutationMock).toHaveBeenCalledWith(
"settings.feature.enable",
{ name: "whatsapp", install_only: true },
150_000,
),
);
finishInstall(installedPayload);
expect(requestMutationMock).not.toHaveBeenCalledWith("settings.channel.connect.start", expect.anything(), expect.anything());
const restartButton = await within(installationGroup).findByRole("button", { name: "Restart nanobot" });
const blockedInstallHint = within(installationGroup).getByRole("group", { name: "Install WeChat" });
expect(secondInstall).toBeDisabled();
await act(async () => { blockedInstallHint.focus(); });
expect(await screen.findByRole("tooltip")).toHaveTextContent("Restart nanobot before installing another channel.");
await userEvent.setup().keyboard("{Enter}");
fireEvent.click(secondInstall);
expect(requestMutationMock).toHaveBeenCalledTimes(1);
expect(restartButton).toBeEnabled();
await act(async () => { restartButton.focus(); });
expect(await screen.findByRole("tooltip")).toHaveTextContent("Restart nanobot to apply updated channel support.");
expect(screen.queryByRole("switch", { name: "WhatsApp channel" })).not.toBeInTheDocument();
expect(restart).not.toHaveBeenCalled();
fireEvent.click(restartButton);
expect(restart).toHaveBeenCalledTimes(1);
expect(requestMutationMock.mock.calls.map(([action]) => action)).toEqual([
"settings.feature.enable",
]);
});
it("keeps a refreshed pending restart on its channel and restores switches after restart", async () => {
let restartPending = true;
const installed = { ...uninstalledConnectFeature("whatsapp"), installed: true };
const other = { ...catalogFeature("Existing", false), requires_restart: true };
vi.stubGlobal("fetch", vi.fn(async (input: RequestInfo | URL) => {
const url = String(input);
if (url === "/api/settings") {
return jsonResponse({ ...settingsPayload(), requires_restart: restartPending });
}
if (url === "/api/settings/nanobot-features") {
return jsonResponse({
features: [{ ...installed, restart_pending: restartPending }, other, uninstalledConnectFeature("weixin")],
enabled_count: 0,
requires_restart: restartPending,
});
}
return jsonResponse({});
}));
renderSettingsView({ initialSection: "channels" });
const installationGroup = await screen.findByRole("region", { name: "Requires dependencies" });
expect(await within(installationGroup).findByRole("button", { name: "Restart nanobot" })).toBeEnabled();
expect(screen.getByRole("switch", { name: "Existing channel" })).toBeDisabled();
restartPending = false;
await act(async () => { fireEvent(window, new Event("focus")); });
expect(await screen.findByRole("switch", { name: "WhatsApp channel" })).toBeEnabled();
expect(screen.getByRole("switch", { name: "WhatsApp channel" })).toHaveAttribute("aria-checked", "false");
expect(screen.getByRole("switch", { name: "Existing channel" })).toBeEnabled();
expect(screen.getByRole("button", { name: "Install WeChat" })).toBeEnabled();
});
it.each([
["feishu", "Feishu"],
["weixin", "WeChat"],
] as const)(
"installs %s support before mounting its custom connect panel",
async (name, displayName) => {
const feature = uninstalledConnectFeature(name);
vi.stubGlobal(
"fetch",
vi.fn(async (input: RequestInfo | URL) => {
const url = String(input);
if (url === "/api/settings") return jsonResponse(settingsPayload());
if (url === "/api/settings/cli-apps") {
return jsonResponse({ apps: [], installed_count: 0 });
}
if (url === "/api/settings/mcp-presets") {
return jsonResponse({ presets: [], installed_count: 0 });
}
if (url === "/api/settings/nanobot-features") {
return jsonResponse({ features: [feature], enabled_count: 0 });
}
return { ok: false, status: 404, json: async () => ({}) } as Response;
}),
);
requestMutationMock.mockResolvedValueOnce({
features: [{ ...feature, installed: true }],
enabled_count: 0,
requires_restart: false,
last_action: {
ok: true,
message: `Installed support for channel '${name}'`,
enabled: false,
},
});
if (name === "weixin") {
requestMutationMock.mockResolvedValueOnce({ status: "pending", session_id: "weixin-auto", qr_url: "https://example.com/weixin-login" });
}
renderSettingsView({ initialSection: "channels" });
fireEvent.click(await screen.findByRole("button", { name: `View ${displayName} settings` }));
expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
const installButton = screen.getByRole("button", { name: `Install ${displayName}` });
expect(installButton).toHaveFocus();
expect(installButton).toBeEnabled();
fireEvent.click(installButton);
await waitFor(() =>
expect(requestMutationMock).toHaveBeenCalledWith(
"settings.feature.enable",
{ name, install_only: true },
150_000,
),
);
await screen.findByRole("switch", { name: `${displayName} channel` });
fireEvent.click(screen.getByRole("button", { name: `View ${displayName} settings` }));
if (name === "weixin") {
await waitFor(() => expect(requestMutationMock).toHaveBeenCalledWith(
"settings.channel.connect.start", { channel: "weixin" }, 150_000,
));
expect(await screen.findByRole("img", { name: "WeChat login QR code" })).toBeInTheDocument();
expect(requestMutationMock.mock.calls.filter(([action]) => action === "settings.channel.connect.start")).toHaveLength(1);
} else {
expect(await screen.findByRole("button", { name: "Connect" })).toBeInTheDocument();
expect(screen.queryByRole("button", { name: "Create assistant" })).not.toBeInTheDocument();
expect(requestMutationMock.mock.calls.some(([action]) => action.startsWith("settings.channel.connect"))).toBe(false);
}
},
);
it("keeps WeChat login recovery visible across transient channel refreshes", async () => {
const expiredFeature: NanobotFeatureInfo = {
name: "weixin",
display_name: "WeChat",
webui: "webui/index.tsx",
type: "channel",
enabled: true,
configured: true,
installed: true,
requires_dependencies: true,
ready: false,
running: false,
runtime_status: "failed",
runtime_error: "WeChat login expired. Scan again to reconnect.",
status: "failed",
install_supported: true,
requires_restart: false,
};
let currentFeature = expiredFeature;
let featureFetches = 0;
vi.stubGlobal(
"fetch",
vi.fn(async (input: RequestInfo | URL) => {
const url = String(input);
if (url === "/api/settings") return jsonResponse(settingsPayload());
if (url === "/api/settings/cli-apps") {
return jsonResponse({ apps: [], installed_count: 0 });
}
if (url === "/api/settings/mcp-presets") {
return jsonResponse({ presets: [], installed_count: 0 });
}
if (url === "/api/settings/nanobot-features") {
featureFetches += 1;
return jsonResponse({ features: [currentFeature], enabled_count: 0 });
}
return { ok: false, status: 404, json: async () => ({}) } as Response;
}),
);
requestMutationMock.mockImplementation(async (action: string) => {
if (action === "settings.channel.connect.start") {
return {
status: "pending",
session_id: "weixin-recovery",
qr_url: "https://example.com/weixin-recovery",
};
}
return settingsPayload();
});
renderSettingsView({ initialSection: "channels" });
fireEvent.click(await screen.findByRole("button", { name: "View WeChat settings" }));
expect(await screen.findByRole("img", { name: "WeChat login QR code" })).toBeInTheDocument();
const fetchesBeforeRefresh = featureFetches;
currentFeature = {
...expiredFeature,
runtime_status: "stopped",
runtime_error: undefined,
status: "enabled",
};
window.dispatchEvent(new Event("focus"));
await waitFor(() => expect(featureFetches).toBeGreaterThan(fetchesBeforeRefresh));
expect(screen.getByRole("img", { name: "WeChat login QR code" })).toBeInTheDocument();
expect(screen.getByText("WeChat login expired. Scan again to reconnect.")).toBeInTheDocument();
expect(requestMutationMock.mock.calls.filter(([action]) => (
action === "settings.channel.connect.start"
))).toHaveLength(1);
});
it("announces an install-only failure and logs action context", async () => {
const feature = uninstalledConnectFeature("whatsapp");
const installError = new Error("Package install failed");
const consoleError = vi.spyOn(console, "error").mockImplementation(() => {});
try {
vi.stubGlobal(
"fetch",
vi.fn(async (input: RequestInfo | URL) => {
const url = String(input);
if (url === "/api/settings") return jsonResponse(settingsPayload());
if (url === "/api/settings/cli-apps") {
return jsonResponse({ apps: [], installed_count: 0 });
}
if (url === "/api/settings/mcp-presets") {
return jsonResponse({ presets: [], installed_count: 0 });
}
if (url === "/api/settings/nanobot-features") {
return jsonResponse({ features: [feature], enabled_count: 0 });
}
return { ok: false, status: 404, json: async () => ({}) } as Response;
}),
);
requestMutationMock.mockRejectedValueOnce(installError);
renderSettingsView({ initialSection: "channels" });
fireEvent.click(await screen.findByRole("button", { name: "Install WhatsApp" }));
expect(await screen.findByRole("alert")).toHaveTextContent("Package install failed");
expect(screen.getByRole("button", { name: "Install WhatsApp" })).toBeEnabled();
expect(consoleError).toHaveBeenCalledWith(
"nanobot feature action failed",
expect.objectContaining({
action: "enable",
name: "whatsapp",
installOnly: true,
error: installError,
}),
);
} finally {
consoleError.mockRestore();
}
});
it("shows an enabled channel with missing support as failed", async () => {
const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
const url = String(input);
if (url === "/api/settings") return jsonResponse(settingsPayload());
if (url === "/api/settings/cli-apps") return jsonResponse({ apps: [], installed_count: 0 });
if (url === "/api/settings/mcp-presets") return jsonResponse({ presets: [], installed_count: 0 });
if (url === "/api/settings/nanobot-features") {
return jsonResponse({
features: [{
name: "matrix",
display_name: "Matrix",
type: "channel",
enabled: true,
running: false,
runtime_status: "failed",
runtime_error: "Channel dependencies could not be installed. Check gateway logs.",
installed: false,
requires_dependencies: true,
ready: false,
status: "missing_dependency",
install_supported: true,
requires_restart: true,
}],
enabled_count: 1,
});
}
return { ok: false, status: 404, json: async () => ({}) } as Response;
});
vi.stubGlobal("fetch", fetchMock);
requestMutationMock.mockResolvedValueOnce({
features: [{
name: "matrix",
display_name: "Matrix",
type: "channel",
enabled: true,
installed: true,
requires_dependencies: true,
ready: true,
status: "enabled",
install_supported: true,
requires_restart: true,
}],
enabled_count: 1,
last_action: { ok: true, message: "Enabled channel 'matrix'", enabled: true },
});
renderSettingsView({ initialSection: "channels" });
expect((await screen.findAllByText("Failed")).length).toBeGreaterThan(0);
expect(screen.queryByRole("switch", { name: "Matrix channel" })).not.toBeInTheDocument();
fireEvent.click(screen.getByRole("button", { name: "Install Matrix" }));
await waitFor(() =>
expect(requestMutationMock).toHaveBeenCalledWith(
"settings.feature.enable",
{ name: "matrix", install_only: true },
150_000,
),
);
});
it("shows a configured channel as failed when its runtime did not start", async () => {
const runtimeError = "Channel failed to start. Check gateway logs.";
vi.stubGlobal(
"fetch",
vi.fn(async (input: RequestInfo | URL) => {
const url = String(input);
if (url === "/api/settings") return jsonResponse(settingsPayload());
if (url === "/api/settings/cli-apps") return jsonResponse({ apps: [], installed_count: 0 });
if (url === "/api/settings/mcp-presets") return jsonResponse({ presets: [], installed_count: 0 });
if (url === "/api/settings/nanobot-features") {
return jsonResponse({
features: [{
name: "matrix",
display_name: "Matrix",
type: "channel",
enabled: true,
configured: true,
installed: true,
ready: false,
running: false,
runtime_status: "failed",
runtime_error: runtimeError,
status: "failed",
install_supported: true,
requires_restart: false,
}],
enabled_count: 0,
});
}
return { ok: false, status: 404, json: async () => ({}) } as Response;
}),
);
renderSettingsView({ initialSection: "channels" });
fireEvent.click(await screen.findByRole("button", { name: "View Matrix settings" }));
expect(screen.getAllByText("Failed").length).toBeGreaterThan(0);
expect(screen.getByText(runtimeError)).toBeInTheDocument();
expect(screen.getByLabelText("Matrix channel")).toHaveAttribute(
"aria-checked",
"false",
);
});
it("starts Feishu connect in WebUI instead of showing a CLI command", async () => {
const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
const url = String(input);
if (url === "/api/settings") return jsonResponse(settingsPayload());
if (url === "/api/settings/cli-apps") return jsonResponse({ apps: [], installed_count: 0 });
if (url === "/api/settings/mcp-presets") return jsonResponse({ presets: [], installed_count: 0 });
if (url === "/api/settings/nanobot-features") {
return jsonResponse({
features: [{
name: "feishu",
display_name: "Feishu",
webui: "webui/index.tsx",
type: "channel",
enabled: false,
configured: false,
installed: true,
ready: false,
status: "not_enabled",
install_supported: true,
requires_restart: true,
}],
enabled_count: 0,
});
}
return { ok: false, status: 404, json: async () => ({}) } as Response;
});
vi.stubGlobal("fetch", fetchMock);
requestMutationMock.mockResolvedValueOnce({
session_id: "feishu-session",
status: "pending",
qr_url: "https://accounts.feishu.cn/login?device_code=device",
domain: "feishu",
interval_ms: 5000,
expires_at_ms: Date.now() + 600_000,
message: "Scan with Feishu or Lark to connect.",
});
renderSettingsView({ initialSection: "channels" });
fireEvent.click(await screen.findByRole("button", { name: "View Feishu settings" }));
fireEvent.click(await screen.findByRole("button", { name: "Connect" }));
await waitFor(() =>
expect(requestMutationMock).toHaveBeenCalledWith(
"settings.channel.connect.start",
{ channel: "feishu", domain: "feishu", instance_id: "default", mode: "replace" },
150_000,
),
);
expect(await screen.findByText("Scan with Feishu")).toBeInTheDocument();
expect(await screen.findByText("Waiting for authorization...")).toBeInTheDocument();
});
it("starts Feishu connect from the default assistant action", async () => {
const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
const url = String(input);
if (url === "/api/settings") return jsonResponse(settingsPayload());
if (url === "/api/settings/cli-apps") return jsonResponse({ apps: [], installed_count: 0 });
if (url === "/api/settings/mcp-presets") return jsonResponse({ presets: [], installed_count: 0 });
if (url === "/api/settings/nanobot-features") {
return jsonResponse({
features: [{
name: "feishu",
display_name: "Feishu",
webui: "webui/index.tsx",
type: "channel",
enabled: false,
configured: false,
installed: true,
ready: false,
status: "not_enabled",
install_supported: true,
requires_restart: true,
}],
enabled_count: 0,
});
}
return { ok: false, status: 404, json: async () => ({}) } as Response;
});
vi.stubGlobal("fetch", fetchMock);
requestMutationMock.mockResolvedValueOnce({
session_id: "feishu-switch-session",
status: "pending",
qr_url: "https://accounts.feishu.cn/login?device_code=switch-device",
domain: "feishu",
interval_ms: 5000,
expires_at_ms: Date.now() + 600_000,
message: "Scan with Feishu or Lark to connect.",
});
renderSettingsView({ initialSection: "channels" });
fireEvent.click(await screen.findByRole("button", { name: "View Feishu settings" }));
fireEvent.click(await screen.findByRole("button", { name: "Connect" }));
await waitFor(() =>
expect(requestMutationMock).toHaveBeenCalledWith(
"settings.channel.connect.start",
{ channel: "feishu", domain: "feishu", instance_id: "default", mode: "replace" },
150_000,
),
);
expect(await screen.findByText("Scan with Feishu")).toBeInTheDocument();
});
it("enables configured Feishu assistant without starting a new connect flow", async () => {
const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
const url = String(input);
if (url === "/api/settings") return jsonResponse(settingsPayload());
if (url === "/api/settings/cli-apps") return jsonResponse({ apps: [], installed_count: 0 });
if (url === "/api/settings/mcp-presets") return jsonResponse({ presets: [], installed_count: 0 });
if (url === "/api/settings/nanobot-features") {
return jsonResponse({
features: [{
name: "feishu",
display_name: "Feishu",
webui: "webui/index.tsx",
type: "channel",
enabled: false,
configured: true,
installed: true,
ready: false,
status: "not_enabled",
install_supported: true,
requires_restart: true,
}],
enabled_count: 0,
});
}
return { ok: false, status: 404, json: async () => ({}) } as Response;
});
vi.stubGlobal("fetch", fetchMock);
requestMutationMock.mockImplementation(async (action: string) => {
if (action === "settings.feature.enable") {
return {
features: [{
name: "feishu",
display_name: "Feishu",
webui: "webui/index.tsx",
type: "channel",
enabled: true,
running: true,
runtime_status: "running",
configured: true,
instances: [{
id: "default",
name: "nanobot",
enabled: true,
running: true,
runtime_status: "running",
configured: true,
config_values: { "channels.feishu.appId": "cli_test" },
configured_fields: [
"channels.feishu.appId",
"channels.feishu.appSecret",
],
}],
installed: true,
ready: true,
status: "enabled",
install_supported: true,
requires_restart: true,
}],
enabled_count: 1,
requires_restart: false,
last_action: { ok: true, message: "Enabled channel 'feishu'", enabled: true },
};
}
if (action === "settings.channel.connect.start") {
throw new Error("Feishu connect should not start when credentials are already configured");
}
return settingsPayload();
});
renderSettingsView({ initialSection: "channels" });
fireEvent.click((await screen.findAllByRole("button", { name: /^View .+ settings$/ }))[0]);
fireEvent.click(await screen.findByRole("switch", { name: "nanobot assistant" }));
await waitFor(() =>
expect(requestMutationMock).toHaveBeenCalledWith(
"settings.feature.enable",
{ name: "feishu", instance_id: "default" },
150_000,
),
);
expect(requestMutationMock.mock.calls.some(([action]) => (
action === "settings.channel.connect.start"
))).toBe(false);
expect(screen.getByRole("switch", { name: "nanobot assistant" })).toHaveAttribute(
"aria-checked",
"true",
);
});
it("opens and saves each Feishu assistant's settings directly from Advanced", async () => {
vi.stubGlobal(
"fetch",
vi.fn(async (input: RequestInfo | URL) => {
const url = String(input);
if (url === "/api/settings") return jsonResponse(settingsPayload());
if (url === "/api/settings/cli-apps") return jsonResponse({ apps: [], installed_count: 0 });
if (url === "/api/settings/mcp-presets") return jsonResponse({ presets: [], installed_count: 0 });
if (url === "/api/settings/nanobot-features") {
return jsonResponse({
features: [{
name: "feishu",
display_name: "Feishu",
webui: "webui/index.tsx",
type: "channel",
enabled: true,
configured: true,
installed: true,
ready: true,
status: "enabled",
install_supported: true,
requires_restart: true,
setup: channelSetupContract("feishu"),
instances: [
{
id: "default",
name: "nanobot",
display_name: "Support Bot",
avatar_url: "https://example.com/support.png",
enabled: true,
configured: true,
config_values: {
"channels.feishu.appId": "cli_default",
"channels.feishu.domain": "feishu",
"channels.feishu.groupPolicy": "mention",
"channels.feishu.allowFrom": "",
"channels.feishu.topicIsolation": "true",
},
configured_fields: [
"channels.feishu.appId",
"channels.feishu.appSecret",
"channels.feishu.domain",
"channels.feishu.groupPolicy",
"channels.feishu.topicIsolation",
],
},
{
id: "product",
name: "Product bot",
display_name: "Product Helper",
avatar_url: "https://example.com/product.png",
enabled: false,
configured: true,
config_values: { "channels.feishu.appId": "cli_product" },
configured_fields: [
"channels.feishu.appId",
"channels.feishu.appSecret",
],
},
],
}],
enabled_count: 1,
});
}
return { ok: false, status: 404, json: async () => ({}) } as Response;
}),
);
renderSettingsView({ initialSection: "channels" });
fireEvent.click((await screen.findAllByRole("button", { name: /^View .+ settings$/ }))[0]);
expect(await screen.findByText("Product Helper")).toBeInTheDocument();
expect(screen.getAllByText("Support Bot")).toHaveLength(1);
expect(document.querySelector('img[src="https://example.com/support.png"]')).toBeTruthy();
const support = within(screen.getByText("Support Bot").closest("article")!);
const product = within(screen.getByText("Product Helper").closest("article")!);
const supportAdvanced = support.getByRole("button", { name: "Advanced" });
const productAdvanced = product.getByRole("button", { name: "Advanced" });
expect(supportAdvanced).toBeVisible();
expect(productAdvanced).toBeVisible();
supportAdvanced.focus();
await userEvent.setup().keyboard("[Enter]");
expect(supportAdvanced).toHaveAttribute("aria-expanded", "true");
expect(support.getByLabelText("App ID")).toBeVisible();
expect(support.getByLabelText("App ID")).toHaveValue("cli_default");
expect(support.getByRole("group", { name: "Topic sessions" })).toBeVisible();
fireEvent.click(productAdvanced);
expect(supportAdvanced).toHaveAttribute("aria-expanded", "false");
expect(productAdvanced).toHaveAttribute("aria-expanded", "true");
expect(product.getByLabelText("App ID")).toHaveValue("cli_product");
fireEvent.change(product.getByLabelText("App ID"), { target: { value: "cli_updated" } });
const featureRequests = () => vi.mocked(fetch).mock.calls
.filter(([input]) => String(input) === "/api/settings/nanobot-features").length;
const beforeRefresh = featureRequests();
await act(async () => { fireEvent(window, new Event("focus")); });
await waitFor(() => expect(featureRequests()).toBeGreaterThan(beforeRefresh));
expect(product.getByLabelText("App ID")).toHaveValue("cli_updated");
fireEvent.click(productAdvanced);
expect(productAdvanced).toHaveAttribute("aria-expanded", "false");
fireEvent.click(productAdvanced);
expect(product.getByLabelText("App ID")).toHaveValue("cli_updated");
fireEvent.click(product.getByRole("button", { name: "Save settings" }));
await waitFor(() => expect(requestMutationMock).toHaveBeenCalledWith(
"settings.channel.configure",
expect.objectContaining({
name: "feishu",
instance_id: "product",
enable: false,
values: expect.objectContaining({ "channels.feishu.appId": "cli_updated" }),
}),
150_000,
));
expect(await screen.findByText("Settings saved.")).toBeVisible();
productAdvanced.focus();
await userEvent.setup().keyboard("[Space]");
expect(productAdvanced).toHaveAttribute("aria-expanded", "false");
fireEvent.click(supportAdvanced);
expect(support.getByLabelText("App ID")).toHaveValue("cli_default");
});
it("opens WeChat advanced settings from the header and preserves autosave", async () => {
const feature: NanobotFeatureInfo = {
name: "weixin",
display_name: "WeChat",
webui: "webui/index.tsx",
type: "channel",
installed: true,
enabled: false,
configured: true,
ready: true,
status: "not_enabled",
install_supported: true,
requires_restart: false,
setup: { fields: [
channelSetupField("weixin", "sendProgress", "bool"),
channelSetupField("weixin", "baseUrl"),
channelSetupField("weixin", "token", "secret"),
] },
config_values: {
"channels.weixin.sendProgress": "true",
"channels.weixin.baseUrl": "https://api.example.com",
},
};
vi.stubGlobal("fetch", vi.fn(async (input: RequestInfo | URL) => {
if (String(input) === "/api/settings") return jsonResponse(settingsPayload());
if (String(input) === "/api/settings/nanobot-features") {
return jsonResponse({ features: [feature], enabled_count: 0 });
}
return { ok: false, status: 404, json: async () => ({}) } as Response;
}));
renderSettingsView({ initialSection: "channels" });
fireEvent.click(await screen.findByRole("button", { name: "View WeChat settings" }));
const advanced = await screen.findByRole("button", { name: "Advanced" });
advanced.focus();
await userEvent.setup().keyboard("[Enter]");
const apiUrl = screen.getByRole("textbox", { name: "API URL" });
expect(apiUrl).toBeVisible();
expect(screen.queryByLabelText("Token")).not.toBeInTheDocument();
fireEvent.change(apiUrl, { target: { value: "https://updated.example.com" } });
await waitFor(() => expect(requestMutationMock).toHaveBeenCalledWith(
"settings.channel.configure",
expect.objectContaining({
name: "weixin",
enable: false,
values: expect.objectContaining({ "channels.weixin.baseUrl": "https://updated.example.com" }),
}),
150_000,
));
fireEvent.click(advanced);
fireEvent.click(advanced);
expect(screen.getByRole("textbox", { name: "API URL" })).toHaveValue("https://updated.example.com");
});
it("renders external multi-instance channels from the shared contract", async () => {
const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
const url = String(input);
if (url === "/api/settings") return jsonResponse(settingsPayload());
if (url === "/api/settings/cli-apps") return jsonResponse({ apps: [], installed_count: 0 });
if (url === "/api/settings/mcp-presets") return jsonResponse({ presets: [], installed_count: 0 });
if (url === "/api/settings/nanobot-features") {
return jsonResponse({
features: [{
name: "multiplugin",
display_name: "Multi Plugin",
type: "channel",
enabled: true,
running: true,
runtime_status: "running",
configured: true,
installed: true,
ready: true,
status: "enabled",
install_supported: true,
requires_restart: false,
setup: {
fields: [
channelSetupField("multiplugin", "token", "secret", { required: true }),
channelSetupField("multiplugin", "region", "enum", {
choices: ["eu", "us"],
defaultValue: "us",
}),
],
},
instances: [
{
id: "default",
name: "Default worker",
enabled: true,
running: true,
runtime_status: "running",
configured: true,
config_values: { "channels.multiplugin.region": "us" },
configured_fields: ["channels.multiplugin.token"],
},
{
id: "product",
name: "Product worker",
enabled: true,
running: true,
runtime_status: "running",
configured: true,
config_values: { "channels.multiplugin.region": "eu" },
configured_fields: ["channels.multiplugin.token"],
},
],
}],
enabled_count: 1,
});
}
return { ok: false, status: 404, json: async () => ({}) } as Response;
});
vi.stubGlobal("fetch", fetchMock);
renderSettingsView({ initialSection: "channels" });
fireEvent.click((await screen.findAllByRole("button", { name: /^View .+ settings$/ }))[0]);
expect(await screen.findByText("Default worker")).toBeInTheDocument();
expect(screen.getByRole("switch", { name: "Default worker instance" })).toHaveAttribute(
"aria-checked",
"true",
);
expect(screen.getByRole("switch", { name: "Product worker instance" })).toHaveAttribute(
"aria-checked",
"true",
);
fireEvent.click(within(screen.getByText("Product worker").closest("article")!)
.getByRole("button", { name: "Advanced" }));
expect(screen.getByRole("radio", { name: "Eu" })).toBeChecked();
});
it("shows a single Feishu assistant without a duplicate assistant list", async () => {
const feishuPayload = {
features: [{
name: "feishu",
display_name: "Feishu",
webui: "webui/index.tsx",
type: "channel",
enabled: true,
configured: true,
installed: true,
ready: true,
status: "enabled",
running: true,
runtime_status: "running",
install_supported: true,
requires_restart: true,
instances: [{
id: "default",
name: "nanobot",
display_name: "Support Bot",
avatar_url: "https://example.com/support.png",
enabled: true,
running: true,
runtime_status: "running",
configured: true,
config_values: { "channels.feishu.appId": "cli_support" },
configured_fields: [
"channels.feishu.appId",
"channels.feishu.appSecret",
],
}],
}],
enabled_count: 1,
};
vi.stubGlobal(
"fetch",
vi.fn(async (input: RequestInfo | URL) => {
const url = String(input);
if (url === "/api/settings") return jsonResponse(settingsPayload());
if (url === "/api/settings/cli-apps") return jsonResponse({ apps: [], installed_count: 0 });
if (url === "/api/settings/mcp-presets") return jsonResponse({ presets: [], installed_count: 0 });
if (url === "/api/settings/nanobot-features") return jsonResponse(feishuPayload);
return { ok: false, status: 404, json: async () => ({}) } as Response;
}),
);
requestMutationMock.mockResolvedValueOnce(feishuPayload);
renderSettingsView({ initialSection: "channels" });
fireEvent.click((await screen.findAllByRole("button", { name: /^View .+ settings$/ }))[0]);
await screen.findByText("Support Bot");
expect(screen.getAllByText("Support Bot")).toHaveLength(1);
expect(screen.getByRole("switch", { name: "Support Bot assistant" })).toHaveAttribute(
"aria-checked",
"true",
);
fireEvent.click(screen.getByRole("button", { name: "Advanced" }));
expect(screen.getByLabelText("App ID")).toBeInTheDocument();
expect(document.querySelector('img[src="https://example.com/support.png"]')).toBeTruthy();
});
it("does not call a configured Feishu assistant connected after runtime failure", async () => {
const runtimeError = "Channel failed to start. Check gateway logs.";
vi.stubGlobal(
"fetch",
vi.fn(async (input: RequestInfo | URL) => {
const url = String(input);
if (url === "/api/settings") return jsonResponse(settingsPayload());
if (url === "/api/settings/cli-apps") return jsonResponse({ apps: [], installed_count: 0 });
if (url === "/api/settings/mcp-presets") return jsonResponse({ presets: [], installed_count: 0 });
if (url === "/api/settings/nanobot-features") {
return jsonResponse({
features: [{
name: "feishu",
display_name: "Feishu",
webui: "webui/index.tsx",
type: "channel",
enabled: true,
configured: true,
installed: true,
ready: false,
running: false,
runtime_status: "failed",
runtime_error: runtimeError,
status: "failed",
install_supported: true,
requires_restart: false,
instances: [{
id: "default",
name: "test",
enabled: true,
configured: true,
running: false,
runtime_status: "failed",
runtime_error: runtimeError,
config_values: { "channels.feishu.appId": "cli_test" },
configured_fields: [
"channels.feishu.appId",
"channels.feishu.appSecret",
],
}],
}],
enabled_count: 0,
});
}
return { ok: false, status: 404, json: async () => ({}) } as Response;
}),
);
renderSettingsView({ initialSection: "channels" });
fireEvent.click((await screen.findAllByRole("button", { name: /^View .+ settings$/ }))[0]);
expect(screen.getAllByText("Failed").length).toBeGreaterThan(0);
expect(screen.getByText(runtimeError)).toBeInTheDocument();
expect(screen.getByRole("switch", { name: "test assistant" })).toHaveAttribute(
"aria-checked",
"false",
);
});
it("preserves advanced field edits when collapsed and reopened with the keyboard", async () => {
vi.stubGlobal(
"fetch",
vi.fn(async (input: RequestInfo | URL) => {
const url = String(input);
if (url === "/api/settings") return jsonResponse(settingsPayload());
if (url === "/api/settings/cli-apps") return jsonResponse({ apps: [], installed_count: 0 });
if (url === "/api/settings/mcp-presets") return jsonResponse({ presets: [], installed_count: 0 });
if (url === "/api/settings/nanobot-features") {
return jsonResponse({
features: [{
name: "discord",
display_name: "Discord",
webui: "webui/index.ts",
type: "channel",
enabled: true,
installed: true,
ready: true,
status: "enabled",
install_supported: true,
requires_restart: true,
setup: channelSetupContract("discord"),
}],
enabled_count: 1,
});
}
return { ok: false, status: 404, json: async () => ({}) } as Response;
}),
);
renderSettingsView({ initialSection: "channels" });
fireEvent.click(await screen.findByRole("button", { name: "View Discord settings" }));
const advanced = screen.getByRole("button", { name: "Advanced" });
advanced.focus();
await userEvent.setup().keyboard("[Enter]");
expect(advanced).toHaveAttribute("aria-expanded", "true");
const behavior = screen.getByRole("group", { name: "Group rules" });
expect(behavior).toBeVisible();
expect(within(behavior).getByRole("radio", { name: "Mentions only" })).toBeChecked();
expect(within(behavior).getByRole("radio", { name: "All messages" })).toBeInTheDocument();
fireEvent.click(within(behavior).getByRole("radio", { name: "All messages" }));
expect(within(behavior).getByRole("radio", { name: "All messages" })).toBeChecked();
fireEvent.click(advanced);
await waitFor(() => expect(advanced).toHaveAttribute("aria-expanded", "false"));
expect(behavior).not.toBeVisible();
advanced.focus();
await userEvent.setup().keyboard("[Space]");
expect(advanced).toHaveAttribute("aria-expanded", "true");
expect(behavior).toBeVisible();
expect(within(behavior).getByRole("radio", { name: "All messages" })).toBeChecked();
});
it("uses a list-to-detail navigation stack on compact screens", async () => {
vi.stubGlobal(
"matchMedia",
vi.fn((query: string) => ({
matches: false,
media: query,
onchange: null,
addEventListener: vi.fn(),
removeEventListener: vi.fn(),
addListener: vi.fn(),
removeListener: vi.fn(),
dispatchEvent: vi.fn(),
})),
);
vi.stubGlobal(
"fetch",
vi.fn(async (input: RequestInfo | URL) => {
const url = String(input);
if (url === "/api/settings") return jsonResponse(settingsPayload());
if (url === "/api/settings/cli-apps") return jsonResponse({ apps: [], installed_count: 0 });
if (url === "/api/settings/mcp-presets") return jsonResponse({ presets: [], installed_count: 0 });
if (url === "/api/settings/nanobot-features") {
return jsonResponse({
features: [{
name: "email",
display_name: "Email",
type: "channel",
enabled: false,
installed: true,
ready: false,
status: "not_enabled",
install_supported: true,
requires_restart: true,
}],
enabled_count: 0,
});
}
return { ok: false, status: 404, json: async () => ({}) } as Response;
}),
);
renderSettingsView({ initialSection: "channels" });
const emailRow = await screen.findByRole("button", { name: "View Email settings" });
expect(emailRow).toBeVisible();
expect(screen.getByRole("switch", { name: "Email channel" })).toBeInTheDocument();
fireEvent.click(emailRow);
expect(screen.getByRole("dialog")).toHaveFocus();
expect(within(screen.getByRole("dialog")).getByRole("heading", { name: "Email" })).toBeVisible();
fireEvent.click(screen.getByRole("button", { name: "Close" }));
expect(screen.getByRole("button", { name: "View Email settings" })).toBeInTheDocument();
});
it("saves Discord credentials from the channel setup panel", async () => {
const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
const url = String(input);
if (url === "/api/settings") return jsonResponse(settingsPayload());
if (url === "/api/settings/cli-apps") return jsonResponse({ apps: [], installed_count: 0 });
if (url === "/api/settings/mcp-presets") return jsonResponse({ presets: [], installed_count: 0 });
if (url === "/api/settings/nanobot-features") {
return jsonResponse({
features: [{
name: "discord",
display_name: "Discord",
webui: "webui/index.ts",
type: "channel",
enabled: false,
configured: false,
installed: true,
ready: false,
status: "not_enabled",
install_supported: true,
requires_restart: true,
setup: channelSetupContract("discord"),
}],
enabled_count: 0,
});
}
return { ok: false, status: 404, json: async () => ({}) } as Response;
});
vi.stubGlobal("fetch", fetchMock);
requestMutationMock
.mockResolvedValueOnce({
name: "discord",
status: "ready",
checks: [],
missing_fields: [],
can_enable: true,
requires_restart: false,
})
.mockResolvedValueOnce({
name: "discord",
saved: true,
saved_keys: [
"channels.discord.token",
"channels.discord.allowChannels",
"channels.discord.groupPolicy",
],
nanobot_features: {
features: [{
name: "discord",
display_name: "Discord",
webui: "webui/index.ts",
type: "channel",
enabled: true,
running: true,
runtime_status: "running",
configured: true,
installed: true,
ready: true,
status: "enabled",
install_supported: true,
requires_restart: true,
setup: channelSetupContract("discord"),
}],
enabled_count: 1,
requires_restart: false,
},
});
renderSettingsView({ initialSection: "channels" });
fireEvent.click(await screen.findByRole("button", { name: "View Discord settings" }));
fireEvent.pointerDown(screen.getByRole("button", { name: "Help" }), { button: 0, ctrlKey: false });
expect(await screen.findByRole("menuitem", { name: "Open Discord setup" })).toHaveAttribute(
"href",
"https://nanobot.wiki/docs/0.2.2/getting-started/chat-apps#discord",
);
fireEvent.keyDown(screen.getByRole("menu"), { key: "Escape" });
expect(screen.getByLabelText("Discord channel")).toBeEnabled();
fireEvent.change(screen.getByPlaceholderText("Discord bot token"), {
target: { value: "discord-token" },
});
fireEvent.click(screen.getByRole("button", { name: "Advanced" }));
fireEvent.change(screen.getByLabelText("Allowed channels"), {
target: { value: "123, 456" },
});
fireEvent.click(within(screen.getByRole("group", { name: "Group rules" })).getByRole(
"radio",
{ name: "All messages" },
));
fireEvent.click(screen.getByRole("switch", { name: "Enable channel" }));
await waitFor(() =>
expect(
requestMutationMock.mock.calls.some(([action]) => (
action === "settings.channel.configure"
)),
).toBe(true),
);
expect(requestMutationMock).toHaveBeenCalledWith(
"settings.channel.configure",
{
name: "discord",
enable: true,
values: {
"channels.discord.token": "discord-token",
"channels.discord.allowChannels": "123, 456",
"channels.discord.groupPolicy": "open",
},
},
150_000,
);
expect(await screen.findByText("Checked and enabled.")).toBeInTheDocument();
expect(screen.getByLabelText("Discord channel")).toHaveAttribute(
"aria-checked",
"true",
);
});
it("requires Email consent to be granted before validating or enabling", async () => {
vi.stubGlobal(
"fetch",
vi.fn(async (input: RequestInfo | URL) => {
const url = String(input);
if (url === "/api/settings") return jsonResponse(settingsPayload());
if (url === "/api/settings/cli-apps") return jsonResponse({ apps: [], installed_count: 0 });
if (url === "/api/settings/mcp-presets") return jsonResponse({ presets: [], installed_count: 0 });
if (url === "/api/settings/nanobot-features") {
return jsonResponse({
features: [{
name: "email",
display_name: "Email",
webui: "webui/index.ts",
type: "channel",
enabled: false,
configured: false,
installed: true,
ready: false,
status: "not_enabled",
install_supported: true,
requires_restart: false,
setup: channelSetupContract("email"),
}],
enabled_count: 0,
});
}
return { ok: false, status: 404, json: async () => ({}) } as Response;
}),
);
requestMutationMock.mockImplementation(async (action: string) => {
if (action === "settings.channel.validate") {
return {
name: "email",
status: "ready",
checks: [],
missing_fields: [],
can_enable: true,
requires_restart: false,
};
}
if (action === "settings.channel.configure") {
return {
name: "email",
saved: true,
saved_keys: [
"channels.email.consentGranted",
"channels.email.imapHost",
"channels.email.imapUsername",
"channels.email.imapPassword",
"channels.email.smtpHost",
"channels.email.smtpUsername",
"channels.email.smtpPassword",
],
};
}
return settingsPayload();
});
renderSettingsView({ initialSection: "channels" });
fireEvent.click(await screen.findByRole("button", { name: "View Email settings" }));
expect(screen.getByText("Receiving mail")).toBeInTheDocument();
expect(screen.getByText("Sending mail")).toBeInTheDocument();
expect(screen.queryByRole("button", { name: "Gmail" })).not.toBeInTheDocument();
fireEvent.click(screen.getByRole("button", { name: "Advanced" }));
expect(screen.getByText("Quick fill")).toBeVisible();
const trustedServices = screen.getByLabelText("Trusted authentication services");
expect(trustedServices).toBeVisible();
fireEvent.change(trustedServices, { target: { value: "mx.receiver.example" } });
fireEvent.change(screen.getByLabelText("IMAP host"), { target: { value: "imap.custom.test" } });
fireEvent.click(screen.getByRole("button", { name: "Gmail" }));
expect(screen.getByLabelText("IMAP host")).toHaveValue("imap.custom.test");
expect(screen.getByLabelText("SMTP host")).toHaveValue("smtp.gmail.com");
fireEvent.click(screen.getByRole("button", { name: "Outlook" }));
expect(screen.getByLabelText("SMTP host")).toHaveValue("smtp.gmail.com");
fireEvent.change(screen.getByLabelText("IMAP host"), { target: { value: "imap.example.com" } });
fireEvent.change(screen.getByLabelText("IMAP username"), { target: { value: "[email protected]" } });
fireEvent.change(screen.getByLabelText("IMAP password"), { target: { value: "imap-secret" } });
fireEvent.change(screen.getByLabelText("SMTP host"), { target: { value: "smtp.example.com" } });
fireEvent.change(screen.getByLabelText("SMTP username"), { target: { value: "[email protected]" } });
fireEvent.change(screen.getByLabelText("SMTP password"), { target: { value: "smtp-secret" } });
const consentGroup = screen.getByRole("group", { name: "Email access" });
const notGranted = within(consentGroup).getByRole("radio", { name: "Not granted" });
const granted = within(consentGroup).getByRole("radio", { name: "Granted" });
expect(notGranted).toBeChecked();
fireEvent.click(screen.getByRole("switch", { name: "Enable channel" }));
await waitFor(() => expect(granted).toHaveFocus());
expect(consentGroup).toHaveAttribute("aria-invalid", "true");
expect(notGranted).toHaveAttribute("aria-invalid", "true");
expect(granted).toHaveAttribute("aria-invalid", "true");
expect(screen.getByText("Required to complete setup.")).toBeInTheDocument();
expect(requestMutationMock.mock.calls.some(([action, args]) => (
action === "settings.channel.validate" || (action === "settings.channel.configure" && args.enable === true)
))).toBe(false);
fireEvent.click(granted);
expect(consentGroup).toHaveAttribute("aria-invalid", "false");
expect(notGranted).toHaveAttribute("aria-invalid", "false");
expect(granted).toHaveAttribute("aria-invalid", "false");
expect(screen.queryByText("Required to complete setup.")).not.toBeInTheDocument();
fireEvent.click(screen.getByRole("switch", { name: "Enable channel" }));
await waitFor(() =>
expect(requestMutationMock).toHaveBeenCalledWith(
"settings.channel.validate",
expect.objectContaining({
name: "email",
values: expect.objectContaining({
"channels.email.consentGranted": "true",
"channels.email.trustedAuthservIds": "mx.receiver.example",
}),
}),
20_000,
),
);
await waitFor(() =>
expect(requestMutationMock).toHaveBeenCalledWith(
"settings.channel.configure",
expect.objectContaining({ name: "email", enable: true }),
150_000,
),
);
});
it("commits Email edits on blur and waits for the save before closing", async () => {
let resolveConfigure: ((value: Record<string, unknown>) => void) | undefined;
const configureResult = new Promise<Record<string, unknown>>((resolve) => {
resolveConfigure = resolve;
});
vi.stubGlobal(
"fetch",
vi.fn(async (input: RequestInfo | URL) => {
const url = String(input);
if (url === "/api/settings") return jsonResponse(settingsPayload());
if (url === "/api/settings/cli-apps") return jsonResponse({ apps: [], installed_count: 0 });
if (url === "/api/settings/mcp-presets") return jsonResponse({ presets: [], installed_count: 0 });
if (url === "/api/settings/nanobot-features") {
return jsonResponse({
features: [configuredEmailFeature({ running: true, runtime_status: "running" })],
enabled_count: 1,
});
}
return { ok: false, status: 404, json: async () => ({}) } as Response;
}),
);
requestMutationMock.mockImplementation((action: string) => {
if (action === "settings.channel.configure") return configureResult;
return Promise.resolve(settingsPayload());
});
renderSettingsView({ initialSection: "channels" });
fireEvent.click(await screen.findByRole("button", { name: "View Email settings" }));
const dialog = screen.getByRole("dialog");
expect(within(dialog).queryByRole("button", { name: "Save" })).not.toBeInTheDocument();
fireEvent.click(within(dialog).getByRole("button", { name: "Advanced" }));
expect(within(dialog).queryByRole("button", { name: "Gmail" })).not.toBeInTheDocument();
fireEvent.change(screen.getByLabelText("IMAP host"), {
target: { value: "imap.changed.example.com" },
});
fireEvent.blur(screen.getByLabelText("IMAP host"));
await waitFor(() => expect(requestMutationMock).toHaveBeenCalledWith(
"settings.channel.configure",
expect.objectContaining({
name: "email",
values: expect.objectContaining({
"channels.email.imapHost": "imap.changed.example.com",
}),
}),
150_000,
));
expect(within(dialog).getByText("Saving")).toBeVisible();
fireEvent.click(within(dialog).getByRole("button", { name: "Close" }));
expect(screen.getByRole("dialog")).toBeInTheDocument();
await act(async () => {
resolveConfigure?.({ name: "email", saved: true, saved_keys: ["channels.email.imapHost"] });
await configureResult;
});
await waitFor(() => expect(screen.queryByRole("dialog")).not.toBeInTheDocument());
});
it("keeps focused Email advanced edits unsaved when an earlier blur save completes", async () => {
const user = userEvent.setup();
let resolveConfigure: ((value: Record<string, unknown>) => void) | undefined;
const configureResult = new Promise<Record<string, unknown>>((resolve) => {
resolveConfigure = resolve;
});
const emailFeature = configuredEmailFeature();
vi.stubGlobal("fetch", vi.fn(async (input: RequestInfo | URL) => {
const url = String(input);
if (url === "/api/settings") return jsonResponse(settingsPayload());
if (url === "/api/settings/nanobot-features") {
return jsonResponse({ features: [emailFeature], enabled_count: 1 });
}
return jsonResponse({});
}));
requestMutationMock
.mockResolvedValue({ name: "email", saved: true, saved_keys: ["channels.email.trustedAuthservIds"] })
.mockReturnValueOnce(configureResult);
renderSettingsView({ initialSection: "channels" });
await user.click(await screen.findByRole("button", { name: "View Email settings" }));
await user.click(screen.getByRole("button", { name: "Advanced" }));
const fromAddress = screen.getByRole("textbox", { name: "From address" });
const trustedServices = screen.getByRole("textbox", { name: "Trusted authentication services" });
await user.type(fromAddress, "[email protected]");
expect(requestMutationMock).not.toHaveBeenCalled();
await user.click(trustedServices);
await waitFor(() => expect(requestMutationMock).toHaveBeenCalledTimes(1));
expect(requestMutationMock).toHaveBeenNthCalledWith(
1,
"settings.channel.configure",
{
name: "email",
values: expect.objectContaining({ "channels.email.fromAddress": "[email protected]" }),
},
150_000,
);
expect(requestMutationMock.mock.calls[0][1].values).not.toHaveProperty("channels.email.trustedAuthservIds");
expect(screen.getByText("Saving")).toBeVisible();
await user.type(trustedServices, "mx.receiver.example");
expect(trustedServices).toHaveFocus();
expect(requestMutationMock).toHaveBeenCalledTimes(1);
await act(async () => {
resolveConfigure?.({ name: "email", saved: true, saved_keys: ["channels.email.fromAddress"] });
await configureResult;
});
expect(trustedServices).toHaveFocus();
expect(trustedServices).toHaveValue("mx.receiver.example");
expect(requestMutationMock).toHaveBeenCalledTimes(1);
await user.tab();
await waitFor(() => expect(requestMutationMock).toHaveBeenCalledTimes(2));
expect(requestMutationMock).toHaveBeenNthCalledWith(
2,
"settings.channel.configure",
{
name: "email",
values: expect.objectContaining({
"channels.email.fromAddress": "[email protected]",
"channels.email.trustedAuthservIds": "mx.receiver.example",
}),
},
150_000,
);
});
it("prefills saved channel config without exposing secrets", async () => {
const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
const url = String(input);
if (url === "/api/settings") return jsonResponse(settingsPayload());
if (url === "/api/settings/cli-apps") return jsonResponse({ apps: [], installed_count: 0 });
if (url === "/api/settings/mcp-presets") return jsonResponse({ presets: [], installed_count: 0 });
if (url === "/api/settings/nanobot-features") {
return jsonResponse({
features: [{
name: "discord",
display_name: "Discord",
webui: "webui/index.ts",
type: "channel",
enabled: false,
configured: true,
installed: true,
ready: false,
status: "not_enabled",
install_supported: true,
requires_restart: true,
config_values: {
"channels.discord.allowChannels": "123, 456",
"channels.discord.groupPolicy": "open",
},
configured_fields: [
"channels.discord.token",
"channels.discord.allowChannels",
"channels.discord.groupPolicy",
],
setup: channelSetupContract("discord"),
}],
enabled_count: 0,
});
}
return { ok: false, status: 404, json: async () => ({}) } as Response;
});
vi.stubGlobal("fetch", fetchMock);
requestMutationMock.mockResolvedValueOnce({
features: [{
name: "discord",
display_name: "Discord",
webui: "webui/index.ts",
type: "channel",
enabled: true,
configured: true,
installed: true,
ready: true,
status: "enabled",
install_supported: true,
requires_restart: true,
setup: channelSetupContract("discord"),
}],
enabled_count: 1,
requires_restart: false,
});
renderSettingsView({ initialSection: "channels" });
fireEvent.click(await screen.findByRole("button", { name: "View Discord settings" }));
expect(screen.getByLabelText("Discord channel")).toHaveAttribute(
"aria-checked",
"false",
);
expect(screen.getByLabelText("Discord channel")).toBeEnabled();
const savedSecret = screen.getByPlaceholderText("Saved secret");
expect(savedSecret).toHaveValue("");
expect(savedSecret).toHaveAttribute("autocomplete", "off");
expect(savedSecret.closest("form")).not.toBeNull();
expect(screen.queryByDisplayValue("discord-secret-token")).not.toBeInTheDocument();
fireEvent.click(screen.getByRole("button", { name: "Advanced" }));
expect(screen.getByLabelText("Allowed channels")).toHaveValue("123, 456");
expect(within(screen.getByRole("group", { name: "Group rules" })).getByRole(
"radio",
{ name: "All messages" },
)).toBeChecked();
fireEvent.click(screen.getByRole("button", { name: "Close" }));
fireEvent.click(screen.getByLabelText("Discord channel"));
await waitFor(() =>
expect(requestMutationMock).toHaveBeenCalledWith(
"settings.feature.enable",
{ name: "discord" },
150_000,
),
);
});
it("shows an actionable credential guide for Telegram", async () => {
vi.stubGlobal(
"fetch",
vi.fn(async (input: RequestInfo | URL) => {
const url = String(input);
if (url === "/api/settings") return jsonResponse(settingsPayload());
if (url === "/api/settings/cli-apps") return jsonResponse({ apps: [], installed_count: 0 });
if (url === "/api/settings/mcp-presets") return jsonResponse({ presets: [], installed_count: 0 });
if (url === "/api/settings/nanobot-features") {
return jsonResponse({
features: [{
name: "telegram",
display_name: "Telegram",
webui: "webui/index.ts",
type: "channel",
enabled: false,
installed: true,
ready: false,
status: "not_enabled",
install_supported: true,
requires_restart: true,
}],
enabled_count: 0,
});
}
return { ok: false, status: 404, json: async () => ({}) } as Response;
}),
);
renderSettingsView({ initialSection: "channels" });
fireEvent.click(await screen.findByRole("button", { name: "View Telegram settings" }));
fireEvent.pointerDown(screen.getByRole("button", { name: "Help" }), { button: 0, ctrlKey: false });
expect(await screen.findByRole("menuitem", { name: "Open Telegram setup" })).toHaveAttribute(
"href",
"https://nanobot.wiki/docs/0.2.2/getting-started/chat-apps#telegram",
);
fireEvent.keyDown(screen.getByRole("menu"), { key: "Escape" });
});
it("opens channel setup guides from the help menu", async () => {
const channels = [
["telegram", "Telegram", "Open Telegram setup"],
["feishu", "Feishu", "Open Feishu setup"],
["slack", "Slack", "Open Slack setup"],
["discord", "Discord", "Open Discord setup"],
["email", "Email", "Open Email setup"],
["matrix", "Matrix", "Open Matrix setup"],
["whatsapp", "WhatsApp", "Open WhatsApp setup"],
["dingtalk", "DingTalk", "Open DingTalk setup"],
["wecom", "WeCom", "Open WeCom setup"],
["weixin", "WeChat", "Open WeChat setup"],
["qq", "QQ", "Open QQ setup"],
["signal", "Signal", "Open Signal setup"],
["msteams", "Microsoft Teams", "Open Teams setup"],
["napcat", "NapCat", "Open NapCat setup"],
["mochat", "MoChat", "Open MoChat setup guide"],
] as const;
vi.stubGlobal(
"fetch",
vi.fn(async (input: RequestInfo | URL) => {
const url = String(input);
if (url === "/api/settings") return jsonResponse(settingsPayload());
if (url === "/api/settings/cli-apps") return jsonResponse({ apps: [], installed_count: 0 });
if (url === "/api/settings/mcp-presets") return jsonResponse({ presets: [], installed_count: 0 });
if (url === "/api/settings/nanobot-features") {
return jsonResponse({
features: channels.map(([name, displayName]) => ({
name,
display_name: displayName,
webui: ["feishu", "qq", "weixin", "whatsapp"].includes(name) ? "webui/index.tsx" : "webui/index.ts",
type: "channel",
enabled: false,
installed: true,
ready: false,
status: "not_enabled",
install_supported: true,
requires_restart: true,
})),
enabled_count: 0,
});
}
return { ok: false, status: 404, json: async () => ({}) } as Response;
}),
);
renderSettingsView({ initialSection: "channels" });
for (const [, displayName, guideLabel] of channels) {
fireEvent.click(await screen.findByRole("button", { name: `View ${displayName} settings` }));
fireEvent.pointerDown(screen.getByRole("button", { name: "Help" }), { button: 0, ctrlKey: false });
const guide = await screen.findByRole("menuitem", { name: guideLabel });
expect(guide).toHaveAttribute("href", expect.stringMatching(/^https:\/\//));
fireEvent.keyDown(screen.getByRole("menu"), { key: "Escape" });
fireEvent.click(screen.getByRole("button", { name: "Close" }));
}
});
it("uses choices for channel enum and boolean fields", async () => {
vi.stubGlobal(
"fetch",
vi.fn(async (input: RequestInfo | URL) => {
const url = String(input);
if (url === "/api/settings") return jsonResponse(settingsPayload());
if (url === "/api/settings/cli-apps") return jsonResponse({ apps: [], installed_count: 0 });
if (url === "/api/settings/mcp-presets") return jsonResponse({ presets: [], installed_count: 0 });
if (url === "/api/settings/nanobot-features") {
return jsonResponse({
features: ["email", "feishu", "matrix", "qq"].map((name) => ({
name,
display_name: name === "qq" ? "QQ" : name[0].toUpperCase() + name.slice(1),
webui: name === "feishu" || name === "qq" ? "webui/index.tsx" : "webui/index.ts",
type: "channel",
enabled: true,
installed: true,
ready: true,
status: "enabled",
install_supported: true,
requires_restart: true,
setup: channelSetupContract(name as "email" | "feishu" | "matrix" | "qq"),
})),
enabled_count: 4,
});
}
return { ok: false, status: 404, json: async () => ({}) } as Response;
}),
);
renderSettingsView({ initialSection: "channels" });
fireEvent.click(await screen.findByRole("button", { name: "View Email settings" }));
const consent = screen.getByRole("group", { name: "Email access" });
expect(within(consent).getByRole("radio", { name: "Not granted" })).toBeChecked();
expect(within(consent).getByRole("radio", { name: "Granted" })).toBeInTheDocument();
fireEvent.click(screen.getByRole("button", { name: "Close" }));
fireEvent.click(screen.getByRole("button", { name: "View Feishu settings" }));
fireEvent.click(screen.getByRole("button", { name: "Advanced" }));
const region = screen.getByRole("group", { name: "Region" });
expect(within(region).getByRole("radio", { name: "Feishu" })).toBeChecked();
expect(within(region).getByRole("radio", { name: "Lark" })).toBeInTheDocument();
fireEvent.click(screen.getByRole("button", { name: "Close" }));
fireEvent.click(screen.getByRole("button", { name: "View Matrix settings" }));
expect(screen.getByText("Credential method")).toBeInTheDocument();
fireEvent.click(screen.getByRole("button", { name: "Advanced" }));
const matrixBehavior = screen.getByRole("group", { name: "Group rules" });
expect(within(matrixBehavior).getByRole("radio", { name: "All messages" })).toBeChecked();
expect(within(matrixBehavior).getByRole("radio", { name: "Allowlist" })).toBeInTheDocument();
fireEvent.click(screen.getByRole("button", { name: "Close" }));
fireEvent.click(screen.getByRole("button", { name: "View QQ settings" }));
fireEvent.click(screen.getByRole("button", { name: "Advanced" }));
const format = screen.getByRole("group", { name: "Message format" });
expect(within(format).getByRole("radio", { name: "Plain text" })).toBeChecked();
expect(within(format).getByRole("radio", { name: "Markdown" })).toBeInTheDocument();
});
it("connects QQ by QR scan and fills AppID from saved credentials", async () => {
const qqFeature: NanobotFeatureInfo = {
name: "qq",
display_name: "QQ",
webui: "webui/index.tsx",
type: "channel",
enabled: false,
configured: false,
installed: true,
ready: false,
status: "not_enabled",
install_supported: true,
requires_restart: false,
setup: channelSetupContract("qq"),
};
let currentFeature = qqFeature;
vi.stubGlobal(
"fetch",
vi.fn(async (input: RequestInfo | URL) => {
const url = String(input);
if (url === "/api/settings") return jsonResponse(settingsPayload());
if (url === "/api/settings/cli-apps") return jsonResponse({ apps: [], installed_count: 0 });
if (url === "/api/settings/mcp-presets") return jsonResponse({ presets: [], installed_count: 0 });
if (url === "/api/settings/nanobot-features") {
return jsonResponse({ features: [currentFeature], enabled_count: 0 });
}
return { ok: false, status: 404, json: async () => ({}) } as Response;
}),
);
requestMutationMock.mockImplementation(async (action: string) => {
if (action === "settings.channel.connect.start") {
return { status: "pending", session_id: "qq-1", qr_url: "https://example.com/qq-login" };
}
if (action === "settings.channel.connect.poll") {
currentFeature = {
...qqFeature,
enabled: true,
configured: true,
config_values: { "channels.qq.appId": "1024" },
configured_fields: ["channels.qq.appId", "channels.qq.secret"],
};
return {
status: "succeeded",
session_id: "qq-1",
message: "QQ is connected.",
nanobot_features: { features: [currentFeature], enabled_count: 1 },
};
}
return settingsPayload();
});
renderSettingsView({ initialSection: "channels" });
fireEvent.click(await screen.findByRole("button", { name: "View QQ settings" }));
expect(await screen.findByRole("img", { name: "QQ binding QR code" })).toBeInTheDocument();
expect(requestMutationMock).toHaveBeenCalledWith(
"settings.channel.connect.start", { channel: "qq" }, 150_000,
);
await waitFor(() => expect(requestMutationMock).toHaveBeenCalledWith(
"settings.channel.connect.poll", { channel: "qq", session_id: "qq-1" }, 150_000,
));
expect(await screen.findByText("Configured")).toBeInTheDocument();
expect(screen.queryByRole("alertdialog")).not.toBeInTheDocument();
expect(screen.queryByText(/Rebinding may interrupt other apps/)).not.toBeInTheDocument();
fireEvent.click(screen.getByRole("button", { name: "Advanced" }));
expect(screen.getByLabelText("App ID")).toHaveValue("1024");
expect(screen.getByLabelText("Acknowledgement message")).toHaveValue("⏳ Processing...");
});
it("keeps saved QQ setup distinct from a running connection when reopening settings", async () => {
const qqFeature: NanobotFeatureInfo = {
...catalogFeature("qq", false),
display_name: "QQ",
webui: "webui/index.tsx",
configured: true,
runtime_status: "stopped",
config_values: { "channels.qq.appId": "1024" },
configured_fields: ["channels.qq.appId", "channels.qq.secret"],
setup: channelSetupContract("qq"),
};
vi.stubGlobal("fetch", vi.fn(async (input: RequestInfo | URL) => {
const url = String(input);
if (url === "/api/settings") return jsonResponse(settingsPayload());
if (url === "/api/settings/nanobot-features") {
return jsonResponse({ features: [qqFeature], enabled_count: 0 });
}
return { ok: false, status: 404, json: async () => ({}) } as Response;
}));
renderSettingsView({ initialSection: "channels" });
fireEvent.click(await screen.findByRole("button", { name: "View QQ settings" }));
expect(await screen.findByText("Configured")).toBeInTheDocument();
expect(within(screen.getByRole("dialog")).getByText("Not running")).toBeInTheDocument();
expect(within(screen.getByRole("dialog")).queryByText("Running")).not.toBeInTheDocument();
expect(screen.getByText("1024")).toBeInTheDocument();
expect(screen.getByRole("button", { name: "Rebind bot" })).toBeInTheDocument();
expect(screen.queryByRole("img", { name: "QQ binding QR code" })).not.toBeInTheDocument();
expect(requestMutationMock).not.toHaveBeenCalled();
fireEvent.click(screen.getByRole("button", { name: "Enter credentials manually" }));
expect(screen.getByRole("group", { name: "Manual credentials" })).toBeInTheDocument();
expect(screen.getByRole("group", { name: "Access" })).toBeInTheDocument();
expect(screen.getByRole("group", { name: "Behavior" })).toBeInTheDocument();
expect(screen.getByRole("group", { name: "Advanced" })).toBeInTheDocument();
expect(screen.getByLabelText("App ID")).toHaveValue("1024");
fireEvent.click(screen.getByRole("button", { name: "Close" }));
fireEvent.click(screen.getByRole("button", { name: "View QQ settings" }));
const rebind = await screen.findByRole("button", { name: "Rebind bot" });
expect(screen.queryByText(/Rebinding may interrupt other apps/)).not.toBeInTheDocument();
expect(requestMutationMock).not.toHaveBeenCalled();
rebind.focus();
fireEvent.click(rebind);
const confirmation = await screen.findByRole("alertdialog", { name: "Rebind bot" });
expect(confirmation).toHaveTextContent("Rebinding may interrupt other apps using this QQ bot. If the App Secret is reset, the old secret becomes invalid and those apps need the new secret.");
expect(requestMutationMock).not.toHaveBeenCalled();
fireEvent.click(within(confirmation).getByRole("button", { name: "Cancel" }));
await waitFor(() => expect(screen.queryByRole("alertdialog")).not.toBeInTheDocument());
expect(screen.queryByText(/Rebinding may interrupt other apps/)).not.toBeInTheDocument();
expect(rebind).toHaveFocus();
expect(requestMutationMock).not.toHaveBeenCalled();
requestMutationMock.mockResolvedValue({ status: "pending", session_id: "qq-rebind", qr_url: "https://example.com/qq-rebind" });
fireEvent.click(rebind);
fireEvent.click(within(await screen.findByRole("alertdialog", { name: "Rebind bot" }))
.getByRole("button", { name: "Rebind bot" }));
expect(await screen.findByRole("img", { name: "QQ binding QR code" })).toBeInTheDocument();
expect(requestMutationMock).toHaveBeenCalledTimes(1);
expect(requestMutationMock).toHaveBeenCalledWith("settings.channel.connect.start", { channel: "qq" }, 150_000);
expect(screen.queryByRole("alertdialog")).not.toBeInTheDocument();
});
it("keeps the WebUI websocket channel enabled without opening a setup dialog", async () => {
const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
const url = String(input);
if (url === "/api/settings") return jsonResponse(settingsPayload());
if (url === "/api/settings/cli-apps") return jsonResponse({ apps: [], installed_count: 0 });
if (url === "/api/settings/mcp-presets") return jsonResponse({ presets: [], installed_count: 0 });
if (url === "/api/settings/nanobot-features") {
return jsonResponse({
features: [{
name: "websocket",
display_name: "Websocket",
capabilities: ["always_enabled"],
webui: "webui/index.ts",
type: "channel",
enabled: true,
installed: true,
ready: true,
status: "enabled",
install_supported: true,
requires_restart: true,
}],
enabled_count: 1,
});
}
return { ok: false, status: 404, json: async () => ({}) } as Response;
});
vi.stubGlobal("fetch", fetchMock);
renderSettingsView({ initialSection: "channels" });
const websocketName = await screen.findByText("nanobot WebUI");
fireEvent.click(websocketName);
expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
const websocketSwitch = screen.getByRole("switch", { name: "nanobot WebUI channel" });
expect(websocketSwitch).toBeDisabled();
expect(websocketSwitch).toHaveAttribute("aria-checked", "true");
expect(requestMutationMock).not.toHaveBeenCalled();
});
});