@elizaos/app-core 2.0.0-alpha.74 → 2.0.0-alpha.76

package/test/app/knowledge-upload-helpers.test.ts

@@ -1,124 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import {
-  getKnowledgeUploadFilename,
-  type KnowledgeUploadFile,
-  shouldReadKnowledgeFileAsText,
-} from "../../src/components/KnowledgeView";
-import {
-  isKnowledgeImageFile,
-  type KnowledgeImageCompressionPlatform,
-  MAX_KNOWLEDGE_IMAGE_PROCESSING_BYTES,
-  maybeCompressKnowledgeUploadImage,
-} from "../../src/components/knowledge-upload-image";
-
-function makeUploadFile(
-  name: string,
-  type: string,
-  relativePath?: string,
-): KnowledgeUploadFile {
-  const file = new File(["content"], name, { type }) as KnowledgeUploadFile;
-  if (relativePath !== undefined) {
-    Object.defineProperty(file, "webkitRelativePath", {
-      value: relativePath,
-      configurable: true,
-    });
-  }
-  return file;
-}
-
-describe("knowledge upload helpers", () => {
-  it("prefers relative path for folder uploads", () => {
-    const file = makeUploadFile("guide.md", "text/markdown", "docs/guide.md");
-    expect(getKnowledgeUploadFilename(file)).toBe("docs/guide.md");
-  });
-
-  it("falls back to filename for regular uploads", () => {
-    const file = makeUploadFile("note.txt", "text/plain");
-    expect(getKnowledgeUploadFilename(file)).toBe("note.txt");
-  });
-
-  it("detects text-readable knowledge files", () => {
-    expect(
-      shouldReadKnowledgeFileAsText({
-        type: "application/json",
-        name: "a.bin",
-      }),
-    ).toBe(true);
-    expect(
-      shouldReadKnowledgeFileAsText({
-        type: "application/octet-stream",
-        name: "notes.md",
-      }),
-    ).toBe(true);
-    expect(
-      shouldReadKnowledgeFileAsText({
-        type: "application/pdf",
-        name: "report.pdf",
-      }),
-    ).toBe(false);
-  });
-
-  it("detects image uploads by mime type or extension", () => {
-    expect(isKnowledgeImageFile({ name: "scan.bin", type: "image/png" })).toBe(
-      true,
-    );
-    expect(
-      isKnowledgeImageFile({
-        name: "scan.WEBP",
-        type: "application/octet-stream",
-      }),
-    ).toBe(true);
-    expect(
-      isKnowledgeImageFile({ name: "notes.txt", type: "text/plain" }),
-    ).toBe(false);
-  });
-
-  it("compresses oversized local images before upload", async () => {
-    const file = new File(
-      [new Uint8Array(MAX_KNOWLEDGE_IMAGE_PROCESSING_BYTES + 1024)],
-      "scan.png",
-      { type: "image/png" },
-    ) as KnowledgeUploadFile;
-    Object.defineProperty(file, "webkitRelativePath", {
-      value: "images/scan.png",
-      configurable: true,
-    });
-
-    const platform: KnowledgeImageCompressionPlatform = {
-      isAvailable: () => true,
-      loadImageSource: vi.fn(async () => ({
-        source: {} as CanvasImageSource,
-        width: 2400,
-        height: 1600,
-      })),
-      renderBlob: vi
-        .fn()
-        .mockResolvedValueOnce(
-          new Blob([new Uint8Array(4_000_000)], { type: "image/jpeg" }),
-        ),
-    };
-
-    const result = await maybeCompressKnowledgeUploadImage(file, platform);
-
-    expect(result.optimized).toBe(true);
-    expect(result.originalSize).toBeGreaterThan(result.optimizedSize);
-    expect(result.file.type).toBe("image/jpeg");
-    expect(result.file.name).toBe("scan.png");
-    expect(result.file.webkitRelativePath).toBe("images/scan.png");
-  });
-
-  it("leaves non-image uploads unchanged", async () => {
-    const file = makeUploadFile("notes.md", "text/markdown");
-    const platform: KnowledgeImageCompressionPlatform = {
-      isAvailable: () => true,
-      loadImageSource: vi.fn(),
-      renderBlob: vi.fn(),
-    };
-
-    const result = await maybeCompressKnowledgeUploadImage(file, platform);
-
-    expect(result.optimized).toBe(false);
-    expect(result.file).toBe(file);
-    expect(platform.loadImageSource).not.toHaveBeenCalled();
-  });
-});

