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

package/test/ui/command-palette-commands.test.ts

@@ -1,57 +0,0 @@
-import { buildCommands as buildCommandPaletteCommands } from "@elizaos/app-core/chat";
-import { describe, expect, it, vi } from "vitest";
-
-function buildArgs(
-  overrides: Partial<Parameters<typeof buildCommandPaletteCommands>[0]> = {},
-) {
-  return {
-    agentState: "running",
-    activeGameViewerUrl: "",
-    handleStart: vi.fn(),
-
-    handleRestart: vi.fn(),
-    setTab: vi.fn(),
-    setAppsSubTab: vi.fn(),
-    loadPlugins: vi.fn(),
-    loadSkills: vi.fn(),
-    loadLogs: vi.fn(),
-    loadWorkbench: vi.fn(),
-    handleChatClear: vi.fn(),
-    openBugReport: vi.fn(),
-    ...overrides,
-  };
-}
-
-describe("buildCommandPaletteCommands", () => {
-  it("does not include duplicate command ids", () => {
-    const commands = buildCommandPaletteCommands(buildArgs());
-    const ids = commands.map((command) => command.id);
-    expect(new Set(ids).size).toBe(ids.length);
-  });
-
-  it("includes start-agent only when stopped", () => {
-    const stopped = buildCommandPaletteCommands(
-      buildArgs({ agentState: "stopped" }),
-    );
-    const running = buildCommandPaletteCommands(
-      buildArgs({ agentState: "running" }),
-    );
-    expect(stopped.some((command) => command.id === "start-agent")).toBe(true);
-    expect(running.some((command) => command.id === "start-agent")).toBe(false);
-  });
-
-  it("includes nav-current-game only when a game is active", () => {
-    const withGame = buildCommandPaletteCommands(
-      buildArgs({ activeGameViewerUrl: "https://games.example/play" }),
-    );
-    const withoutGame = buildCommandPaletteCommands(
-      buildArgs({ activeGameViewerUrl: "" }),
-    );
-    expect(withGame.some((command) => command.id === "nav-current-game")).toBe(
-      true,
-    );
-    expect(
-      withoutGame.some((command) => command.id === "nav-current-game"),
-    ).toBe(false);
-  });
-});

package/test/ui/ui-renderer.test.ts

@@ -1,39 +0,0 @@
-import { sanitizeLinkHref } from "@elizaos/app-core/config";
-import { describe, expect, it } from "vitest";
-
-describe("sanitizeLinkHref", () => {
-  it("blocks executable protocols", () => {
-    expect(sanitizeLinkHref("javascript:alert(1)")).toBe("#");
-    expect(sanitizeLinkHref(" data:text/html,<svg/onload=alert(1)>")).toBe("#");
-    expect(sanitizeLinkHref("VBSCRIPT:msgbox(1)")).toBe("#");
-  });
-
-  it("blocks file: protocol (desktop filesystem exposure)", () => {
-    expect(sanitizeLinkHref("file:///etc/passwd")).toBe("#");
-    expect(sanitizeLinkHref("FILE:///C:/Windows/System32")).toBe("#");
-  });
-
-  it("blocks control-character obfuscation bypasses", () => {
-    expect(sanitizeLinkHref("java\nscript:alert(1)")).toBe("#");
-    expect(sanitizeLinkHref("java\tscript:alert(1)")).toBe("#");
-    expect(sanitizeLinkHref("java\rscript:alert(1)")).toBe("#");
-    expect(sanitizeLinkHref("dat\na:text/html,x")).toBe("#");
-  });
-
-  it("preserves safe links", () => {
-    expect(sanitizeLinkHref("https://example.com")).toBe("https://example.com");
-    expect(sanitizeLinkHref("mailto:test@example.com")).toBe(
-      "mailto:test@example.com",
-    );
-    expect(sanitizeLinkHref("/settings")).toBe("/settings");
-    expect(sanitizeLinkHref("#section")).toBe("#section");
-    expect(sanitizeLinkHref("./relative")).toBe("./relative");
-    expect(sanitizeLinkHref("../parent")).toBe("../parent");
-    expect(sanitizeLinkHref("?query=1")).toBe("?query=1");
-  });
-
-  it("falls back safely for blank values", () => {
-    expect(sanitizeLinkHref("")).toBe("#");
-    expect(sanitizeLinkHref(undefined)).toBe("#");
-  });
-});

