Skip to content

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.

10.0 KB
Raw Blame
import {
  makeMobileServerConfig,
  makeMobileThreadShell,
} from "../../lib/mobile-fixtures.test-support";
import { Predicate } from "effect";
import {
  EnvironmentId,
  ProviderDriverKind,
  ProviderInstanceId,
  ThreadId,
  type ServerConfig,
} from "@akeru/contracts";
import { isValidElement, type ReactNode, type ReactElement } from "react";
import { beforeEach, describe, expect, it, vi } from "vite-plus/test";
import type { ComposerCommandItem } from "./ComposerCommandPopover";
import { ThreadComposer, type ThreadComposerProps } from "./ThreadComposer";

const hooks = vi.hoisted(() => ({ slots: [] as unknown[], cursor: 0 }));

vi.mock("react", async (importOriginal) => {
  const slot = <T,>(create: () => T): { value: T } => {
    const index = hooks.cursor++;

    if (!(index in hooks.slots)) hooks.slots[index] = { value: create() };

    return hooks.slots[index] as { value: T };
  };

  const actual = await importOriginal<typeof import("react")>();

  return {
    ...actual,
    memo: <T,>(component: T) => component,
    useRef: <T,>(current: T) => slot(() => ({ current })).value,
    useMemo: <T,>(factory: () => T) => factory(),
    useCallback: <T,>(callback: T) => callback,
    useEffect: () => {},
    useState: <T,>(initial: T | (() => T)) => {
      const state = slot(() => (Predicate.isFunction(initial) ? (initial as () => T)() : initial));

      const set = (next: T | ((previous: T) => T)) => {
        state.value = Predicate.isFunction(next) ? (next as (previous: T) => T)(state.value) : next;
      };

      return [state.value, set];
    },
  };
});

vi.mock("react-native", () => ({
  ActivityIndicator: "ActivityIndicator",
  AccessibilityInfo: { announceForAccessibility: () => {} },
  Image: "Image",
  Platform: { OS: "ios", select: (options: { ios?: unknown }) => options.ios },
  Pressable: "Pressable",
  StyleSheet: { absoluteFill: {}, create: <T,>(styles: T) => styles },
  View: "View",
}));

vi.mock("react-native-reanimated", () => {
  const transition = { duration: () => transition };

  return {
    default: { View: "Animated.View" },
    FadeIn: transition,
    FadeInDown: transition,
    FadeOut: transition,
    FadeOutDown: transition,
    LinearTransition: transition,
  };
});

vi.mock("react-native-image-viewing", () => ({ default: "ImageViewing" }));

vi.mock("@react-navigation/native", () => ({
  StackActions: { push: vi.fn() },
  useFocusEffect: () => {},
  useNavigation: () => ({ dispatch: vi.fn(), addListener: () => () => {} }),
}));

vi.mock("@effect/atom-react", () => ({ useAtomValue: () => [] }));

vi.mock("../../components/AppSymbol", () => ({ SymbolView: "SymbolView" }));

vi.mock("../../components/AppText", () => ({ AppText: "Text" }));

vi.mock("../../components/ComposerAttachmentStrip", () => ({
  ComposerAttachmentStrip: "ComposerAttachmentStrip",
}));

vi.mock("../../components/GlassSurface", () => ({ GlassSurface: "GlassSurface" }));

vi.mock("../../components/ComposerEditor", () => ({ ComposerEditor: "ComposerEditor" }));

vi.mock("../../components/ComposerToolbar", () => ({
  ComposerInlineControl: "ComposerInlineControl",
  ComposerToolbarButton: "ComposerToolbarButton",
  ComposerToolbarRow: "ComposerToolbarRow",
  ComposerToolbarScroller: "ComposerToolbarScroller",
}));

vi.mock("../../components/ControlPill", () => ({ ControlPill: "ControlPill" }));

vi.mock("../../components/ProviderIcon", () => ({ ProviderIcon: "ProviderIcon" }));

vi.mock("../../lib/useThemeColor", () => ({ useThemeColor: () => "#000000" }));

vi.mock("../../lib/i18n", async () => {
  const { createTranslator } = await import("@akeru/client-runtime/i18n");
  const translator = createTranslator("en");

  return { useMobileI18n: () => ({ t: translator.translate, plural: translator.plural }) };
});

vi.mock("../../lib/modelOptions", () => ({
  buildModelOptions: () => [],
  groupByProvider: () => [],
  resolveModelSendBlock: () => null,
}));

vi.mock("../settings/appearance/useScaledTextRole", () => ({ useScaledTextRole: () => ({}) }));

vi.mock("../settings/appearance/AppearancePreferencesProvider", () => ({
  useAppearancePreferences: () => ({ themeAppearance: "light" }),
}));

vi.mock("../../lib/providerOptions", () => ({ resolveProviderOptionDescriptors: () => [] }));

vi.mock("../../state/use-composer-path-search", () => ({
  useComposerPathSearch: () => ({ entries: [], isPending: false }),
}));

vi.mock("../../state/bots", () => ({
  botEnvironment: { update: Symbol("update"), delete: Symbol("delete") },
  environmentBotsAtom: () => Symbol("bots"),
  environmentGroupsAtom: () => Symbol("groups"),
}));

vi.mock("./thread-list-v2-items", () => ({ providerBotName: () => "Codex" }));

vi.mock("../../state/server", () => ({
  serverEnvironment: { subscriptionAuth: () => Symbol("subscriptionAuth") },
}));

vi.mock("../../state/query", () => ({ useEnvironmentQuery: () => ({ data: null }) }));

vi.mock("../../state/use-atom-command", () => ({ useAtomCommand: () => vi.fn() }));