package/test/app/lifecycle-lock.test.ts

@@ -1,267 +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),
-    getAuthStatus: vi.fn(async () => ({
-      required: false,
-      pairingEnabled: false,
-      expiresAt: null,
-    })),
-    getOnboardingStatus: vi.fn(async () => ({ complete: true })),
-    listConversations: vi.fn(async () => ({
-      conversations: [
-        {
-          id: "conv-1",
-          title: "Chat",
-          roomId: "room-1",
-          createdAt: "2026-02-01T00:00:00.000Z",
-          updatedAt: "2026-02-01T00:00:00.000Z",
-        },
-      ],
-    })),
-    getConversationMessages: vi.fn(async () => ({
-      messages: [
-        {
-          id: "msg-1",
-          role: "assistant",
-          text: "hello",
-          timestamp: Date.now(),
-        },
-      ],
-    })),
-    sendWsMessage: vi.fn(),
-    connectWs: vi.fn(),
-    disconnectWs: vi.fn(),
-    onWsEvent: vi.fn(() => () => {}),
-    getAgentEvents: vi.fn(async () => ({ events: [], latestEventId: null })),
-    getStatus: vi.fn(async () => ({
-      state: "running",
-      agentName: "Eliza",
-      model: undefined,
-      startedAt: undefined,
-      uptime: undefined,
-    })),
-    getWalletAddresses: vi.fn(async () => null),
-    getConfig: vi.fn(async () => ({})),
-    getCloudStatus: vi.fn(async () => ({ enabled: false, connected: false })),
-    getCodingAgentStatus: vi.fn(async () => null),
-    getWorkbenchOverview: vi.fn(async () => ({
-      tasks: [],
-      triggers: [],
-      todos: [],
-    })),
-    startAgent: vi.fn(async () => ({
-      state: "running",
-      agentName: "Eliza",
-      model: undefined,
-      startedAt: undefined,
-      uptime: undefined,
-    })),
-  },
-}));
-
-vi.mock("@elizaos/app-core/api", () => ({
-  client: mockClient,
-  SkillScanReportSummary: {},
-}));
-
-import { AppProvider, useApp } from "@elizaos/app-core/state";
-
-function createDeferred<T>() {
-  let resolve!: (value: T | PromiseLike<T>) => void;
-  const promise = new Promise<T>((res) => {
-    resolve = res;
-  });
-  return { promise, resolve };
-}
-
-function Probe(props: {
-  onReady: (api: { handleStart: () => Promise<void> }) => void;
-}) {
-  const { onReady } = props;
-  const app = useApp();
-  useEffect(() => {
-    onReady({ handleStart: app.handleStart });
-  }, [app, onReady]);
-  return null;
-}
-
-describe("lifecycle action locking", () => {
-  beforeEach(() => {
-    Object.assign(window.location, { protocol: "file:", pathname: "/chat" });
-    Object.assign(window, {
-      setTimeout: globalThis.setTimeout,
-      clearTimeout: globalThis.clearTimeout,
-      setInterval: globalThis.setInterval,
-      clearInterval: globalThis.clearInterval,
-    });
-    Object.assign(document.documentElement, { setAttribute: vi.fn() });
-    for (const fn of Object.values(mockClient)) {
-      if (typeof fn === "function" && "mockReset" in fn) {
-        (fn as { mockReset: () => void }).mockReset();
-      }
-    }
-
-    mockClient.hasToken.mockReturnValue(false);
-    mockClient.getAuthStatus.mockResolvedValue({
-      required: false,
-      pairingEnabled: false,
-      expiresAt: null,
-    });
-    mockClient.getOnboardingStatus.mockResolvedValue({ complete: true });
-    mockClient.listConversations.mockResolvedValue({
-      conversations: [
-        {
-          id: "conv-1",
-          title: "Chat",
-          roomId: "room-1",
-          createdAt: "2026-02-01T00:00:00.000Z",
-          updatedAt: "2026-02-01T00:00:00.000Z",
-        },
-      ],
-    });
-    mockClient.getConversationMessages.mockResolvedValue({
-      messages: [
-        {
-          id: "msg-1",
-          role: "assistant",
-          text: "hello",
-          timestamp: Date.now(),
-        },
-      ],
-    });
-    mockClient.sendWsMessage.mockImplementation(() => {});
-    mockClient.connectWs.mockImplementation(() => {});
-    mockClient.disconnectWs.mockImplementation(() => {});
-    mockClient.onWsEvent.mockReturnValue(() => {});
-    mockClient.getAgentEvents.mockResolvedValue({
-      events: [],
-      latestEventId: null,
-    });
-    mockClient.getStatus.mockResolvedValue({
-      state: "running",
-      agentName: "Eliza",
-      model: undefined,
-      startedAt: undefined,
-      uptime: undefined,
-    });
-    mockClient.getWalletAddresses.mockResolvedValue(null);
-    mockClient.getConfig.mockResolvedValue({});
-    mockClient.getCloudStatus.mockResolvedValue({
-      enabled: false,
-      connected: false,
-    });
-    mockClient.getCodingAgentStatus.mockResolvedValue(null);
-    mockClient.getWorkbenchOverview.mockResolvedValue({
-      tasks: [],
-      triggers: [],
-      todos: [],
-    });
-    mockClient.startAgent.mockResolvedValue({
-      state: "running",
-      agentName: "Eliza",
-      model: undefined,
-      startedAt: undefined,
-      uptime: undefined,
-    });
-  });
-
-  it("allows only one same-tick start action call", async () => {
-    const deferred = createDeferred<{
-      state: "running";
-      agentName: string;
-      model: undefined;
-      startedAt: undefined;
-      uptime: undefined;
-    }>();
-    mockClient.startAgent.mockReturnValue(deferred.promise);
-
-    let api: { handleStart: () => Promise<void> } | null = null;
-    let tree: TestRenderer.ReactTestRenderer;
-    await act(async () => {
-      tree = TestRenderer.create(
-        React.createElement(
-          AppProvider,
-          null,
-          React.createElement(Probe, {
-            onReady: (nextApi) => {
-              api = nextApi;
-            },
-          }),
-        ),
-      );
-    });
-
-    expect(api).not.toBeNull();
-
-    await act(async () => {
-      void api?.handleStart();
-      void api?.handleStart();
-    });
-
-    expect(mockClient.startAgent).toHaveBeenCalledTimes(1);
-
-    await act(async () => {
-      deferred.resolve({
-        state: "running",
-        agentName: "Eliza",
-        model: undefined,
-        startedAt: undefined,
-        uptime: undefined,
-      });
-      await deferred.promise;
-    });
-
-    await act(async () => {
-      tree?.unmount();
-    });
-  });
-
-  it("releases the lock after a failed start so a retry can run", async () => {
-    mockClient.startAgent
-      .mockRejectedValueOnce(new Error("boom"))
-      .mockResolvedValueOnce({
-        state: "running",
-        agentName: "Eliza",
-        model: undefined,
-        startedAt: undefined,
-        uptime: undefined,
-      });
-
-    let api: { handleStart: () => Promise<void> } | null = null;
-    let tree: TestRenderer.ReactTestRenderer;
-    await act(async () => {
-      tree = TestRenderer.create(
-        React.createElement(
-          AppProvider,
-          null,
-          React.createElement(Probe, {
-            onReady: (nextApi) => {
-              api = nextApi;
-            },
-          }),
-        ),
-      );
-    });
-
-    expect(api).not.toBeNull();
-
-    await act(async () => {
-      await api?.handleStart();
-    });
-    await act(async () => {
-      await api?.handleStart();
-    });
-
-    expect(mockClient.startAgent).toHaveBeenCalledTimes(2);
-
-    await act(async () => {
-      tree?.unmount();
-    });
-  });
-});

