@elizaos/app-core 2.0.0-alpha.37

package/test/app/autonomy-events.test.ts

@@ -0,0 +1,150 @@
+import type { StreamEventEnvelope } from "@elizaos/app-core/api";
+import {
+  buildAutonomyGapReplayRequests,
+  hasPendingAutonomyGaps,
+  mergeAutonomyEvents,
+} from "@elizaos/app-core/autonomy";
+import { describe, expect, it } from "vitest";
+
+function makeEvent(
+  eventId: string,
+  runId: string,
+  seq: number,
+  stream = "action",
+): StreamEventEnvelope {
+  return {
+    type: "agent_event",
+    version: 1,
+    eventId,
+    ts: Date.now(),
+    runId,
+    seq,
+    stream,
+    payload: { text: `${runId}:${seq}` },
+  };
+}
+
+describe("autonomy-events merge", () => {
+  it("deduplicates events by eventId", () => {
+    const existing = [makeEvent("evt-1", "run-1", 1)];
+    const result = mergeAutonomyEvents({
+      existingEvents: existing,
+      incomingEvents: [makeEvent("evt-1", "run-1", 1)],
+      runHealthByRunId: {},
+    });
+
+    expect(result.events).toHaveLength(1);
+    expect(result.insertedCount).toBe(0);
+    expect(result.duplicateCount).toBe(1);
+    expect(result.store.eventOrder).toEqual(["evt-1"]);
+    expect(result.store.watermark).toBe("evt-1");
+  });
+
+  it("deduplicates events by fallback runId/seq/stream key", () => {
+    const existing = [makeEvent("evt-a", "run-1", 2, "tool")];
+    const result = mergeAutonomyEvents({
+      existingEvents: existing,
+      incomingEvents: [makeEvent("evt-b", "run-1", 2, "tool")],
+      runHealthByRunId: {},
+    });
+
+    expect(result.events).toHaveLength(1);
+    expect(result.insertedCount).toBe(0);
+    expect(result.duplicateCount).toBe(1);
+  });
+
+  it("detects sequence gaps and marks run as recovered when replay fills them", () => {
+    const gap = mergeAutonomyEvents({
+      existingEvents: [makeEvent("evt-1", "run-1", 1)],
+      incomingEvents: [makeEvent("evt-3", "run-1", 3)],
+      runHealthByRunId: {},
+    });
+
+    expect(gap.runsWithNewGaps).toEqual(["run-1"]);
+    expect(hasPendingAutonomyGaps(gap.runHealthByRunId)).toBe(true);
+    expect(gap.runHealthByRunId["run-1"]?.status).toBe("gap_detected");
+    expect(gap.runHealthByRunId["run-1"]?.missingSeqs).toEqual([2]);
+
+    const recovered = mergeAutonomyEvents({
+      existingEvents: gap.events,
+      incomingEvents: [makeEvent("evt-2", "run-1", 2)],
+      runHealthByRunId: gap.runHealthByRunId,
+      replay: true,
+    });
+
+    expect(recovered.runHealthByRunId["run-1"]?.status).toBe("recovered");
+    expect(recovered.runHealthByRunId["run-1"]?.missingSeqs).toEqual([]);
+    expect(recovered.runsRecovered).toContain("run-1");
+    expect(recovered.hasUnresolvedGaps).toBe(false);
+  });
+
+  it("marks unresolved gaps as partial after replay finalization", () => {
+    const gap = mergeAutonomyEvents({
+      existingEvents: [makeEvent("evt-1", "run-1", 1)],
+      incomingEvents: [makeEvent("evt-3", "run-1", 3)],
+      runHealthByRunId: {},
+    });
+
+    const partial = mergeAutonomyEvents({
+      existingEvents: gap.events,
+      incomingEvents: [],
+      runHealthByRunId: gap.runHealthByRunId,
+      replay: true,
+    });
+
+    expect(partial.runHealthByRunId["run-1"]?.status).toBe("partial");
+    expect(partial.runHealthByRunId["run-1"]?.missingSeqs).toEqual([2]);
+    expect(partial.hasUnresolvedGaps).toBe(true);
+  });
+
+  it("builds per-run replay requests from unresolved gaps", () => {
+    const gap = mergeAutonomyEvents({
+      existingEvents: [makeEvent("evt-1", "run-1", 1)],
+      incomingEvents: [makeEvent("evt-3", "run-1", 3)],
+      runHealthByRunId: {},
+    });
+
+    const requests = buildAutonomyGapReplayRequests(
+      gap.runHealthByRunId,
+      gap.store,
+    );
+    expect(requests).toEqual([
+      {
+        runId: "run-1",
+        fromSeq: 2,
+        missingSeqs: [2],
+      },
+    ]);
+
+    const recovered = mergeAutonomyEvents({
+      store: gap.store,
+      incomingEvents: [makeEvent("evt-2", "run-1", 2)],
+      runHealthByRunId: gap.runHealthByRunId,
+    });
+    expect(
+      buildAutonomyGapReplayRequests(
+        recovered.runHealthByRunId,
+        recovered.store,
+      ),
+    ).toEqual([]);
+  });
+
+  it("keeps only the newest events when maxEvents is exceeded", () => {
+    const first = mergeAutonomyEvents({
+      existingEvents: [],
+      incomingEvents: [
+        makeEvent("evt-1", "run-1", 1),
+        makeEvent("evt-2", "run-1", 2),
+        makeEvent("evt-3", "run-1", 3),
+      ],
+      runHealthByRunId: {},
+      maxEvents: 2,
+    });
+
+    expect(first.events.map((event) => event.eventId)).toEqual([
+      "evt-2",
+      "evt-3",
+    ]);
+    expect(first.latestEventId).toBe("evt-3");
+  });
+});