package/test/utils/assistant-text.test.ts

@@ -1,68 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { stripAssistantStageDirections } from "../../src/utils/assistant-text";
-
-describe("stripAssistantStageDirections", () => {
-  it("strips asterisk-wrapped stage directions", () => {
-    const result = stripAssistantStageDirections("Hello *smiles warmly* there");
-    expect(result).not.toContain("smiles warmly");
-    expect(result).toContain("Hello");
-    expect(result).toContain("there");
-  });
-
-  it("strips underscore-wrapped stage directions", () => {
-    const result = stripAssistantStageDirections("Hello _waves happily_ there");
-    expect(result).not.toContain("waves happily");
-  });
-
-  it("preserves asterisk content that is NOT a stage direction", () => {
-    const result = stripAssistantStageDirections(
-      "Use *bold text* for emphasis",
-    );
-    expect(result).toContain("bold text");
-  });
-
-  it("preserves underscore content that is NOT a stage direction", () => {
-    const result = stripAssistantStageDirections(
-      "Use _italic text_ for emphasis",
-    );
-    expect(result).toContain("italic text");
-  });
-
-  it("handles empty input", () => {
-    expect(stripAssistantStageDirections("")).toBe("");
-  });
-
-  it("handles text with no stage directions", () => {
-    expect(stripAssistantStageDirections("Just plain text")).toBe(
-      "Just plain text",
-    );
-  });
-
-  it("handles multiple stage directions in one message", () => {
-    const result = stripAssistantStageDirections(
-      "*nods* I agree. *smiles* That sounds right.",
-    );
-    expect(result).not.toContain("nods");
-    expect(result).not.toContain("smiles");
-    expect(result).toContain("I agree.");
-    expect(result).toContain("That sounds right.");
-  });
-
-  it("handles stage direction at start of text", () => {
-    const result = stripAssistantStageDirections("*laughs* That's funny!");
-    expect(result).not.toContain("laughs");
-    expect(result).toContain("That's funny!");
-  });
-
-  it("handles stage direction at end of text", () => {
-    const result = stripAssistantStageDirections("Goodbye! *waves*");
-    expect(result).not.toContain("waves");
-    expect(result).toContain("Goodbye!");
-  });
-
-  it("does not strip across newlines (asterisk pattern is non-greedy single line)", () => {
-    const input = "*smiles\nacross lines*";
-    const result = stripAssistantStageDirections(input);
-    expect(result).toContain("smiles");
-  });
-});

package/test/utils/eliza-globals.test.ts

