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

package/test/app/shell-mode-tab-memory.test.tsx

@@ -1,58 +0,0 @@
-import type { Tab } from "@elizaos/app-core/navigation";
-import { describe, expect, it } from "vitest";
-import {
-  deriveUiShellModeForTab,
-  getTabForShellView,
-  shouldStartAtCharacterSelectOnLaunch,
-} from "../../src/state/shell-routing";
-
-describe("shell routing helpers", () => {
-  it("derives companion mode only for the companion tab", () => {
-    expect(deriveUiShellModeForTab("chat")).toBe("native");
-    expect(deriveUiShellModeForTab("character-select")).toBe("native");
-    expect(deriveUiShellModeForTab("settings")).toBe("native");
-    expect(deriveUiShellModeForTab("companion")).toBe("companion");
-  });
-
-  it("maps shell view toggles onto a single canonical tab target", () => {
-    expect(getTabForShellView("companion", "chat")).toBe("companion");
-    expect(getTabForShellView("character", "chat")).toBe("character-select");
-    expect(getTabForShellView("desktop", "settings")).toBe("settings");
-  });
-
-  it("starts completed launches on character select for chat-like entry routes", () => {
-    const entryRoutes: Array<{ navPath: string; urlTab: Tab | null }> = [
-      { navPath: "/", urlTab: "chat" },
-      { navPath: "/chat", urlTab: "chat" },
-      { navPath: "/companion", urlTab: "companion" },
-    ];
-
-    for (const entryRoute of entryRoutes) {
-      expect(
-        shouldStartAtCharacterSelectOnLaunch({
-          onboardingNeedsOptions: false,
-          navPath: entryRoute.navPath,
-          urlTab: entryRoute.urlTab,
-        }),
-      ).toBe(true);
-    }
-  });
-
-  it("keeps explicit desktop routes and incomplete onboarding out of character-select auto-launch", () => {
-    expect(
-      shouldStartAtCharacterSelectOnLaunch({
-        onboardingNeedsOptions: false,
-        navPath: "/settings",
-        urlTab: "settings",
-      }),
-    ).toBe(false);
-
-    expect(
-      shouldStartAtCharacterSelectOnLaunch({
-        onboardingNeedsOptions: true,
-        navPath: "/chat",
-        urlTab: "chat",
-      }),
-    ).toBe(false);
-  });
-});

package/test/app/shell-overlays.test.tsx

@@ -1,50 +0,0 @@
-import React from "react";
-import { renderToStaticMarkup } from "react-dom/server";
-import { describe, expect, it, vi } from "vitest";
-
-vi.mock("@elizaos/app-core/components", async () => {
-  const actual = await vi.importActual<
-    typeof import("@elizaos/app-core/components")
-  >("@elizaos/app-core/components");
-  return {
-    ...actual,
-    BugReportModal: () => React.createElement("div", null, "BugReportModal"),
-    CommandPalette: () => React.createElement("div", null, "CommandPalette"),
-    RestartBanner: () => React.createElement("div", null, "RestartBanner"),
-    ShortcutsOverlay: () =>
-      React.createElement("div", null, "ShortcutsOverlay"),
-  };
-});
-
-vi.mock("../../src/components/MemoryDebugPanel", () => ({
-  MemoryDebugPanel: () => React.createElement("div", null, "MemoryDebugPanel"),
-}));
-
-import { ShellOverlays } from "../../src/components/ShellOverlays";
-
-describe("ShellOverlays", () => {
-  it("renders the shared overlay components once", () => {
-    const markup = renderToStaticMarkup(
-      React.createElement(ShellOverlays, { actionNotice: null }),
-    );
-
-    expect(markup).toContain("CommandPalette");
-    expect(markup).toContain("RestartBanner");
-
-    expect(markup).toContain("BugReportModal");
-    expect(markup).toContain("ShortcutsOverlay");
-  });
-
-  it.each([
-    [{ text: "Saved", tone: "success" }, "bg-ok"],
-    [{ text: "Failed", tone: "error" }, "bg-danger"],
-    [{ text: "Working", tone: "info" }, "bg-accent"],
-  ])("maps %o action notices to the expected tone class", (actionNotice, expectedClass) => {
-    const markup = renderToStaticMarkup(
-      React.createElement(ShellOverlays, { actionNotice }),
-    );
-
-    expect(markup).toContain(actionNotice.text);
-    expect(markup).toContain(expectedClass);
-  });
-});