package/test/app/avatar-selector.test.tsx

@@ -0,0 +1,52 @@
+// @vitest-environment jsdom
+import TestRenderer, { act } from "react-test-renderer";
+import { describe, expect, it, vi } from "vitest";
+
+import { AvatarSelector } from "../../src/components/AvatarSelector";
+
+vi.mock("@elizaos/app-core/state", () => ({
+  useApp: () => ({ t: (k: string) => k }),
+  getVrmPreviewUrl: vi.fn(() => "preview.png"),
+  getVrmTitle: vi.fn(() => "Avatar"),
+  VRM_COUNT: 4,
+}));
+
+describe("AvatarSelector", () => {
+  it("suppresses onSelect clicks when loading is true", async () => {
+    const onSelect = vi.fn();
+    let renderer!: TestRenderer.ReactTestRenderer;
+    await act(async () => {
+      renderer = TestRenderer.create(
+        <AvatarSelector selected={1} onSelect={onSelect} loading={true} />,
+      );
+    });
+
+    const buttons = renderer.root.findAllByType("button");
+    const avatarButton = buttons[0];
+    await act(async () => {
+      avatarButton.props.onClick();
+    });
+
+    expect(onSelect).not.toHaveBeenCalled();
+    expect(avatarButton.props.disabled).toBe(true);
+  });
+
+  it("calls onSelect when loading is false", async () => {
+    const onSelect = vi.fn();
+    let renderer!: TestRenderer.ReactTestRenderer;
+    await act(async () => {
+      renderer = TestRenderer.create(
+        <AvatarSelector selected={1} onSelect={onSelect} loading={false} />,
+      );
+    });
+
+    const buttons = renderer.root.findAllByType("button");
+    const avatarButton = buttons[1];
+    await act(async () => {
+      avatarButton.props.onClick();
+    });
+
+    expect(onSelect).toHaveBeenCalledWith(2);
+    expect(avatarButton.props.disabled).toBe(false);
+  });
+});

package/test/app/bsc-trade-panel.test.tsx