@@ -1,59 +0,0 @@
-// @vitest-environment jsdom
-
-import { afterEach, describe, expect, it } from "vitest";
-import {
-  clearElizaApiBase,
-  clearElizaApiToken,
-  getElizaApiBase,
-  getElizaApiToken,
-  setElizaApiBase,
-  setElizaApiToken,
-} from "../../src/utils/eliza-globals";
-
-declare global {
-  interface Window {
-    __ELIZA_API_BASE__?: string;
-    __ELIZA_API_TOKEN__?: string;
-  }
-}
-
-describe("eliza-globals", () => {
-  afterEach(() => {
-    delete window.__ELIZA_API_BASE__;
-    delete window.__ELIZA_API_TOKEN__;
-  });
-
-  describe("getElizaApiBase / setElizaApiBase / clearElizaApiBase", () => {
-    it("returns undefined when no base is set", () => {
-      expect(getElizaApiBase()).toBeUndefined();
-    });
-
-    it("returns the value after setElizaApiBase", () => {
-      setElizaApiBase("http://localhost:3000");
-      expect(getElizaApiBase()).toBe("http://localhost:3000");
-    });
-
-    it("returns undefined after clearElizaApiBase", () => {
-      setElizaApiBase("http://localhost:3000");
-      clearElizaApiBase();
-      expect(getElizaApiBase()).toBeUndefined();
-    });
-  });
-
-  describe("getElizaApiToken / setElizaApiToken / clearElizaApiToken", () => {
-    it("returns undefined when no token is set", () => {
-      expect(getElizaApiToken()).toBeUndefined();
-    });
-
-    it("returns the value after setElizaApiToken", () => {
-      setElizaApiToken("test-token-123");
-      expect(getElizaApiToken()).toBe("test-token-123");
-    });
-
-    it("returns undefined after clearElizaApiToken", () => {
-      setElizaApiToken("test-token-123");
-      clearElizaApiToken();
-      expect(getElizaApiToken()).toBeUndefined();
-    });
-  });
-});

package/test/utils/package-exports.test.ts

@@ -1,70 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
-
-/**
- * Regression test: ensures every subpath used by internal imports
- * has a matching entry in the package.json "exports" map.
- *
- * This prevents Vite / Node resolution errors like:
- *   Missing "./utils/eliza-globals" specifier in "@elizaos/app-core" package
- */
-describe("@elizaos/app-core package exports", () => {
-  const pkgPath = resolve(__dirname, "../../package.json");
-  const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-  const exportKeys = Object.keys(pkg.exports ?? {});
-
-  /**
-   * Subpaths that are imported with deep paths within the package
-   * or by downstream consumers (e.g. @elizaos/home).
-   * Each entry should resolve through the exports map.
-   */
-  const requiredSubpaths = [
-    "./api",
-    "./bridge",
-    "./config",
-    "./events",
-    "./hooks",
-    "./i18n",
-    "./navigation",
-    "./platform",
-    "./state",
-    "./types",
-    "./utils",
-    "./voice",
-    "./autonomy",
-    "./chat",
-    "./coding",
-    "./providers",
-    "./actions",
-    "./onboarding-config",
-    "./companion",
-    "./components",
-    "./styles/base.css",
-    "./styles/xterm.css",
-    "./styles/anime.css",
-    "./styles/onboarding-game.css",
-    "./styles/styles.css",
-  ];
-
-  for (const subpath of requiredSubpaths) {
-    it(`exports "${subpath}"`, () => {
-      expect(exportKeys).toContain(subpath);
-    });
-  }
-
-  /**
-   * Deep wildcard subpaths that must resolve (e.g. ./utils/eliza-globals).
-   * These rely on wildcard entries like "./utils/*" in the exports map.
-   */
-  const deepSubpaths = [
-    { subpath: "./utils/eliza-globals", wildcard: "./utils/*" },
-    { subpath: "./components/StreamView", wildcard: "./components/*" },
-  ];
-
-  for (const { subpath, wildcard } of deepSubpaths) {
-    it(`resolves "${subpath}" via wildcard "${wildcard}"`, () => {
-      expect(exportKeys).toContain(wildcard);
-    });
-  }
-});

package/test/utils/streaming-text.test.ts