package/test/app/shortcuts-overlay.test.tsx

@@ -1,111 +0,0 @@
-// @vitest-environment jsdom
-
-import { ShortcutsOverlay } from "@elizaos/app-core/components";
-import { COMMON_SHORTCUTS } from "@elizaos/app-core/hooks";
-import React from "react";
-import TestRenderer, { act } from "react-test-renderer";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-let addListenerSpy: ReturnType<typeof vi.spyOn>;
-
-function getLatestKeydownHandler(): (event: KeyboardEvent) => void {
-  const keydownCalls = addListenerSpy.mock.calls.filter(
-    (call: unknown[]) => call[0] === "keydown" && typeof call[1] === "function",
-  );
-  const latestCall = keydownCalls.at(-1);
-  if (!latestCall) {
-    throw new Error("Expected ShortcutsOverlay to register a keydown handler");
-  }
-  return latestCall[1] as (event: KeyboardEvent) => void;
-}
-
-function findText(
-  root: TestRenderer.ReactTestInstance,
-  value: string,
-): TestRenderer.ReactTestInstance[] {
-  return root.findAll((node: TestRenderer.ReactTestInstance) =>
-    node.children.some((child) => child === value),
-  );
-}
-
-describe("ShortcutsOverlay", () => {
-  beforeEach(() => {
-    vi.restoreAllMocks();
-    addListenerSpy = vi.spyOn(window, "addEventListener");
-  });
-
-  it("opens on Shift+? and renders the shared shortcuts list", () => {
-    let tree!: TestRenderer.ReactTestRenderer;
-    act(() => {
-      tree = TestRenderer.create(React.createElement(ShortcutsOverlay));
-    });
-
-    expect(tree.toJSON()).toBeNull();
-
-    const preventDefault = vi.fn();
-    act(() => {
-      getLatestKeydownHandler()({
-        shiftKey: true,
-        key: "?",
-        preventDefault,
-        target: { tagName: "DIV" },
-      } as KeyboardEvent);
-    });
-
-    const dialog = tree.root.findByProps({ role: "dialog" });
-    expect(dialog.props["aria-label"]).toBe("Keyboard shortcuts");
-    expect(findText(tree.root, "Open command palette")).toHaveLength(1);
-    expect(tree.root.findAllByType("kbd" as React.ElementType)).toHaveLength(
-      COMMON_SHORTCUTS.length,
-    );
-    expect(preventDefault).toHaveBeenCalledOnce();
-  });
-
-  it("ignores the toggle shortcut while typing in an input", () => {
-    let tree!: TestRenderer.ReactTestRenderer;
-    act(() => {
-      tree = TestRenderer.create(React.createElement(ShortcutsOverlay));
-    });
-
-    const preventDefault = vi.fn();
-    act(() => {
-      getLatestKeydownHandler()({
-        shiftKey: true,
-        key: "?",
-        preventDefault,
-        target: { tagName: "INPUT" },
-      } as KeyboardEvent);
-    });
-
-    expect(tree.toJSON()).toBeNull();
-    expect(preventDefault).not.toHaveBeenCalled();
-  });
-
-  it("closes on Escape once opened", () => {
-    let tree!: TestRenderer.ReactTestRenderer;
-    act(() => {
-      tree = TestRenderer.create(React.createElement(ShortcutsOverlay));
-    });
-
-    act(() => {
-      getLatestKeydownHandler()({
-        shiftKey: true,
-        key: "?",
-        preventDefault: vi.fn(),
-        target: { tagName: "DIV" },
-      } as KeyboardEvent);
-    });
-
-    const preventDefault = vi.fn();
-    act(() => {
-      getLatestKeydownHandler()({
-        key: "Escape",
-        preventDefault,
-        target: { tagName: "DIV" },
-      } as KeyboardEvent);
-    });
-
-    expect(tree.toJSON()).toBeNull();
-    expect(preventDefault).toHaveBeenCalledOnce();
-  });
-});