package/test/app/lifo-popout-utils.test.ts

@@ -1,208 +0,0 @@
-/** @vitest-environment jsdom */
-
-import {
-  buildLifoPopoutUrl,
-  generateLifoSessionId,
-  getLifoSessionIdFromLocation,
-  getLifoSyncChannelName,
-  getPopoutValueFromLocation,
-  isLifoPopoutModeAtLocation,
-  isLifoPopoutValue,
-  LIFO_SYNC_CHANNEL_PREFIX,
-} from "@elizaos/app-core/platform";
-import { describe, expect, it } from "vitest";
-
-describe("isLifoPopoutValue", () => {
-  it('returns true for ""', () => {
-    expect(isLifoPopoutValue("")).toBe(true);
-  });
-
-  it('returns true for "1"', () => {
-    expect(isLifoPopoutValue("1")).toBe(true);
-  });
-
-  it('returns true for "true"', () => {
-    expect(isLifoPopoutValue("true")).toBe(true);
-  });
-
-  it('returns true for "lifo"', () => {
-    expect(isLifoPopoutValue("lifo")).toBe(true);
-  });
-
-  it('returns true for case-insensitive "TRUE"', () => {
-    expect(isLifoPopoutValue("TRUE")).toBe(true);
-  });
-
-  it('returns true for case-insensitive "Lifo"', () => {
-    expect(isLifoPopoutValue("Lifo")).toBe(true);
-  });
-
-  it('returns true for " lifo " (with whitespace)', () => {
-    expect(isLifoPopoutValue(" lifo ")).toBe(true);
-  });
-
-  it("returns false for null", () => {
-    expect(isLifoPopoutValue(null)).toBe(false);
-  });
-
-  it('returns false for "false"', () => {
-    expect(isLifoPopoutValue("false")).toBe(false);
-  });
-
-  it('returns false for "0"', () => {
-    expect(isLifoPopoutValue("0")).toBe(false);
-  });
-
-  it('returns false for "no"', () => {
-    expect(isLifoPopoutValue("no")).toBe(false);
-  });
-
-  it('returns false for "random"', () => {
-    expect(isLifoPopoutValue("random")).toBe(false);
-  });
-});
-
-describe("getPopoutValueFromLocation", () => {
-  it("reads ?popout=lifo from search string", () => {
-    expect(
-      getPopoutValueFromLocation({ search: "?popout=lifo", hash: "" }),
-    ).toBe("lifo");
-  });
-
-  it("reads #/lifo?popout=lifo from hash string", () => {
-    expect(
-      getPopoutValueFromLocation({ search: "", hash: "#/lifo?popout=lifo" }),
-    ).toBe("lifo");
-  });
-
-  it("returns null when no popout param exists", () => {
-    expect(getPopoutValueFromLocation({ search: "", hash: "" })).toBeNull();
-  });
-
-  it("search takes precedence over hash", () => {
-    expect(
-      getPopoutValueFromLocation({
-        search: "?popout=1",
-        hash: "#/lifo?popout=lifo",
-      }),
-    ).toBe("1");
-  });
-});
-
-describe("isLifoPopoutModeAtLocation", () => {
-  it("returns true for search ?popout=lifo", () => {
-    expect(
-      isLifoPopoutModeAtLocation({ search: "?popout=lifo", hash: "" }),
-    ).toBe(true);
-  });
-
-  it("returns true for hash #/lifo?popout=true", () => {
-    expect(
-      isLifoPopoutModeAtLocation({ search: "", hash: "#/lifo?popout=true" }),
-    ).toBe(true);
-  });
-
-  it("returns false for empty location", () => {
-    expect(isLifoPopoutModeAtLocation({ search: "", hash: "" })).toBe(false);
-  });
-
-  it("returns false for ?popout=false", () => {
-    expect(
-      isLifoPopoutModeAtLocation({ search: "?popout=false", hash: "" }),
-    ).toBe(false);
-  });
-});
-
-describe("buildLifoPopoutUrl", () => {
-  it("generates URL with ?popout=lifo param", () => {
-    const url = buildLifoPopoutUrl({
-      baseUrl: "http://localhost:3000/app",
-    });
-    const parsed = new URL(url);
-    expect(parsed.searchParams.get("popout")).toBe("lifo");
-  });
-
-  it("includes lifoSession param when sessionId provided", () => {
-    const url = buildLifoPopoutUrl({
-      baseUrl: "http://localhost:3000/app",
-      sessionId: "abc123",
-    });
-    const parsed = new URL(url);
-    expect(parsed.searchParams.get("lifoSession")).toBe("abc123");
-  });
-
-  it("uses default /lifo path when no targetPath", () => {
-    const url = buildLifoPopoutUrl({
-      baseUrl: "http://localhost:3000/app",
-    });
-    const parsed = new URL(url);
-    expect(parsed.pathname).toBe("/lifo");
-  });
-
-  it("uses provided targetPath", () => {
-    const url = buildLifoPopoutUrl({
-      baseUrl: "http://localhost:3000/app",
-      targetPath: "/custom/path",
-    });
-    const parsed = new URL(url);
-    expect(parsed.pathname).toBe("/custom/path");
-  });
-});
-
-describe("generateLifoSessionId", () => {
-  it("returns a 16-char hex string", () => {
-    const id = generateLifoSessionId();
-    expect(id).toMatch(/^[0-9a-f]{16}$/);
-  });
-
-  it("returns unique values on successive calls", () => {
-    const a = generateLifoSessionId();
-    const b = generateLifoSessionId();
-    expect(a).not.toBe(b);
-  });
-});
-
-describe("getLifoSessionIdFromLocation", () => {
-  it("reads from search: ?lifoSession=abc123", () => {
-    expect(
-      getLifoSessionIdFromLocation({
-        search: "?lifoSession=abc123",
-        hash: "",
-      }),
-    ).toBe("abc123");
-  });
-
-  it("reads from hash: #/lifo?popout=lifo&lifoSession=abc123", () => {
-    expect(
-      getLifoSessionIdFromLocation({
-        search: "",
-        hash: "#/lifo?popout=lifo&lifoSession=abc123",
-      }),
-    ).toBe("abc123");
-  });
-
-  it("returns null when not present", () => {
-    expect(getLifoSessionIdFromLocation({ search: "", hash: "" })).toBeNull();
-  });
-
-  it("search takes precedence over hash", () => {
-    expect(
-      getLifoSessionIdFromLocation({
-        search: "?lifoSession=fromSearch",
-        hash: "#/lifo?lifoSession=fromHash",
-      }),
-    ).toBe("fromSearch");
-  });
-});
-
-describe("getLifoSyncChannelName", () => {
-  it("returns prefixed name when sessionId given", () => {
-    expect(getLifoSyncChannelName("sess42")).toBe(
-      `${LIFO_SYNC_CHANNEL_PREFIX}-sess42`,
-    );
-  });
-
-  it("returns base prefix when sessionId is null", () => {
-    expect(getLifoSyncChannelName(null)).toBe(LIFO_SYNC_CHANNEL_PREFIX);
-  });
-});