vi.mock("./ComposerCommandPopover", () => ({ ComposerCommandPopover: "ComposerCommandPopover" }));

vi.mock("./ComposerMentionPopover", () => ({ ComposerMentionPopover: "ComposerMentionPopover" }));

vi.mock("./ThreadSettingsSheet", () => ({
  useExistingThreadSettingsRoutePresentation: () => ({ present: vi.fn(), clear: vi.fn() }),
}));

vi.mock("./use-thread-settings-sheet-presentation", () => ({
  useThreadSettingsSheetRoute: () => ({
    isActive: false,
    isVisible: false,
    open: vi.fn(),
    onDismissed: vi.fn(),
    onStackTransitionsFinished: vi.fn(),
  }),
}));

vi.mock("../../lib/useEnvironmentComposerDictation", () => ({
  useEnvironmentComposerDictation: () => ({
    status: "idle",
    unavailableReason: null,
    onStart: () => {},
    onRelease: () => {},
    onCancel: () => {},
  }),
}));

type TestElementProps = {
  children?: ReactNode;
  accessibilityLabel?: string;
  onAccessibilityTap?: () => void;
  onChangeText?: (value: string) => void;
  onPress?: () => void;
  value?: string;
  source?: { uri?: string };
  disabled?: boolean;
  triggerKind?: string;
  emptyText?: string;
  items?: ReadonlyArray<import("./ComposerCommandPopover").ComposerCommandItem>;
};

type Element = ReactElement<TestElementProps>;

function findElement(node: ReactNode, accept: (element: Element) => boolean): Element | null {
  if (Array.isArray(node)) {
    for (const child of node) {
      const found = findElement(child, accept);

      if (found) return found;
    }

    return null;
  }

  if (!isValidElement<TestElementProps>(node)) return null;

  if (accept(node)) return node;

  for (const value of [node.props.children]) {
    const found = findElement(value, accept);

    if (found) return found;
  }

  return null;
}

// The thread's provider, whose skills and commands feed the `$` and `/` menus.
const serverConfig = makeMobileServerConfig({
  providers: [
    {
      instanceId: ProviderInstanceId.make("claudeAgent"),
      driver: ProviderDriverKind.make("claudeAgent"),
      enabled: true,
      installed: true,
      status: "ready",
      checkedAt: "2026-01-01T00:00:00Z",
      version: null,
      auth: { status: "authenticated" },
      models: [],
      slashCommands: [{ name: "compact", description: "Compact context" }],
      skills: [
        { name: "deploy", path: "/skills/deploy/SKILL.md", enabled: true },
        { name: "review", path: "/skills/review/SKILL.md", enabled: true },
        { name: "archived", path: "/skills/archived/SKILL.md", enabled: false },
      ],
    },
  ],
});

function renderMenu(draftMessage: string, config: ServerConfig | null = serverConfig) {
  hooks.slots = [];
  hooks.cursor = 0;

  const props = {
    draftMessage,
    draftAttachments: [],
    onChangeDraftMessage: vi.fn(),
    onRemoveDraftImage: vi.fn(),
    placeholder: "Message",
    connectionState: "connected",
    connectionError: null,
    environmentLabel: null,
    selectedThread: makeMobileThreadShell({
      id: ThreadId.make("thread"),
      botId: null,
      session: null,
      runtimeMode: "full-access",
      modelSelection: { instanceId: ProviderInstanceId.make("claudeAgent"), model: "claude" },
    }),
    serverConfig: config,
    queueCount: 0,
    environmentId: EnvironmentId.make("environment"),
    projectCwd: null,
    onPickDraftImages: vi.fn(),
    onNativePasteImages: vi.fn(),
    onStopThread: vi.fn(),
    onSendMessage: vi.fn(),
    onUpdateModelSelection: vi.fn(),
    onUpdateRuntimeMode: vi.fn(),
    onReconnectEnvironment: vi.fn(),
  } satisfies ThreadComposerProps;

  const tree = ThreadComposer(props);
  const popover = findElement(tree, (element) => element.type === "ComposerCommandPopover");

  return {
    triggerKind: popover?.props.triggerKind,
    emptyText: popover?.props.emptyText,
    labels: ((popover?.props.items ?? []) as ReadonlyArray<ComposerCommandItem>).map(
      (item) => item.label,
    ),
  };
}

beforeEach(() => {
  hooks.slots = [];
  hooks.cursor = 0;
});

describe("ThreadComposer command menus", () => {
  it("lists the provider's enabled skills after $", () => {
    expect(renderMenu("$")).toEqual({ triggerKind: "skill", labels: ["deploy", "review"] });
  });

  it("ranks $ skills by the typed query", () => {
    expect(renderMenu("$dep")).toEqual({ triggerKind: "skill", labels: ["deploy"] });
  });

  it("lists app commands, provider commands, and skills after /", () => {
    expect(renderMenu("/")).toEqual({
      triggerKind: "slash-command",
      labels: ["/model", "/compact", "skill:deploy", "skill:review"],
    });
  });

  it("filters / rows by the typed query", () => {
    expect(renderMenu("/comp").labels).toEqual(["/compact"]);
  });

  it("keeps $ open with a connect line when no provider is connected", () => {
    const noProvider = makeMobileServerConfig({ ...serverConfig, providers: [] });
    expect(renderMenu("$", noProvider)).toEqual({
      triggerKind: "skill",
      emptyText: "Connect a provider to use skills.",
      labels: [],
    });
    expect(renderMenu("/", noProvider).labels).toEqual(["/model"]);
  });

  it("shows no menu without a trigger", () => {
    expect(renderMenu("hello").triggerKind).toBeUndefined();
  });
});