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

package/test/app/agent-transfer-lock.test.ts

@@ -1,279 +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: [],
-    })),
-    exportAgent: vi.fn(async () => ({
-      blob: async () => new Blob(["x"]),
-      headers: {
-        get: () => null,
-      },
-    })),
-    importAgent: vi.fn(async () => ({
-      agentName: "Eliza",
-      counts: {
-        memories: 1,
-        entities: 0,
-        rooms: 0,
-      },
-    })),
-  },
-}));
-
-vi.mock("@elizaos/app-core/api", () => ({
-  client: mockClient,
-  SkillScanReportSummary: {},
-}));
-
-import type { AppState } from "@elizaos/app-core/state";
-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 };
-}
-
-type ProbeApi = {
-  setState: (
-    key: "exportPassword" | "importPassword" | "importFile",
-    value: unknown,
-  ) => void;
-  handleAgentExport: () => Promise<void>;
-  handleAgentImport: () => Promise<void>;
-};
-
-function Probe(props: { onReady: (api: ProbeApi) => void }) {
-  const { onReady } = props;
-  const app = useApp();
-
-  useEffect(() => {
-    onReady({
-      setState: (key, value) =>
-        app.setState(
-          key,
-          value as AppState["exportPassword" | "importPassword" | "importFile"],
-        ),
-      handleAgentExport: app.handleAgentExport,
-      handleAgentImport: app.handleAgentImport,
-    });
-  }, [app, onReady]);
-
-  return null;
-}
-
-describe("agent transfer 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: [],
-    });
-  });
-
-  it("allows only one same-tick export call", async () => {
-    const deferred = createDeferred<{
-      blob: () => Promise<Blob>;
-      headers: { get: (name: string) => string | null };
-    }>();
-    mockClient.exportAgent.mockReturnValue(deferred.promise);
-
-    let api: ProbeApi | 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 () => {
-      api?.setState("exportPassword", "abcd");
-    });
-
-    await act(async () => {
-      void api?.handleAgentExport();
-      void api?.handleAgentExport();
-    });
-
-    expect(mockClient.exportAgent).toHaveBeenCalledTimes(1);
-
-    await act(async () => {
-      tree?.unmount();
-    });
-  });
-
-  it("allows only one same-tick import call", async () => {
-    const deferred = createDeferred<{
-      agentName: string;
-      counts: { memories: number; entities: number; rooms: number };
-    }>();
-    mockClient.importAgent.mockReturnValue(deferred.promise);
-
-    let api: ProbeApi | 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();
-
-    const fakeFile = {
-      name: "agent-export.eliza-agent",
-      arrayBuffer: async () => new ArrayBuffer(8),
-    } as File;
-
-    await act(async () => {
-      api?.setState("importPassword", "abcd");
-      api?.setState("importFile", fakeFile);
-    });
-
-    await act(async () => {
-      void api?.handleAgentImport();
-      void api?.handleAgentImport();
-    });
-
-    expect(mockClient.importAgent).toHaveBeenCalledTimes(1);
-
-    await act(async () => {
-      tree?.unmount();
-    });
-  });
-});

package/test/app/api-client-electrobun-fallback.test.ts