package/test/app/sse-interruption.test.ts

@@ -1,122 +0,0 @@
-import { ElizaClient } from "@elizaos/app-core/api";
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
-
-function buildSseResponse(chunks: string[]): Response {
-  const encoder = new TextEncoder();
-  const body = new ReadableStream<Uint8Array>({
-    start(controller) {
-      for (const chunk of chunks) {
-        controller.enqueue(encoder.encode(chunk));
-      }
-      controller.close();
-    },
-  });
-
-  return new Response(body, {
-    status: 200,
-    headers: { "Content-Type": "text/event-stream" },
-  });
-}
-
-function buildErroringSseResponse(chunks: string[]): Response {
-  const encoder = new TextEncoder();
-  let pullCount = 0;
-  const body = new ReadableStream<Uint8Array>({
-    pull(controller) {
-      if (pullCount < chunks.length) {
-        controller.enqueue(encoder.encode(chunks[pullCount]));
-        pullCount++;
-      } else {
-        controller.error(new Error("network connection lost"));
-      }
-    },
-  });
-
-  return new Response(body, {
-    status: 200,
-    headers: { "Content-Type": "text/event-stream" },
-  });
-}
-
-describe("SSE stream interruption detection", () => {
-  const originalFetch = globalThis.fetch;
-  let fetchMock: ReturnType<typeof vi.fn>;
-  let client: ElizaClient;
-
-  beforeEach(() => {
-    fetchMock = vi.fn();
-    globalThis.fetch = fetchMock as typeof globalThis.fetch;
-    client = new ElizaClient("http://localhost:2138", "token");
-  });
-
-  afterEach(() => {
-    globalThis.fetch = originalFetch;
-  });
-
-  test('completed: true when "done" event received', async () => {
-    fetchMock.mockResolvedValue(
-      buildSseResponse([
-        'data: {"type":"token","text":"Hello "}\n\n',
-        'data: {"type":"token","text":"world"}\n\n',
-        'data: {"type":"done","fullText":"Hello world","agentName":"Eliza"}\n\n',
-      ]),
-    );
-
-    const tokens: string[] = [];
-    const result = await client.sendChatStream("hi", (t) => tokens.push(t));
-
-    expect(result.completed).toBe(true);
-    expect(result.text).toBe("Hello world");
-    expect(result.agentName).toBe("Eliza");
-    expect(tokens).toEqual(["Hello ", "world"]);
-  });
-
-  test("completed: false when reader throws mid-stream", async () => {
-    fetchMock.mockResolvedValue(
-      buildErroringSseResponse([
-        'data: {"type":"token","text":"Partial "}\n\n',
-        'data: {"type":"token","text":"response"}\n\n',
-      ]),
-    );
-
-    const tokens: string[] = [];
-    const result = await client.sendChatStream("hi", (t) => tokens.push(t));
-
-    expect(result.completed).toBe(false);
-    expect(result.text).toBe("Partial response");
-    expect(tokens).toEqual(["Partial ", "response"]);
-  });
-
-  test('completed: false when stream ends without "done" event', async () => {
-    fetchMock.mockResolvedValue(
-      buildSseResponse([
-        'data: {"type":"token","text":"Truncated "}\n\n',
-        'data: {"type":"token","text":"text"}\n\n',
-        // No "done" event — stream just ends
-      ]),
-    );
-
-    const tokens: string[] = [];
-    const result = await client.sendChatStream("hi", (t) => tokens.push(t));
-
-    expect(result.completed).toBe(false);
-    expect(result.text).toBe("Truncated text");
-    expect(tokens).toEqual(["Truncated ", "text"]);
-  });
-
-  test("partial text preserved in return value when stream errors", async () => {
-    fetchMock.mockResolvedValue(
-      buildErroringSseResponse([
-        'data: {"type":"token","text":"Some "}\n\n',
-        'data: {"type":"token","text":"partial "}\n\n',
-        'data: {"type":"token","text":"content"}\n\n',
-      ]),
-    );
-
-    const tokens: string[] = [];
-    const result = await client.sendChatStream("hi", (t) => tokens.push(t));
-
-    expect(result.completed).toBe(false);
-    expect(result.text).toBe("Some partial content");
-  });
-});

