@elizaos/app-core 2.0.0-alpha.73 → 2.0.0-alpha.75

package/test/app/plugins-view-toggle-restart.test.ts

@@ -1,129 +0,0 @@
-import React from "react";
-import TestRenderer, { act } from "react-test-renderer";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const mockUseApp = vi.fn();
-const mockOnWsEvent = vi.fn(() => () => {});
-const mockHandlePluginToggle = vi.fn();
-const mockLoadPlugins = vi.fn(async () => {});
-const mockHandlePluginConfigSave = vi.fn(async () => {});
-const mockSetActionNotice = vi.fn();
-const mockSetState = vi.fn();
-
-vi.mock("@elizaos/app-core/state", () => ({
-  useApp: () => mockUseApp(),
-}));
-
-vi.mock("@elizaos/app-core/api", () => ({
-  client: {
-    onWsEvent: (...args: unknown[]) => mockOnWsEvent(...args),
-    installRegistryPlugin: vi.fn(),
-    testPluginConnection: vi.fn(),
-    restartAndWait: vi.fn(),
-  },
-}));
-
-import { PluginsView } from "@elizaos/app-core/components/PluginsView";
-
-function createDeferred<T>() {
-  let resolve!: (value: T | PromiseLike<T>) => void;
-  const promise = new Promise<T>((res) => {
-    resolve = res;
-  });
-  return { promise, resolve };
-}
-
-function baseContext() {
-  return {
-    t: (k: string) => k,
-    plugins: [
-      {
-        id: "test-plugin",
-        name: "Test Plugin",
-        description: "Plugin for toggle UX tests",
-        enabled: false,
-        configured: true,
-        envKey: null,
-        category: "feature" as const,
-        source: "bundled" as const,
-        parameters: [],
-        validationErrors: [],
-        validationWarnings: [],
-      },
-    ],
-    pluginStatusFilter: "all" as const,
-    pluginSearch: "",
-    pluginSettingsOpen: new Set<string>(),
-    pluginSaving: new Set<string>(),
-    pluginSaveSuccess: new Set<string>(),
-    loadPlugins: mockLoadPlugins,
-    handlePluginToggle: mockHandlePluginToggle,
-    handlePluginConfigSave: mockHandlePluginConfigSave,
-    setActionNotice: mockSetActionNotice,
-    setState: mockSetState,
-  };
-}
-
-describe("PluginsView restart-aware toggles", () => {
-  beforeEach(() => {
-    mockUseApp.mockReset();
-    mockOnWsEvent.mockReset();
-    mockHandlePluginToggle.mockReset();
-    mockLoadPlugins.mockReset();
-    mockHandlePluginConfigSave.mockReset();
-    mockSetActionNotice.mockReset();
-    mockSetState.mockReset();
-    mockOnWsEvent.mockReturnValue(() => {});
-    mockLoadPlugins.mockResolvedValue(undefined);
-    mockHandlePluginConfigSave.mockResolvedValue(undefined);
-    mockSetState.mockImplementation(() => {});
-    mockUseApp.mockReturnValue(baseContext());
-  });
-
-  it("locks plugin toggles while a restart-causing toggle is in flight", async () => {
-    const deferred = createDeferred<void>();
-    mockHandlePluginToggle.mockReturnValue(deferred.promise);
-
-    let tree: TestRenderer.ReactTestRenderer;
-    await act(async () => {
-      tree = TestRenderer.create(React.createElement(PluginsView));
-    });
-
-    const getToggle = () =>
-      tree?.root.find(
-        (node) =>
-          node.type === "button" &&
-          node.props["data-plugin-toggle"] === "test-plugin",
-      );
-
-    expect(getToggle().props.disabled).toBe(false);
-
-    await act(async () => {
-      getToggle().props.onClick({ stopPropagation: () => {} });
-    });
-
-    expect(mockHandlePluginToggle).toHaveBeenCalledTimes(1);
-    expect(getToggle().props.disabled).toBe(true);
-    expect(String(getToggle().props.children)).toContain("APPLYING");
-    expect(
-      tree?.root.findAll(
-        (node) =>
-          typeof node.props.className === "string" &&
-          node.props.className.includes("border-accent") &&
-          node.children.join("").includes("pluginsview.ApplyingPluginChan"),
-      ).length,
-    ).toBeGreaterThan(0);
-
-    await act(async () => {
-      getToggle().props.onClick({ stopPropagation: () => {} });
-    });
-    expect(mockHandlePluginToggle).toHaveBeenCalledTimes(1);
-
-    await act(async () => {
-      deferred.resolve();
-      await deferred.promise;
-    });
-
-    expect(getToggle().props.disabled).toBe(false);
-  });
-});