@@ -0,0 +1,134 @@
+// @vitest-environment jsdom
+import React from "react";
+import TestRenderer, { act } from "react-test-renderer";
+import { describe, expect, it, vi } from "vitest";
+import { BscTradePanel } from "../../src/components/BscTradePanel";
+
+const VALID_TOKEN = "0x1234567890abcdef1234567890abcdef12345678";
+
+function findByTestId(
+  root: TestRenderer.ReactTestInstance,
+  testId: string,
+): TestRenderer.ReactTestInstance {
+  return root.find((node) => node.props["data-testid"] === testId);
+}
+
+const mockSetActionNotice = vi.fn();
+vi.mock("@elizaos/app-core/state", () => ({
+  useApp: () => ({
+    t: (_k: string) => "Latest quote",
+    setActionNotice: mockSetActionNotice,
+    copyToClipboard: vi.fn().mockResolvedValue(undefined),
+  }),
+}));
+
+describe("BscTradePanel", () => {
+  it("surfaces preflight failures from the toolbar button", async () => {
+    const setActionNotice = mockSetActionNotice;
+    const getBscTradePreflight = vi.fn().mockResolvedValue({
+      ok: false,
+      reasons: ["RPC missing"],
+    });
+
+    let tree: TestRenderer.ReactTestRenderer | null = null;
+    await act(async () => {
+      tree = TestRenderer.create(
+        React.createElement(BscTradePanel, {
+          tradeReady: false,
+          bnbBalance: 0,
+          trackedTokens: [],
+          onAddToken: vi.fn(),
+
+          getBscTradePreflight,
+          getBscTradeQuote: vi.fn(),
+        }),
+      );
+    });
+
+    if (!tree) {
+      throw new Error("Expected BscTradePanel renderer to be created.");
+    }
+
+    const root = tree.root;
+    const tokenInput = findByTestId(root, "wallet-quick-token-input");
+    await act(async () => {
+      tokenInput.props.onChange({ target: { value: VALID_TOKEN } });
+    });
+
+    const preflightButton = findByTestId(root, "wallet-token-preflight");
+    await act(async () => {
+      await preflightButton.props.onClick();
+    });
+
+    expect(getBscTradePreflight).toHaveBeenCalledWith(VALID_TOKEN);
+    expect(setActionNotice).toHaveBeenCalledWith("RPC missing", "error", 3600);
+  });
+
+  it("quotes the current trade inputs from the toolbar button", async () => {
+    const _setActionNotice = mockSetActionNotice;
+    const getBscTradePreflight = vi.fn().mockResolvedValue({
+      ok: true,
+      reasons: [],
+    });
+    const getBscTradeQuote = vi.fn().mockResolvedValue({
+      side: "buy",
+      tokenAddress: VALID_TOKEN,
+      slippageBps: 100,
+      quoteIn: { amount: "0.1", symbol: "BNB" },
+      quoteOut: { amount: "25", symbol: "TKN" },
+      route: [],
+    });
+
+    let tree: TestRenderer.ReactTestRenderer | null = null;
+    await act(async () => {
+      tree = TestRenderer.create(
+        React.createElement(BscTradePanel, {
+          tradeReady: true,
+          bnbBalance: 1,
+          trackedTokens: [],
+          onAddToken: vi.fn(),
+
+          getBscTradePreflight,
+          getBscTradeQuote,
+        }),
+      );
+    });
+
+    if (!tree) {
+      throw new Error("Expected BscTradePanel renderer to be created.");
+    }
+
+    const root = tree.root;
+    const tokenInput = findByTestId(root, "wallet-quick-token-input");
+    await act(async () => {
+      tokenInput.props.onChange({ target: { value: VALID_TOKEN } });
+    });
+
+    const amountPreset = findByTestId(root, "wallet-quick-amount-0.1");
+    await act(async () => {
+      amountPreset.props.onClick();
+    });
+
+    const quoteButton = findByTestId(root, "wallet-token-quote");
+    await act(async () => {
+      await quoteButton.props.onClick();
+    });
+
+    expect(getBscTradePreflight).toHaveBeenCalledWith(VALID_TOKEN);
+    expect(getBscTradeQuote).toHaveBeenCalledWith({
+      side: "buy",
+      tokenAddress: VALID_TOKEN,
+      amount: "0.1",
+    });
+
+    const latestQuoteBlocks = root.findAll(
+      (node) =>
+        node.type === "div" &&
+        node.children.some(
+          (child) =>
+            typeof child === "string" && child.includes("Latest quote"),
+        ),
+    );
+    expect(latestQuoteBlocks.length).toBeGreaterThan(0);
+  });
+});

