Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
import type { TestProps, TestValue } from "../test-support/reactTree";
import { decodeServerProvider } from "../test-support/fixtures";
import { Predicate } from "effect";
import { isValidElement, type ReactElement } from "react";
import {
DEFAULT_UNIFIED_SETTINGS,
EnvironmentId,
ProviderDriverKind,
ProviderInstanceId,
type ImageGenerationSettings,
type ServerProvider,
} from "@akeru/contracts";
import { beforeEach, describe, expect, it, vi } from "vite-plus/test";
import { visitElements } from "../test-support/reactTree";
import { reactHookHarness as hooks } from "../../test/reactHookHarness";
import type { Bot } from "./types";
const atoms = vi.hoisted(() => ({
providers: Symbol("providers"),
mcpServers: Symbol("mcpServers"),
update: Symbol("botUpdate"),
}));
const state = vi.hoisted(() => ({
bots: [] as Bot[],
providers: [] as ServerProvider[],
imageGeneration: null as ImageGenerationSettings | null,
updateBot: vi.fn(),
}));
vi.mock("react", async (importOriginal) => {
const actual = await importOriginal<typeof import("react")>();
const { reactHookHarness } = await import("../../test/reactHookHarness");
return {
...actual,
useCallback: reactHookHarness.useCallback,
useEffect: () => {},
useMemo: reactHookHarness.useMemo,
useRef: reactHookHarness.useRef,
useState: reactHookHarness.useState,
};
});
vi.mock("react/compiler-runtime", async () => {
const { reactHookHarness } = await import("../../test/reactHookHarness");
return { c: reactHookHarness.useMemoCache };
});
vi.mock("@tanstack/react-router", () => ({
useBlocker: () => {},
useCanGoBack: () => false,
useNavigate: () => vi.fn(),
}));
vi.mock("@effect/atom-react", () => ({
useAtomValue: (atom: symbol) => (atom === atoms.providers ? state.providers : []),
}));
vi.mock("../../state/server", () => ({
primaryServerProvidersAtom: atoms.providers,
serverEnvironment: {
imageProviders: () => Symbol("imageProviders"),
subscriptionAuth: () => Symbol("subscriptionAuth"),
},
}));
vi.mock("../../state/mcpServers", () => ({ environmentMcpServersAtom: () => atoms.mcpServers }));
vi.mock("../../state/bots", () => ({ botEnvironment: { update: atoms.update } }));
vi.mock("../../state/environments", () => ({
usePrimaryEnvironmentId: () => EnvironmentId.make("environment-1"),
}));
vi.mock("../../state/use-atom-command", () => ({
useAtomCommand: (atom: symbol) => (atom === atoms.update ? state.updateBot : vi.fn()),
}));
vi.mock("../../state/query", () => ({
useEnvironmentQuery: () => ({ data: null, error: null, isPending: true, refresh: vi.fn() }),
}));
vi.mock("../../hooks/useSettings", () => ({
usePrimarySettings: () => DEFAULT_UNIFIED_SETTINGS,
useEnvironmentSettings: <T,>(
_environmentId: EnvironmentId,
selector: (settings: typeof DEFAULT_UNIFIED_SETTINGS) => T,
) =>
selector({
...DEFAULT_UNIFIED_SETTINGS,
imageGeneration: state.imageGeneration ?? DEFAULT_UNIFIED_SETTINGS.imageGeneration,
}),
}));
vi.mock("./rosterStore", () => ({
useRosterStore: <T,>(selector: (store: { bots: Bot[] }) => T) => selector({ bots: state.bots }),
}));
vi.mock("./useBotThreadRef", () => ({ useBotThreadRef: () => null }));
vi.mock("../ui/toast", () => ({ toastManager: { add: vi.fn() } }));
vi.mock("../../i18n", async () => {
const { createTranslator } = await import("@akeru/client-runtime/i18n");
const translator = createTranslator("en");
return { useI18n: () => ({ ...translator, t: translator.translate }) };
});
import { BotSettingsPage } from "./BotSettingsPage";
import { expandBotSettingsSections } from "./BotSettingsPage.test-support";
const environmentId = EnvironmentId.make("environment-1");
const codexId = ProviderInstanceId.make("codex");
function codexProvider(): ServerProvider {
return decodeServerProvider({
instanceId: codexId,
driver: ProviderDriverKind.make("codex"),
enabled: true,
installed: true,
version: "1.0.0",
status: "ready",
auth: { status: "authenticated" },
checkedAt: "2026-09-01T00:00:00.000Z",
models: [
{ slug: "gpt-5", name: "GPT-5", isCustom: false, capabilities: null },
{ slug: "gpt-5-mini", name: "GPT-5 mini", isCustom: false, capabilities: null },
],
slashCommands: [],
skills: [],
});
}
function makeBot(overrides: Partial<Bot> = {}): Bot {
return {
id: "bot-1",
name: "Scout",
title: "Scout",
label: null,
description: null,
disabledMcpServerIds: [],
avatar: { kind: "blob", shape: "circle", color: "#2E8EFF" },
engine: { provider: codexId, model: "gpt-5" },
sandbox: "local",
runtimeMode: "full-access",
personalityTone: 50,
voiceEnabled: false,
imageProvider: null,
groupId: null,
pinned: false,
archivedAt: null,
createdAt: "2026-09-01T00:00:00.000Z",
updatedAt: "2026-09-01T00:00:00.000Z",
...overrides,
};
}
type Tree = ReactElement<TestProps>;
/** Renders the page, then the form it mounts, the way React would on each pass. */
function renderForm(): Tree {
hooks.beginRender();
const page = BotSettingsPage({ botId: "bot-1" }) as Tree;
const formElement = visitElements(
page,
(element) => Predicate.isFunction(element.props.onSave) && "bot" in element.props,
);
expect(formElement).not.toBeNull();
const Form = formElement!.type as (props: TestProps) => Tree;
return expandBotSettingsSections(Form(formElement!.props));
}
function imageSelect(tree: Tree) {
const select = visitElements(
tree,
(element) =>
Predicate.isFunction(element.props.onValueChange) &&
visitElements(
element.props.children,
(child) => child.props["aria-label"] === "Image provider",
) !== null,
);
expect(select).not.toBeNull();
return select!.props as {
readonly value: string;
readonly onValueChange: (value: string) => void;
readonly children: TestValue;
};
}
function textOf(node: TestValue): string {
if (Predicate.isString(node) || Predicate.isNumber(node)) return String(node);
if (Array.isArray(node)) return node.map(textOf).join("");
if (isValidElement<Tree["props"]>(node)) {
return textOf((node as Tree).props.children);
}
return "";
}
function selectedLabel(tree: Tree): string {
const trigger = visitElements(
imageSelect(tree).children,
(element) => element.props["aria-label"] === "Image provider",
);
return textOf(trigger?.props.children);
}
function saveButton(tree: Tree) {
const button = visitElements(
tree,
(element) => element.props.onClick !== undefined && textOf(element.props.children) === "Save",
);
expect(button).not.toBeNull();
return button!.props as { readonly disabled: boolean; readonly onClick: () => void };
}
function modelPicker(tree: Tree) {
const picker = visitElements(
tree,
(element) =>
Predicate.isFunction(element.props.onChange) && "activeInstanceId" in element.props,
);
expect(picker).not.toBeNull();
return picker!.props as {
readonly activeInstanceId: string;
readonly model: string;
readonly onChange: (instanceId: string, model: string) => void;
};
}
async function flushPromises(): Promise<void> {
for (let index = 0; index < 4; index += 1) await Promise.resolve();
}
function expectedUpdate(bot: Bot, overrides: TestProps) {
return {
environmentId,
input: {
botId: bot.id,
name: bot.name,
label: null,
description: null,
engine: bot.engine,
sandbox: bot.sandbox,
personalityTone: 50,
voiceEnabled: false,
imageProvider: null,
disabledMcpServerIds: [],
...overrides,
},
};
}
describe("bot settings image provider", () => {
beforeEach(() => {
hooks.reset();
state.bots = [makeBot()];
state.providers = [codexProvider()];
state.imageGeneration = {
chatgptEnabled: true,
grokEnabled: true,
defaultProvider: "chatgpt",
fallbackOrder: ["chatgpt", "grok"],
};
state.updateBot.mockReset().mockResolvedValue({ _tag: "Success" });
});
it("starts on the global default without unsaved changes", () => {
const tree = renderForm();
expect(imageSelect(tree).value).toBe("default");
expect(selectedLabel(tree)).toBe("Use global default (ChatGPT)");
expect(saveButton(tree).disabled).toBe(true);
});
it("preserves inheritance until Local is explicitly selected", async () => {
state.bots = [makeBot({ sandbox: null })];
let tree = renderForm();
expect(saveButton(tree).disabled).toBe(true);
const select = visitElements(
tree,
(element) =>
Predicate.isFunction(element.props.onValueChange) &&
visitElements(
element.props.children,
(child) => child.props["aria-label"] === "Sandbox provider",
) !== null,
);
expect(select?.props.value).toBe("default");
(select!.props.onValueChange as (value: string) => void)("local");
tree = renderForm();
expect(saveButton(tree).disabled).toBe(false);
saveButton(tree).onClick();
await flushPromises();
expect(state.updateBot).toHaveBeenCalledWith(
expectedUpdate(state.bots[0]!, { sandbox: "local" }),
);
});
it("preserves an inherited sandbox while saving another field", async () => {
state.bots = [makeBot({ sandbox: null })];
imageSelect(renderForm()).onValueChange("grok");
saveButton(renderForm()).onClick();
await flushPromises();
expect(state.updateBot).toHaveBeenCalledWith(
expectedUpdate(state.bots[0]!, { imageProvider: "grok", sandbox: null }),
);
});
it("can restore the default sandbox from an explicit choice", async () => {
state.bots = [makeBot({ sandbox: "railway" })];
const tree = renderForm();
const select = visitElements(
tree,
(element) =>
Predicate.isFunction(element.props.onValueChange) &&
visitElements(
element.props.children,
(child) => child.props["aria-label"] === "Sandbox provider",
) !== null,
);
(select!.props.onValueChange as (value: string) => void)("default");
saveButton(renderForm()).onClick();
await flushPromises();
expect(state.updateBot).toHaveBeenCalledWith(expectedUpdate(state.bots[0]!, { sandbox: null }));
});
it("keeps a removed saved provider visible while editing another field", async () => {
const missingId = ProviderInstanceId.make("removed_claude");
state.bots = [makeBot({ engine: { provider: missingId, model: "sonnet" } })];
let tree = renderForm();
expect(modelPicker(tree).activeInstanceId).toBe(missingId);
const notice = visitElements(tree, (element) =>
Boolean(element.props.presentation && Predicate.isObjectOrArray(element.props.presentation)),
);
expect(notice?.props.presentation).toMatchObject({ reason: "missing-provider" });
imageSelect(tree).onValueChange("grok");
tree = renderForm();
saveButton(tree).onClick();
await flushPromises();
expect(state.updateBot).toHaveBeenCalledWith(
expectedUpdate(state.bots[0]!, { imageProvider: "grok" }),
);
});
it.each([
["grok", "Grok"],
["chatgpt", "ChatGPT"],
] as const)("saves %s as the bot's image provider", async (provider, label) => {
imageSelect(renderForm()).onValueChange(provider);
let tree = renderForm();
expect(imageSelect(tree).value).toBe(provider);
expect(selectedLabel(tree)).toBe(label);
expect(saveButton(tree).disabled).toBe(false);
saveButton(tree).onClick();
await flushPromises();
expect(state.updateBot).toHaveBeenCalledTimes(1);
expect(state.updateBot).toHaveBeenCalledWith(
expectedUpdate(state.bots[0]!, { imageProvider: provider }),
);
// The roster refreshes with the saved bot; the draft now matches it.
state.bots = [makeBot({ imageProvider: provider })];
tree = renderForm();
expect(imageSelect(tree).value).toBe(provider);
expect(saveButton(tree).disabled).toBe(true);
expect(textOf(tree)).toContain("Saved");
});
it("clears a saved provider back to the global default", async () => {
state.bots = [makeBot({ imageProvider: "grok" })];
let tree = renderForm();
expect(imageSelect(tree).value).toBe("grok");
imageSelect(tree).onValueChange("default");
tree = renderForm();
expect(imageSelect(tree).value).toBe("default");
expect(selectedLabel(tree)).toBe("Use global default (ChatGPT)");
saveButton(tree).onClick();
await flushPromises();
expect(state.updateBot).toHaveBeenCalledWith(
expectedUpdate(state.bots[0]!, { imageProvider: null }),
);
});
it("keeps the image choice and the chat model independent", async () => {
imageSelect(renderForm()).onValueChange("grok");
let tree = renderForm();
expect(modelPicker(tree).model).toBe("gpt-5");
modelPicker(tree).onChange(codexId, "gpt-5-mini");
tree = renderForm();
expect(imageSelect(tree).value).toBe("grok");
expect(modelPicker(tree).model).toBe("gpt-5-mini");
imageSelect(tree).onValueChange("chatgpt");
tree = renderForm();
expect(modelPicker(tree).model).toBe("gpt-5-mini");
saveButton(tree).onClick();
await flushPromises();
expect(state.updateBot).toHaveBeenCalledWith(
expectedUpdate(state.bots[0]!, {
engine: { provider: codexId, model: "gpt-5-mini" },
imageProvider: "chatgpt",
}),
);
});
it("changing only the chat model saves the bot's image choice unchanged", async () => {
state.bots = [makeBot({ imageProvider: "grok" })];
modelPicker(renderForm()).onChange(codexId, "gpt-5-mini");
const tree = renderForm();
expect(imageSelect(tree).value).toBe("grok");
saveButton(tree).onClick();
await flushPromises();
expect(state.updateBot).toHaveBeenCalledWith(
expectedUpdate(state.bots[0]!, {
engine: { provider: codexId, model: "gpt-5-mini" },
imageProvider: "grok",
}),
);
});
});