package/test/app/provider-dropdown-default.test.tsx

@@ -1,300 +0,0 @@
-import React from "react";
-import {
-  act,
-  create,
-  type ReactTestInstance,
-  type ReactTestRenderer,
-} from "react-test-renderer";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-// ---------------------------------------------------------------------------
-// Mocks
-// ---------------------------------------------------------------------------
-
-const mockGetConfig = vi.fn();
-const mockGetOnboardingOptions = vi.fn();
-const mockGetSubscriptionStatus = vi.fn();
-const mockUpdateConfig = vi.fn();
-const mockSwitchProvider = vi.fn();
-
-vi.mock("@elizaos/app-core/api", () => ({
-  client: {
-    getConfig: (...args: unknown[]) => mockGetConfig(...args),
-    getOnboardingOptions: (...args: unknown[]) =>
-      mockGetOnboardingOptions(...args),
-    getSubscriptionStatus: (...args: unknown[]) =>
-      mockGetSubscriptionStatus(...args),
-    updateConfig: (...args: unknown[]) => mockUpdateConfig(...args),
-    switchProvider: (...args: unknown[]) => mockSwitchProvider(...args),
-  },
-}));
-
-vi.mock("@elizaos/app-core/components", async () => {
-  const actual = await vi.importActual<
-    typeof import("@elizaos/app-core/components")
-  >("@elizaos/app-core/components");
-  return {
-    ...actual,
-    ApiKeyConfig: () => null,
-    SubscriptionStatus: () => null,
-  };
-});
-vi.mock("@elizaos/app-core/config", () => ({
-  ConfigRenderer: () => null,
-  defaultRegistry: {},
-}));
-
-import { ProviderSwitcher } from "@elizaos/app-core/components";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function defaultProps() {
-  return {
-    elizaCloudEnabled: false,
-    elizaCloudConnected: false,
-    elizaCloudCredits: null,
-    elizaCloudCreditsLow: false,
-    elizaCloudCreditsCritical: false,
-    elizaCloudTopUpUrl: "",
-    elizaCloudUserId: null,
-    elizaCloudLoginBusy: false,
-    elizaCloudLoginError: null,
-    cloudDisconnecting: false,
-    plugins: [
-      {
-        id: "plugin-anthropic",
-        name: "Anthropic",
-        category: "ai-provider",
-        enabled: true,
-        configured: true,
-        parameters: [],
-      },
-    ],
-    pluginSaving: new Set<string>(),
-    pluginSaveSuccess: new Set<string>(),
-    loadPlugins: vi.fn(async () => {}),
-    handlePluginToggle: vi.fn(async () => {}),
-    handlePluginConfigSave: vi.fn(),
-    handleCloudLogin: vi.fn(async () => {}),
-    handleCloudDisconnect: vi.fn(async () => {}),
-    setState: vi.fn(),
-    setTab: vi.fn(),
-  };
-}
-
-function getSelectValue(tree: ReactTestRenderer): string | undefined {
-  const root = tree.root;
-  const selects = root.findAll(
-    (node: ReactTestInstance) =>
-      node.type === "select" && node.props.value !== undefined,
-  );
-  return selects.length > 0 ? selects[0].props.value : undefined;
-}
-
-function getSelect(tree: ReactTestRenderer): ReactTestInstance {
-  const root = tree.root;
-  return root.find(
-    (node: ReactTestInstance) =>
-      node.type === "select" && node.props.value !== undefined,
-  );
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("ProviderSwitcher provider dropdown default", () => {
-  beforeEach(() => {
-    mockGetConfig.mockReset();
-    mockGetOnboardingOptions.mockReset();
-    mockGetSubscriptionStatus.mockReset();
-    mockUpdateConfig.mockReset();
-    mockSwitchProvider.mockReset();
-    mockUpdateConfig.mockResolvedValue({ ok: true });
-    mockSwitchProvider.mockResolvedValue({ ok: true });
-  });
-
-  it("does not auto-select __cloud__ when config returns non-cloud inference", async () => {
-    // Config returns cloud.enabled=false — not a cloud user
-    mockGetConfig.mockResolvedValue({
-      models: { small: "some-local-model", large: "some-local-model" },
-      cloud: { enabled: false },
-      agents: {},
-      env: { vars: {} },
-    });
-    mockGetOnboardingOptions.mockResolvedValue({
-      models: [],
-      piAiModels: [],
-      piAiDefaultModel: "",
-    });
-    mockGetSubscriptionStatus.mockResolvedValue({ providers: [] });
-
-    let tree!: ReactTestRenderer;
-    await act(async () => {
-      tree = create(React.createElement(ProviderSwitcher, defaultProps()));
-    });
-
-    // Let the async config load settle
-    await act(async () => {
-      await new Promise((r) => setTimeout(r, 50));
-    });
-
-    const selectValue = getSelectValue(tree);
-    // With the fix, the dropdown should resolve to the enabled plugin
-    // (plugin-anthropic), NOT "__cloud__"
-    expect(selectValue).toBe("plugin-anthropic");
-  });
-
-  it("selects __cloud__ when config returns cloud inference enabled", async () => {
-    mockGetConfig.mockResolvedValue({
-      models: {},
-      cloud: {
-        enabled: true,
-        inferenceMode: "cloud",
-        services: { inference: true },
-      },
-      agents: {},
-      env: { vars: {} },
-    });
-    mockGetOnboardingOptions.mockResolvedValue({
-      models: [],
-      piAiModels: [],
-      piAiDefaultModel: "",
-    });
-    mockGetSubscriptionStatus.mockResolvedValue({ providers: [] });
-
-    let tree!: ReactTestRenderer;
-    await act(async () => {
-      tree = create(
-        React.createElement(ProviderSwitcher, {
-          ...defaultProps(),
-          elizaCloudEnabled: true,
-        }),
-      );
-    });
-
-    await act(async () => {
-      await new Promise((r) => setTimeout(r, 50));
-    });
-
-    const selectValue = getSelectValue(tree);
-    expect(selectValue).toBe("__cloud__");
-  });
-
-  it("switches to subscription providers even when plugin ids use short slugs", async () => {
-    mockGetConfig.mockResolvedValue({
-      models: {},
-      cloud: {
-        enabled: true,
-        inferenceMode: "cloud",
-        services: { inference: true },
-      },
-      agents: {},
-      env: { vars: {} },
-    });
-    mockGetOnboardingOptions.mockResolvedValue({
-      models: [],
-      piAiModels: [],
-      piAiDefaultModel: "",
-    });
-    mockGetSubscriptionStatus.mockResolvedValue({
-      providers: [
-        {
-          provider: "anthropic-subscription",
-          configured: true,
-          valid: true,
-          expiresAt: null,
-        },
-      ],
-    });
-
-    const handlePluginToggle = vi.fn(async () => {});
-
-    let tree!: ReactTestRenderer;
-    await act(async () => {
-      tree = create(
-        React.createElement(ProviderSwitcher, {
-          ...defaultProps(),
-          elizaCloudEnabled: true,
-          plugins: [
-            {
-              id: "plugin-openai",
-              name: "OpenAI",
-              category: "ai-provider",
-              enabled: true,
-              configured: true,
-              parameters: [],
-            },
-            {
-              id: "plugin-anthropic",
-              name: "Anthropic",
-              category: "ai-provider",
-              enabled: false,
-              configured: true,
-              parameters: [],
-            },
-          ],
-          handlePluginToggle,
-        }),
-      );
-    });
-
-    await act(async () => {
-      await new Promise((r) => setTimeout(r, 50));
-    });
-
-    await act(async () => {
-      getSelect(tree).props.onChange({
-        target: { value: "anthropic-subscription" },
-      });
-      await Promise.resolve();
-    });
-
-    expect(mockUpdateConfig).toHaveBeenCalledWith({
-      cloud: {
-        services: { inference: false },
-        inferenceMode: "byok",
-      },
-      env: { vars: { ELIZA_USE_PI_AI: "" } },
-    });
-    expect(mockSwitchProvider).toHaveBeenCalledWith("anthropic-subscription");
-    expect(handlePluginToggle).toHaveBeenCalledWith("plugin-anthropic", true);
-    expect(handlePluginToggle).toHaveBeenCalledWith("plugin-openai", false);
-  });
-
-  it("restores Claude Subscription from saved config instead of collapsing to anthropic", async () => {
-    mockGetConfig.mockResolvedValue({
-      models: {},
-      cloud: {
-        enabled: false,
-        inferenceMode: "byok",
-        services: { inference: false },
-      },
-      agents: {
-        defaults: {
-          subscriptionProvider: "anthropic-subscription",
-        },
-      },
-      env: { vars: {} },
-    });
-    mockGetOnboardingOptions.mockResolvedValue({
-      models: [],
-      piAiModels: [],
-      piAiDefaultModel: "",
-    });
-    mockGetSubscriptionStatus.mockResolvedValue({ providers: [] });
-
-    let tree!: ReactTestRenderer;
-    await act(async () => {
-      tree = create(React.createElement(ProviderSwitcher, defaultProps()));
-    });
-
-    await act(async () => {
-      await new Promise((r) => setTimeout(r, 50));
-    });
-
-    expect(getSelectValue(tree)).toBe("anthropic-subscription");
-  });
-});

package/test/app/restart-banner.test.tsx

@@ -1,205 +0,0 @@
-import React from "react";
-import { renderToStaticMarkup } from "react-dom/server";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-interface RestartBannerContextStub {
-  t: (key: string) => string;
-  pendingRestart: boolean;
-  pendingRestartReasons: string[];
-  restartBannerDismissed: boolean;
-  dismissRestartBanner: () => void;
-  showRestartBanner: () => void;
-  triggerRestart: () => Promise<void>;
-  relaunchDesktop: () => Promise<void>;
-}
-
-const mockUseApp = vi.fn<() => RestartBannerContextStub>();
-
-vi.mock("@elizaos/app-core/state", async () => {
-  const actual = await vi.importActual<
-    typeof import("@elizaos/app-core/state")
-  >("@elizaos/app-core/state");
-  return {
-    ...actual,
-    useApp: () => mockUseApp(),
-  };
-});
-
-import { RestartBanner } from "@elizaos/app-core/components";
-
-function makeContext(
-  overrides: Partial<RestartBannerContextStub> = {},
-): RestartBannerContextStub {
-  return {
-    t: (k: string) => k,
-    pendingRestart: false,
-    pendingRestartReasons: [],
-    restartBannerDismissed: false,
-    dismissRestartBanner: vi.fn(),
-    showRestartBanner: vi.fn(),
-    triggerRestart: vi.fn(async () => undefined),
-    relaunchDesktop: vi.fn(async () => undefined),
-    ...overrides,
-  };
-}
-
-/** Extract visible text from HTML markup (strip tags). */
-function readAllText(markup: string): string {
-  return markup
-    .replace(/<[^>]+>/g, " ")
-    .replace(/\s+/g, " ")
-    .trim();
-}
-
-describe("RestartBanner", () => {
-  beforeEach(() => {
-    mockUseApp.mockReset();
-  });
-
-  it("renders nothing when no restart is pending", () => {
-    mockUseApp.mockReturnValue(makeContext({ pendingRestart: false }));
-
-    const markup = renderToStaticMarkup(React.createElement(RestartBanner));
-    expect(markup).toBe("");
-  });
-
-  it("renders compact reminder when banner is dismissed", () => {
-    mockUseApp.mockReturnValue(
-      makeContext({
-        pendingRestart: true,
-        pendingRestartReasons: ["Configuration updated"],
-        restartBannerDismissed: true,
-      }),
-    );
-
-    const markup = renderToStaticMarkup(React.createElement(RestartBanner));
-    const text = readAllText(markup);
-    expect(text).toContain("Configuration updated");
-    expect(text).toContain("Electrobun still has restart-required changes queued");
-    expect(markup).toContain("Review");
-  });
-
-  it("renders banner with single reason text", () => {
-    mockUseApp.mockReturnValue(
-      makeContext({
-        pendingRestart: true,
-        pendingRestartReasons: ["Plugin toggled"],
-      }),
-    );
-
-    const markup = renderToStaticMarkup(React.createElement(RestartBanner));
-    const text = readAllText(markup);
-
-    expect(text).toContain("Plugin toggled");
-    expect(text).toContain("restart to apply");
-  });
-
-  it("renders banner with count for multiple reasons", () => {
-    mockUseApp.mockReturnValue(
-      makeContext({
-        pendingRestart: true,
-        pendingRestartReasons: [
-          "Plugin toggled",
-          "Configuration updated",
-          "Wallet configuration updated",
-        ],
-      }),
-    );
-
-    const markup = renderToStaticMarkup(React.createElement(RestartBanner));
-    const text = readAllText(markup);
-
-    expect(text).toContain("3 changes pending");
-    expect(text).toContain("restart to apply");
-  });
-
-  it("renders Later button", () => {
-    mockUseApp.mockReturnValue(
-      makeContext({
-        pendingRestart: true,
-        pendingRestartReasons: ["Plugin toggled"],
-      }),
-    );
-
-    const markup = renderToStaticMarkup(React.createElement(RestartBanner));
-    expect(markup).toContain("Later");
-  });
-
-  it("renders Restart Now button", () => {
-    mockUseApp.mockReturnValue(
-      makeContext({
-        pendingRestart: true,
-        pendingRestartReasons: ["Plugin toggled"],
-      }),
-    );
-
-    const markup = renderToStaticMarkup(React.createElement(RestartBanner));
-    expect(markup).toContain("Restart Now");
-  });
-
-  it("renders with amber background styling", () => {
-    mockUseApp.mockReturnValue(
-      makeContext({
-        pendingRestart: true,
-        pendingRestartReasons: ["Configuration updated"],
-      }),
-    );
-
-    const markup = renderToStaticMarkup(React.createElement(RestartBanner));
-    expect(markup).toContain(
-      "color-mix(in srgb, var(--accent) 15%, var(--bg) 85%)",
-    );
-    expect(markup).toContain("z-[9998]");
-  });
-
-  it("renders with zero reasons gracefully (edge case: pendingRestart true but empty reasons)", () => {
-    mockUseApp.mockReturnValue(
-      makeContext({
-        pendingRestart: true,
-        pendingRestartReasons: [],
-      }),
-    );
-
-    const markup = renderToStaticMarkup(React.createElement(RestartBanner));
-    const text = readAllText(markup);
-
-    // Should still render with fallback text
-    expect(text).toContain("Restart required to apply changes");
-  });
-
-  it("dismiss-then-re-show: compact when dismissed, expands with new reasons", () => {
-    // Step 1: Banner is compact after user clicks "Later"
-    mockUseApp.mockReturnValue(
-      makeContext({
-        pendingRestart: true,
-        pendingRestartReasons: ["Plugin toggled"],
-        restartBannerDismissed: true,
-      }),
-    );
-
-    const dismissedMarkup = renderToStaticMarkup(
-      React.createElement(RestartBanner),
-    );
-    expect(dismissedMarkup).not.toBe("");
-    expect(readAllText(dismissedMarkup)).toContain("Review");
-
-    // Step 2: A new config change arrives — restartBannerDismissed is reset
-    // to false by the WS handler (simulating AppContext behavior)
-    mockUseApp.mockReturnValue(
-      makeContext({
-        pendingRestart: true,
-        pendingRestartReasons: ["Plugin toggled", "Configuration updated"],
-        restartBannerDismissed: false,
-      }),
-    );
-
-    const reshownMarkup = renderToStaticMarkup(
-      React.createElement(RestartBanner),
-    );
-    const text = readAllText(reshownMarkup);
-
-    expect(reshownMarkup).not.toBe("");
-    expect(text).toContain("2 changes pending");
-    expect(text).toContain("restart to apply");
-  });
-});