package/test/app/lifo-safe-endpoint.test.ts

@@ -1,34 +0,0 @@
-import { isSafeEndpointUrl } from "@elizaos/app-core/platform";
-import { describe, expect, it } from "vitest";
-
-describe("isSafeEndpointUrl", () => {
-  it("returns true for http://localhost:6080", () => {
-    expect(isSafeEndpointUrl("http://localhost:6080")).toBe(true);
-  });
-
-  it("returns true for https://example.com/novnc", () => {
-    expect(isSafeEndpointUrl("https://example.com/novnc")).toBe(true);
-  });
-
-  it("returns false for javascript:alert(1)", () => {
-    expect(isSafeEndpointUrl("javascript:alert(1)")).toBe(false);
-  });
-
-  it("returns false for data: URL", () => {
-    expect(isSafeEndpointUrl("data:text/html,<script>alert(1)</script>")).toBe(
-      false,
-    );
-  });
-
-  it("returns false for ftp://files.example.com", () => {
-    expect(isSafeEndpointUrl("ftp://files.example.com")).toBe(false);
-  });
-
-  it("returns false for empty string", () => {
-    expect(isSafeEndpointUrl("")).toBe(false);
-  });
-
-  it("returns false for invalid URL (random text)", () => {
-    expect(isSafeEndpointUrl("not a url at all")).toBe(false);
-  });
-});