@@ -1,89 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  computeStreamingDelta,
-  mergeStreamingText,
-} from "../../src/utils/streaming-text";
-
-describe("mergeStreamingText", () => {
-  it("returns incoming when it starts with existing (cumulative snapshot)", () => {
-    expect(mergeStreamingText("Hello", "Hello world")).toBe("Hello world");
-  });
-
-  it("returns incoming when existing is empty", () => {
-    expect(mergeStreamingText("", "Hello")).toBe("Hello");
-  });
-
-  it("returns existing when incoming is empty", () => {
-    expect(mergeStreamingText("Hello", "")).toBe("Hello");
-  });
-
-  it("returns existing when incoming equals existing", () => {
-    expect(mergeStreamingText("Hello", "Hello")).toBe("Hello");
-  });
-
-  it("keeps existing when incoming is a prefix (regressive snapshot)", () => {
-    expect(mergeStreamingText("Hello world", "Hello")).toBe("Hello world");
-  });
-
-  it("appends new portion when incoming overlaps existing suffix", () => {
-    expect(mergeStreamingText("Hello wor", "world")).toBe("Hello world");
-  });
-
-  it("appends single character even when it matches last char (repeated chars)", () => {
-    expect(mergeStreamingText("Hel", "l")).toBe("Hell");
-  });
-
-  it("builds up character by character correctly", () => {
-    let text = "";
-    for (const char of "Hello") {
-      text = mergeStreamingText(text, char);
-    }
-    expect(text).toBe("Hello");
-  });
-
-  it("drops suffix-only resend larger than 1 character", () => {
-    expect(mergeStreamingText("Hello world", "world")).toBe("Hello world");
-  });
-
-  it("replaces when incoming shares prefix >=8 chars but differs", () => {
-    expect(
-      mergeStreamingText(
-        "The quick brown fox jumps",
-        "The quick brown fox leaps",
-      ),
-    ).toBe("The quick brown fox leaps");
-  });
-
-  it("does not false-positive on short messages with natural overlap", () => {
-    expect(mergeStreamingText("Hi", "Hi there")).toBe("Hi there");
-  });
-
-  it("returns incoming when it contains existing as substring", () => {
-    expect(mergeStreamingText("Hello", "prefix Hello suffix")).toBe(
-      "prefix Hello suffix",
-    );
-  });
-
-  it("concatenates when no overlap detected and not a snapshot", () => {
-    expect(mergeStreamingText("abc", "xyz")).toBe("abcxyz");
-  });
-});
-
-describe("computeStreamingDelta", () => {
-  it("returns empty string when merge result equals existing", () => {
-    expect(computeStreamingDelta("Hello world", "Hello")).toBe("");
-  });
-
-  it("returns only the new portion for cumulative snapshots", () => {
-    expect(computeStreamingDelta("Hello", "Hello world")).toBe(" world");
-  });
-
-  it("returns incoming for snapshot replacements", () => {
-    expect(
-      computeStreamingDelta(
-        "The quick brown fox jumps",
-        "The quick brown fox leaps",
-      ),
-    ).toBe("The quick brown fox leaps");
-  });
-});

package/tsconfig.build.json

@@ -1,19 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "declaration": true,
-    "declarationMap": true,
-    "noEmit": false,
-    "outDir": "./dist",
-    "resolveJsonModule": true,
-    "rootDir": "./src",
-    "tsBuildInfoFile": "./dist/.tsbuildinfo"
-  },
-  "exclude": [
-    "src/**/*.stories.ts",
-    "src/**/*.stories.tsx",
-    "src/**/*.test.ts",
-    "src/**/*.test.tsx"
-  ],
-  "include": ["src"]
-}

package/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ES2022",
-    "moduleResolution": "bundler",
-    "jsx": "react-jsx",
-    "strict": true,
-    "skipLibCheck": true,
-    "types": ["node"],
-    "declaration": false,
-    "noEmit": true
-  },
-  "exclude": [
-    "src/**/*.stories.ts",
-    "src/**/*.stories.tsx",
-    "src/**/*.test.ts",
-    "src/**/*.test.tsx"
-  ],
-  "include": ["src"]
-}

package/tsconfig.typecheck.json

@@ -1,12 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "noEmit": true,
-    "noImplicitAny": false
-  },
-  "exclude": [
-    "src/**/*.stories.ts",
-    "src/**/*.stories.tsx"
-  ],
-  "include": ["src", "test"]
-}