package/test/app/startup-asset-missing.e2e.test.ts

@@ -1,126 +0,0 @@
-// @vitest-environment jsdom
-
-import React, { useEffect } from "react";
-import TestRenderer, { act } from "react-test-renderer";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const { mockClient } = vi.hoisted(() => ({
-  mockClient: {
-    hasToken: vi.fn(() => false),
-    getCodingAgentStatus: vi.fn(async () => null),
-    setToken: vi.fn(),
-    getAuthStatus: vi.fn(async () => ({
-      required: false,
-      pairingEnabled: false,
-      expiresAt: null,
-    })),
-    getOnboardingStatus: vi.fn(async () => ({ complete: true })),
-    getStatus: vi.fn(async () => ({
-      state: "error",
-      startup: {
-        phase: "initializing-agent",
-        attempt: 1,
-        lastError: "Bundled avatar ELIZA-01 could not be loaded.",
-      },
-      pendingRestart: false,
-      pendingRestartReasons: [],
-    })),
-    getConfig: vi.fn(async () => ({ ui: { avatarIndex: 1 } })),
-    disconnectWs: vi.fn(),
-  },
-}));
-
-vi.mock("@elizaos/app-core/api", () => ({
-  client: mockClient,
-  SkillScanReportSummary: {},
-}));
-
-import { AppProvider, useApp } from "@elizaos/app-core/state";
-
-interface StartupSnapshot {
-  onboardingLoading: boolean;
-  startupPhase: ReturnType<typeof useApp>["startupPhase"];
-  startupError: ReturnType<typeof useApp>["startupError"];
-}
-
-function Probe(props: { onChange: (snapshot: StartupSnapshot) => void }) {
-  const app = useApp();
-  useEffect(() => {
-    props.onChange({
-      onboardingLoading: app.onboardingLoading,
-      startupPhase: app.startupPhase,
-      startupError: app.startupError,
-    });
-  }, [
-    app.onboardingLoading,
-    app.startupPhase,
-    app.startupError,
-    props.onChange,
-  ]);
-  return null;
-}
-
-describe("startup failure: bundled assets missing", () => {
-  beforeEach(() => {
-    Object.assign(document.documentElement, { setAttribute: vi.fn() });
-    mockClient.hasToken.mockReturnValue(false);
-    mockClient.disconnectWs.mockImplementation(() => {});
-    mockClient.getAuthStatus.mockResolvedValue({
-      required: false,
-      pairingEnabled: false,
-      expiresAt: null,
-    });
-    mockClient.getOnboardingStatus.mockResolvedValue({ complete: true });
-    mockClient.getStatus.mockResolvedValue({
-      state: "error",
-      startup: {
-        phase: "initializing-agent",
-        attempt: 1,
-        lastError: "Bundled avatar ELIZA-01 could not be loaded.",
-      },
-      pendingRestart: false,
-      pendingRestartReasons: [],
-    });
-    mockClient.getConfig.mockResolvedValue({ ui: { avatarIndex: 1 } });
-  });
-  it("surfaces asset-missing before startup reaches ready", async () => {
-    let latest: StartupSnapshot | null = null;
-    let tree: TestRenderer.ReactTestRenderer | null = null;
-
-    await act(async () => {
-      tree = TestRenderer.create(
-        React.createElement(
-          AppProvider,
-          null,
-          React.createElement(Probe, {
-            onChange: (snapshot) => {
-              latest = snapshot;
-            },
-          }),
-        ),
-      );
-    });
-
-    await act(async () => {
-      await Promise.resolve();
-      await Promise.resolve();
-      await Promise.resolve();
-    });
-
-    expect(latest).not.toBeNull();
-    expect(latest?.onboardingLoading).toBe(false);
-    expect(latest?.startupPhase).toBe("initializing-agent");
-    expect(latest?.startupError?.reason).toBe("asset-missing");
-    expect(latest?.startupError?.phase).toBe("initializing-agent");
-    expect(latest?.startupError?.message).toContain(
-      "Required companion assets could not be loaded",
-    );
-    expect(latest?.startupError?.detail).toContain(
-      "Bundled avatar ELIZA-01 could not be loaded",
-    );
-
-    await act(async () => {
-      tree?.unmount();
-    });
-  });
-});