package/test/app/loading-screen.test.tsx

@@ -1,45 +0,0 @@
-import { AvatarLoader } from "@elizaos/app-core/components/AvatarLoader";
-import React from "react";
-import TestRenderer, { act } from "react-test-renderer";
-import { describe, expect, it } from "vitest";
-
-function renderedText(tree: TestRenderer.ReactTestRenderer): string {
-  return tree.root
-    .findAllByType("div")
-    .map((node) => node.children.join(""))
-    .join("\n");
-}
-
-describe("AvatarLoader", () => {
-  it("shows default label", async () => {
-    let tree: TestRenderer.ReactTestRenderer | null = null;
-    await act(async () => {
-      tree = TestRenderer.create(React.createElement(AvatarLoader));
-    });
-    if (!tree) throw new Error("failed to render");
-
-    expect(renderedText(tree)).toContain("Initializing entity");
-  });
-
-  it("shows custom label", async () => {
-    let tree: TestRenderer.ReactTestRenderer | null = null;
-    await act(async () => {
-      tree = TestRenderer.create(
-        React.createElement(AvatarLoader, { label: "Starting systems" }),
-      );
-    });
-    if (!tree) throw new Error("failed to render");
-
-    expect(renderedText(tree)).toContain("Starting systems");
-  });
-
-  it("shows LOADING text", async () => {
-    let tree: TestRenderer.ReactTestRenderer | null = null;
-    await act(async () => {
-      tree = TestRenderer.create(React.createElement(AvatarLoader));
-    });
-    if (!tree) throw new Error("failed to render");
-
-    expect(renderedText(tree)).toContain("LOADING");
-  });
-});