package/test/app/bug-report-modal.test.tsx

@@ -0,0 +1,353 @@
+import React from "react";
+import TestRenderer, { act } from "react-test-renderer";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+// --- hoisted mocks ----------------------------------------------------------
+
+const { mockUseBugReport, mockClient } = vi.hoisted(() => ({
+  mockUseBugReport: vi.fn(),
+  mockClient: {
+    getCodingAgentStatus: vi.fn(async () => null),
+    checkBugReportInfo: vi.fn().mockResolvedValue({}),
+    submitBugReport: vi.fn().mockResolvedValue({}),
+  },
+}));
+
+vi.mock("@elizaos/app-core/hooks", async () => {
+  const actual = await vi.importActual<typeof import("@elizaos/app-core/hooks")>(
+    "@elizaos/app-core/hooks",
+  );
+  return {
+    ...actual,
+    useBugReport: () => mockUseBugReport(),
+  };
+});
+
+vi.mock("@elizaos/app-core/api", () => ({
+  client: mockClient,
+}));
+
+import { BugReportModal } from "@elizaos/app-core/components/BugReportModal";
+
+// --- helpers ----------------------------------------------------------------
+
+let closeFn: ReturnType<typeof vi.fn>;
+
+function setupMock(isOpen: boolean) {
+  closeFn = vi.fn();
+  mockUseBugReport.mockReturnValue({ isOpen, close: closeFn });
+}
+
+function getButtons(root: TestRenderer.ReactTestInstance) {
+  return root.findAllByType("button" as React.ElementType);
+}
+
+function getTextareas(root: TestRenderer.ReactTestInstance) {
+  return root.findAllByType("textarea" as React.ElementType);
+}
+
+function getText(root: TestRenderer.ReactTestInstance): string {
+  return root
+    .findAllByType("span" as React.ElementType)
+    .map((n) => n.children.join(""))
+    .join("\n");
+}
+
+function findButton(root: TestRenderer.ReactTestInstance, label: string) {
+  return getButtons(root).find((b) => b.children.join("").includes(label));
+}
+
+/** Fill both required fields and return the tree root. */
+async function fillRequired(root: TestRenderer.ReactTestInstance) {
+  const textareas = getTextareas(root);
+  await act(async () => {
+    textareas[0].props.onChange({ target: { value: "Bug description" } });
+  });
+  await act(async () => {
+    textareas[1].props.onChange({ target: { value: "1. Click button" } });
+  });
+}
+
+// --- tests ------------------------------------------------------------------
+
+describe("BugReportModal", () => {
+  beforeEach(() => {
+    mockUseBugReport.mockReset();
+    mockClient.checkBugReportInfo.mockReset().mockResolvedValue({});
+    mockClient.submitBugReport.mockReset().mockResolvedValue({});
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  // --- rendering ---
+
+  it("renders nothing when closed", () => {
+    setupMock(false);
+    let tree: TestRenderer.ReactTestRenderer;
+    act(() => {
+      tree = TestRenderer.create(React.createElement(BugReportModal));
+    });
+    expect(tree?.toJSON()).toBeNull();
+  });
+
+  it("renders modal with header when open", async () => {
+    setupMock(true);
+    let tree: TestRenderer.ReactTestRenderer;
+    await act(async () => {
+      tree = TestRenderer.create(React.createElement(BugReportModal));
+      await vi.runAllTimersAsync();
+    });
+    expect(getText(tree?.root)).toContain("bugreportmodal.ReportABug");
+  });
+
+  it("renders required field markers", async () => {
+    setupMock(true);
+    let tree: TestRenderer.ReactTestRenderer;
+    await act(async () => {
+      tree = TestRenderer.create(React.createElement(BugReportModal));
+      await vi.runAllTimersAsync();
+    });
+    const labels = tree?.root.findAllByType("label" as React.ElementType);
+    const requiredLabels = labels?.filter((l) =>
+      l
+        .findAllByType("span" as React.ElementType)
+        .flatMap((s) => s.children)
+        .some((c) => typeof c === "string" && c.includes("*")),
+    );
+    expect(requiredLabels?.length).toBeGreaterThanOrEqual(2);
+  });
+
+  it("renders all form textareas and inputs", async () => {
+    setupMock(true);
+    let tree: TestRenderer.ReactTestRenderer;
+    await act(async () => {
+      tree = TestRenderer.create(React.createElement(BugReportModal));
+      await vi.runAllTimersAsync();
+    });
+    // Description, Steps to Reproduce, Expected Behavior, Actual Behavior
+    expect(getTextareas(tree?.root).length).toBeGreaterThanOrEqual(4);
+    // Node Version, Model Provider
+    const inputs = tree?.root.findAllByType("input" as React.ElementType);
+    expect(inputs?.length).toBeGreaterThanOrEqual(2);
+  });
+
+  // --- env info fetch ---
+
+  it("fetches env info on open", async () => {
+    mockClient.checkBugReportInfo.mockResolvedValue({
+      nodeVersion: "v22.0.0",
+      platform: "darwin",
+    });
+    setupMock(true);
+    await act(async () => {
+      TestRenderer.create(React.createElement(BugReportModal));
+      await vi.runAllTimersAsync();
+    });
+    expect(mockClient.checkBugReportInfo).toHaveBeenCalledOnce();
+  });
+
+  // --- validation ---
+
+  it("disables submit when required fields are empty", async () => {
+    setupMock(true);
+    let tree: TestRenderer.ReactTestRenderer;
+    await act(async () => {
+      tree = TestRenderer.create(React.createElement(BugReportModal));
+      await vi.runAllTimersAsync();
+    });
+    const submitBtn = findButton(tree?.root, "Submit");
+    expect(submitBtn?.props.disabled).toBe(true);
+  });
+
+  it("shows validation error on empty submit attempt", async () => {
+    setupMock(true);
+    let tree: TestRenderer.ReactTestRenderer;
+    await act(async () => {
+      tree = TestRenderer.create(React.createElement(BugReportModal));
+      await vi.runAllTimersAsync();
+    });
+
+    const submitBtn = findButton(tree?.root, "Submit");
+    await act(async () => {
+      submitBtn?.props.onClick();
+    });
+
+    const errorDivs = tree?.root.findAll(
+      (node) => node.type === "div" && node.props.style?.color === "#ef4444",
+    );
+    expect(errorDivs?.length).toBeGreaterThan(0);
+  });
+
+  // --- submission ---
+
+  it("calls submitBugReport on valid submit", async () => {
+    mockClient.submitBugReport.mockResolvedValue({
+      url: "https://github.com/milady-ai/milady/issues/99",
+    });
+    setupMock(true);
+    let tree: TestRenderer.ReactTestRenderer;
+    await act(async () => {
+      tree = TestRenderer.create(React.createElement(BugReportModal));
+      await vi.runAllTimersAsync();
+    });
+
+    await fillRequired(tree?.root);
+
+    const submitBtn = findButton(tree?.root, "Submit");
+    await act(async () => {
+      submitBtn?.props.onClick();
+    });
+
+    expect(mockClient.submitBugReport).toHaveBeenCalledWith(
+      expect.objectContaining({
+        description: "Bug description",
+        stepsToReproduce: "1. Click button",
+      }),
+    );
+  });
+
+  it("does not send screenshot field to server", async () => {
+    mockClient.submitBugReport.mockResolvedValue({
+      url: "https://example.com",
+    });
+    setupMock(true);
+    let tree: TestRenderer.ReactTestRenderer;
+    await act(async () => {
+      tree = TestRenderer.create(React.createElement(BugReportModal));
+      await vi.runAllTimersAsync();
+    });
+
+    await fillRequired(tree?.root);
+
+    const submitBtn = findButton(tree?.root, "Submit");
+    await act(async () => {
+      submitBtn?.props.onClick();
+    });
+
+    const callArg = mockClient.submitBugReport.mock.calls[0][0];
+    expect(callArg).not.toHaveProperty("screenshot");
+  });
+
+  it("shows success state with issue URL after submit", async () => {
+    const issueUrl = "https://github.com/milady-ai/milady/issues/99";
+    mockClient.submitBugReport.mockResolvedValue({ url: issueUrl });
+    setupMock(true);
+    let tree: TestRenderer.ReactTestRenderer;
+    await act(async () => {
+      tree = TestRenderer.create(React.createElement(BugReportModal));
+      await vi.runAllTimersAsync();
+    });
+
+    await fillRequired(tree?.root);
+
+    const submitBtn = findButton(tree?.root, "Submit");
+    await act(async () => {
+      submitBtn?.props.onClick();
+    });
+
+    expect(getText(tree?.root)).toContain("bugreportmodal.BugReportSubmitted");
+    const link = tree?.root.findByType("a" as React.ElementType);
+    expect(link?.props.href).toBe(issueUrl);
+  });
+
+  it("shows error message on submit failure", async () => {
+    mockClient.submitBugReport.mockRejectedValue(new Error("Network error"));
+    setupMock(true);
+    let tree: TestRenderer.ReactTestRenderer;
+    await act(async () => {
+      tree = TestRenderer.create(React.createElement(BugReportModal));
+      await vi.runAllTimersAsync();
+    });
+
+    await fillRequired(tree?.root);
+
+    const submitBtn = findButton(tree?.root, "Submit");
+    await act(async () => {
+      submitBtn?.props.onClick();
+    });
+
+    const errorDivs = tree?.root.findAll(
+      (node) =>
+        node.type === "div" &&
+        node.props.style?.color === "#ef4444" &&
+        node.children.some(
+          (c) => typeof c === "string" && c.includes("Network error"),
+        ),
+    );
+    expect(errorDivs?.length).toBe(1);
+  });
+
+  // --- fallback mode ---
+
+  it("does not show success URL on fallback response", async () => {
+    mockClient.submitBugReport.mockResolvedValue({
+      fallback: "https://github.com/milady-ai/milady/issues/new",
+    });
+    setupMock(true);
+    let tree: TestRenderer.ReactTestRenderer;
+    await act(async () => {
+      tree = TestRenderer.create(React.createElement(BugReportModal));
+      await vi.runAllTimersAsync();
+    });
+
+    await fillRequired(tree?.root);
+
+    const submitBtn = findButton(tree?.root, "Submit");
+    await act(async () => {
+      submitBtn?.props.onClick();
+    });
+
+    // Fallback path does not transition to success URL view
+    expect(getText(tree?.root)).not.toContain(
+      "bugreportmodal.BugReportSubmitted",
+    );
+    // Form should still be visible (not replaced by success state)
+    expect(getTextareas(tree?.root).length).toBeGreaterThan(0);
+  });
+
+  // --- close behavior ---
+
+  it("calls close on Cancel button click", async () => {
+    setupMock(true);
+    let tree: TestRenderer.ReactTestRenderer;
+    await act(async () => {
+      tree = TestRenderer.create(React.createElement(BugReportModal));
+      await vi.runAllTimersAsync();
+    });
+
+    const cancelBtn = findButton(tree?.root, "onboarding.cancel");
+    act(() => {
+      cancelBtn?.props.onClick();
+    });
+
+    expect(closeFn).toHaveBeenCalled();
+  });
+
+  // --- logs toggle ---
+
+  it("toggles logs textarea visibility", async () => {
+    setupMock(true);
+    let tree: TestRenderer.ReactTestRenderer;
+    await act(async () => {
+      tree = TestRenderer.create(React.createElement(BugReportModal));
+      await vi.runAllTimersAsync();
+    });
+
+    const before = getTextareas(tree?.root).length;
+
+    const logsToggle = getButtons(tree?.root).find((b) =>
+      b.children.some(
+        (c) => typeof c === "string" && c.trim() === "bugreportmodal.Logs",
+      ),
+    );
+    act(() => {
+      logsToggle?.props.onClick();
+    });
+
+    const after = getTextareas(tree?.root).length;
+    expect(after).toBe(before + 1);
+  });
+});