package/test/app/startup-backend-missing.e2e.test.ts

@@ -1,126 +0,0 @@
-// @vitest-environment jsdom
-
-import React, { useEffect } from "react";
-import TestRenderer, { act } from "react-test-renderer";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-const { mockClient } = vi.hoisted(() => ({
-  mockClient: {
-    hasToken: vi.fn(() => false),
-    getCodingAgentStatus: vi.fn(async () => null),
-    setToken: vi.fn(),
-    getAuthStatus: vi.fn(async () => ({
-      required: false,
-      pairingEnabled: false,
-      expiresAt: null,
-    })),
-    getOnboardingStatus: vi.fn(async () => ({ complete: true })),
-    disconnectWs: vi.fn(),
-  },
-}));
-
-vi.mock("@elizaos/app-core/api", () => ({
-  client: mockClient,
-  SkillScanReportSummary: {},
-}));
-
-import { AppProvider, useApp } from "@elizaos/app-core/state";
-
-interface StartupSnapshot {
-  onboardingLoading: boolean;
-  authRequired: boolean;
-  startupError: ReturnType<typeof useApp>["startupError"];
-}
-
-function Probe(props: { onChange: (snapshot: StartupSnapshot) => void }) {
-  const app = useApp();
-  useEffect(() => {
-    props.onChange({
-      onboardingLoading: app.onboardingLoading,
-      authRequired: app.authRequired,
-      startupError: app.startupError,
-    });
-  }, [
-    app.onboardingLoading,
-    app.authRequired,
-    app.startupError,
-    props.onChange,
-  ]);
-  return null;
-}
-
-describe("startup failure: backend missing", () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-    Object.assign(document.documentElement, { setAttribute: vi.fn() });
-    // Simulate a returning user with a persisted local connection so the
-    // startup flow proceeds to backend polling (fresh installs now skip
-    // backend polling and go straight to onboarding).
-    localStorage.setItem(
-      "eliza:connection-mode",
-      JSON.stringify({ runMode: "local" }),
-    );
-    mockClient.hasToken.mockReturnValue(false);
-    mockClient.disconnectWs.mockImplementation(() => {});
-    mockClient.getAuthStatus.mockResolvedValue({
-      required: false,
-      pairingEnabled: false,
-      expiresAt: null,
-    });
-    const err = Object.assign(
-      new Error("Backend API routes are unavailable on this origin"),
-      {
-        kind: "http",
-        status: 404,
-        path: "/api/onboarding/status",
-      },
-    );
-    mockClient.getOnboardingStatus.mockRejectedValue(err);
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-    localStorage.removeItem("eliza:connection-mode");
-  });
-
-  it("fails fast on backend 404 and surfaces backend-unreachable", async () => {
-    let latest: StartupSnapshot | null = null;
-    let tree: TestRenderer.ReactTestRenderer | null = null;
-
-    await act(async () => {
-      tree = TestRenderer.create(
-        React.createElement(
-          AppProvider,
-          null,
-          React.createElement(Probe, {
-            onChange: (snapshot) => {
-              latest = snapshot;
-            },
-          }),
-        ),
-      );
-    });
-
-    await act(async () => {
-      await Promise.resolve();
-      await vi.runOnlyPendingTimersAsync();
-    });
-
-    expect(latest).not.toBeNull();
-    expect(latest?.onboardingLoading).toBe(false);
-    expect(latest?.authRequired).toBe(false);
-    expect(latest?.startupError?.reason).toBe("backend-unreachable");
-    expect(latest?.startupError?.phase).toBe("starting-backend");
-    expect(latest?.startupError?.message).toContain(
-      "Backend API routes are unavailable on this origin",
-    );
-    expect(latest?.startupError?.status).toBe(404);
-    expect(latest?.startupError?.path).toBe("/api/onboarding/status");
-    expect(mockClient.getAuthStatus).toHaveBeenCalledTimes(1);
-    expect(mockClient.getOnboardingStatus).toHaveBeenCalledTimes(1);
-
-    await act(async () => {
-      tree?.unmount();
-    });
-  });
-});