@@ -1,139 +0,0 @@
-// @vitest-environment jsdom
-
-import { MiladyClient } from "@elizaos/app-core/api";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-describe("MiladyClient desktop API fallback", () => {
-  const originalFetch = globalThis.fetch;
-  const originalBase = (window as { __MILADY_API_BASE__?: string })
-    .__MILADY_API_BASE__;
-  const originalProtocol = window.location.protocol;
-
-  beforeEach(() => {
-    // Aggressively clear global state that might leak from other tests
-    delete (window as { __MILADY_API_BASE__?: string }).__MILADY_API_BASE__;
-    delete (window as { __MILADY_API_TOKEN__?: string }).__MILADY_API_TOKEN__;
-    window.sessionStorage.clear();
-  });
-
-  afterEach(() => {
-    Object.defineProperty(globalThis, "fetch", {
-      value: originalFetch,
-      writable: true,
-      configurable: true,
-    });
-    if (originalBase !== undefined) {
-      (window as { __MILADY_API_BASE__?: string }).__MILADY_API_BASE__ =
-        originalBase;
-    } else {
-      delete (window as { __MILADY_API_BASE__?: string }).__MILADY_API_BASE__;
-    }
-    Object.defineProperty(window, "location", {
-      value: { ...window.location, protocol: originalProtocol },
-      writable: true,
-    });
-  });
-
-  function setProtocol(proto: string) {
-    Object.defineProperty(window, "location", {
-      value: { ...window.location, protocol: proto },
-      writable: true,
-    });
-  }
-
-  it("does not probe localhost on electrobun protocol before API base is injected", async () => {
-    (window as { __MILADY_API_BASE__?: string }).__MILADY_API_BASE__ =
-      undefined;
-    setProtocol("electrobun:");
-
-    const fetchMock = vi.fn(async () => ({
-      ok: true,
-      json: async () => ({
-        state: "starting",
-        agentName: "Milady",
-        model: undefined,
-        uptime: undefined,
-        startedAt: undefined,
-      }),
-    }));
-    Object.defineProperty(globalThis, "fetch", {
-      value: fetchMock,
-      writable: true,
-      configurable: true,
-    });
-
-    const client = new MiladyClient();
-    expect(client.apiAvailable).toBe(false);
-    await expect(client.getStatus()).rejects.toThrow(
-      "API not available (no HTTP origin)",
-    );
-
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-
-  it("prefers injected API base over fallback", async () => {
-    (window as { __MILADY_API_BASE__?: string }).__MILADY_API_BASE__ =
-      "http://localhost:9999";
-    setProtocol("electrobun:");
-
-    const fetchMock = vi.fn(async () => ({
-      ok: true,
-      json: async () => ({
-        state: "running",
-        agentName: "Milady",
-        model: "test",
-        uptime: 1,
-        startedAt: Date.now(),
-      }),
-    }));
-    Object.defineProperty(globalThis, "fetch", {
-      value: fetchMock,
-      writable: true,
-      configurable: true,
-    });
-
-    const client = new MiladyClient();
-    await client.getStatus();
-
-    expect(fetchMock).toHaveBeenCalledWith(
-      "http://localhost:9999/api/status",
-      expect.any(Object),
-    );
-  });
-
-  it("starts unavailable on electrobun and switches to injected API base when injected later", async () => {
-    (window as { __MILADY_API_BASE__?: string }).__MILADY_API_BASE__ =
-      undefined;
-    setProtocol("electrobun:");
-
-    const fetchMock = vi.fn(async () => ({
-      ok: true,
-      json: async () => ({
-        state: "running",
-        agentName: "Milady",
-        model: "test",
-        uptime: 1,
-        startedAt: Date.now(),
-      }),
-    }));
-    Object.defineProperty(globalThis, "fetch", {
-      value: fetchMock,
-      writable: true,
-      configurable: true,
-    });
-
-    const client = new MiladyClient();
-    await expect(client.getStatus()).rejects.toThrow(
-      "API not available (no HTTP origin)",
-    );
-    expect(fetchMock).not.toHaveBeenCalled();
-
-    (window as { __MILADY_API_BASE__?: string }).__MILADY_API_BASE__ =
-      "http://127.0.0.1:4444";
-    await client.getStatus();
-    expect(fetchMock).toHaveBeenLastCalledWith(
-      "http://127.0.0.1:4444/api/status",
-      expect.any(Object),
-    );
-  });
-});

package/test/app/api-client-electron-fallback.test.ts

@@ -1,139 +0,0 @@
-// @vitest-environment jsdom
-
-import { ElizaClient } from "@elizaos/app-core/api";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-describe("ElizaClient Electron API fallback", () => {
-  const originalFetch = globalThis.fetch;
-  const originalBase = (window as { __ELIZA_API_BASE__?: string })
-    .__ELIZA_API_BASE__;
-  const originalProtocol = window.location.protocol;
-
-  beforeEach(() => {
-    // Aggressively clear global state that might leak from other tests
-    delete (window as { __ELIZA_API_BASE__?: string }).__ELIZA_API_BASE__;
-    delete (window as { __ELIZA_API_TOKEN__?: string }).__ELIZA_API_TOKEN__;
-    window.sessionStorage.clear();
-  });
-
-  afterEach(() => {
-    Object.defineProperty(globalThis, "fetch", {
-      value: originalFetch,
-      writable: true,
-      configurable: true,
-    });
-    if (originalBase !== undefined) {
-      (window as { __ELIZA_API_BASE__?: string }).__ELIZA_API_BASE__ =
-        originalBase;
-    } else {
-      delete (window as { __ELIZA_API_BASE__?: string }).__ELIZA_API_BASE__;
-    }
-    Object.defineProperty(window, "location", {
-      value: { ...window.location, protocol: originalProtocol },
-      writable: true,
-    });
-  });
-
-  function setProtocol(proto: string) {
-    Object.defineProperty(window, "location", {
-      value: { ...window.location, protocol: proto },
-      writable: true,
-    });
-  }
-
-  it("does not probe localhost on capacitor-electron protocol before API base is injected", async () => {
-    (window as { __ELIZA_API_BASE__?: string }).__ELIZA_API_BASE__ =
-      undefined;
-    setProtocol("capacitor-electron:");
-
-    const fetchMock = vi.fn(async () => ({
-      ok: true,
-      json: async () => ({
-        state: "starting",
-        agentName: "Eliza",
-        model: undefined,
-        uptime: undefined,
-        startedAt: undefined,
-      }),
-    }));
-    Object.defineProperty(globalThis, "fetch", {
-      value: fetchMock,
-      writable: true,
-      configurable: true,
-    });
-
-    const client = new ElizaClient();
-    expect(client.apiAvailable).toBe(false);
-    await expect(client.getStatus()).rejects.toThrow(
-      "API not available (no HTTP origin)",
-    );
-
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-
-  it("prefers injected API base over fallback", async () => {
-    (window as { __ELIZA_API_BASE__?: string }).__ELIZA_API_BASE__ =
-      "http://localhost:9999";
-    setProtocol("capacitor-electron:");
-
-    const fetchMock = vi.fn(async () => ({
-      ok: true,
-      json: async () => ({
-        state: "running",
-        agentName: "Eliza",
-        model: "test",
-        uptime: 1,
-        startedAt: Date.now(),
-      }),
-    }));
-    Object.defineProperty(globalThis, "fetch", {
-      value: fetchMock,
-      writable: true,
-      configurable: true,
-    });
-
-    const client = new ElizaClient();
-    await client.getStatus();
-
-    expect(fetchMock).toHaveBeenCalledWith(
-      "http://localhost:9999/api/status",
-      expect.any(Object),
-    );
-  });
-
-  it("starts unavailable on capacitor-electron and switches to injected API base when injected later", async () => {
-    (window as { __ELIZA_API_BASE__?: string }).__ELIZA_API_BASE__ =
-      undefined;
-    setProtocol("capacitor-electron:");
-
-    const fetchMock = vi.fn(async () => ({
-      ok: true,
-      json: async () => ({
-        state: "running",
-        agentName: "Eliza",
-        model: "test",
-        uptime: 1,
-        startedAt: Date.now(),
-      }),
-    }));
-    Object.defineProperty(globalThis, "fetch", {
-      value: fetchMock,
-      writable: true,
-      configurable: true,
-    });
-
-    const client = new ElizaClient();
-    await expect(client.getStatus()).rejects.toThrow(
-      "API not available (no HTTP origin)",
-    );
-    expect(fetchMock).not.toHaveBeenCalled();
-
-    (window as { __ELIZA_API_BASE__?: string }).__ELIZA_API_BASE__ =
-      "http://127.0.0.1:4444";
-    await client.getStatus();
-    expect(fetchMock).toHaveBeenLastCalledWith(
-      "http://127.0.0.1:4444/api/status",
-      expect.any(Object),
-    );
-  });
-});

package/test/app/api-client-timeout.test.ts

@@ -1,75 +0,0 @@
-import { ApiError, ElizaClient } from "@elizaos/app-core/api";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-describe("ElizaClient request timeout handling", () => {
-  const originalFetch = globalThis.fetch;
-
-  afterEach(() => {
-    Object.defineProperty(globalThis, "fetch", {
-      value: originalFetch,
-      writable: true,
-      configurable: true,
-    });
-    vi.useRealTimers();
-  });
-
-  it("raises typed timeout error for hung requests", async () => {
-    vi.useFakeTimers();
-
-    const fetchMock = vi.fn(
-      (_url: string, init?: RequestInit) =>
-        new Promise<Response>((_resolve, reject) => {
-          init?.signal?.addEventListener("abort", () => {
-            reject(new DOMException("Aborted", "AbortError"));
-          });
-        }),
-    );
-    Object.defineProperty(globalThis, "fetch", {
-      value: fetchMock,
-      writable: true,
-      configurable: true,
-    });
-
-    const client = new ElizaClient("http://localhost:2138");
-    const request = client.getStatus().catch((err: unknown) => err);
-    await vi.advanceTimersByTimeAsync(10_001);
-
-    const error = await request;
-    expect(error).toBeInstanceOf(ApiError);
-    expect(error).toMatchObject({
-      kind: "timeout",
-      path: "/api/status",
-    });
-  });
-
-  it("raises typed timeout error for raw export requests", async () => {
-    vi.useFakeTimers();
-
-    const fetchMock = vi.fn(
-      (_url: string, init?: RequestInit) =>
-        new Promise<Response>((_resolve, reject) => {
-          init?.signal?.addEventListener("abort", () => {
-            reject(new DOMException("Aborted", "AbortError"));
-          });
-        }),
-    );
-    Object.defineProperty(globalThis, "fetch", {
-      value: fetchMock,
-      writable: true,
-      configurable: true,
-    });
-
-    const client = new ElizaClient("http://localhost:2138");
-    const request = client
-      .exportTrajectories({ format: "json" })
-      .catch((err: unknown) => err);
-    await vi.advanceTimersByTimeAsync(10_001);
-
-    const error = await request;
-    expect(error).toBeInstanceOf(ApiError);
-    expect(error).toMatchObject({
-      kind: "timeout",
-      path: "/api/trajectories/export",
-    });
-  });
-});