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

package/src/i18n/messages.ts

@@ -1,21 +0,0 @@
-import en from "./locales/en.json";
-import es from "./locales/es.json";
-import ko from "./locales/ko.json";
-import pt from "./locales/pt.json";
-import zhCN from "./locales/zh-CN.json";
-
-export const UI_LANGUAGES = ["en", "zh-CN", "ko", "es", "pt"] as const;
-
-export type UiLanguage = (typeof UI_LANGUAGES)[number];
-
-export const DEFAULT_UI_LANGUAGE: UiLanguage = "en";
-
-export type MessageDict = Record<string, string>;
-
-export const MESSAGES: Record<UiLanguage, MessageDict> = {
-  en,
-  "zh-CN": zhCN,
-  ko,
-  es,
-  pt,
-};

package/src/navigation/index.ts

@@ -1,286 +0,0 @@
-/**
- * Navigation — tabs + onboarding.
- */
-
-import type { LucideIcon } from "lucide-react";
-import {
-  Brain,
-  Clock3,
-  Gamepad2,
-  MessageSquare,
-  Radio,
-  Settings,
-  Share2,
-  Sparkles,
-  Wallet,
-} from "lucide-react";
-import { DEFAULT_BRANDING } from "../config/branding";
-
-/** Apps are only enabled in dev mode; production builds hide this feature. */
-export const APPS_ENABLED = false; // import.meta.env.DEV;
-
-/** Stream routes stay addressable; the nav hides the tab unless streaming is enabled. */
-export const STREAM_ENABLED = true;
-/**
- * Companion tab — enabled by default since the VRM companion UI launch.
- * Previously opt-in; now opt-out via VITE_ENABLE_COMPANION_MODE=false.
- */
-export const COMPANION_ENABLED =
-  String(import.meta.env.VITE_ENABLE_COMPANION_MODE ?? "true").toLowerCase() !==
-  "false";
-
-export type Tab =
-  | "chat"
-  | "companion"
-  | "stream"
-  | "apps"
-  | "character"
-  | "character-select"
-  | "wallets"
-  | "knowledge"
-  | "connectors"
-  | "triggers"
-  | "plugins"
-  | "skills"
-  | "actions"
-  | "advanced"
-  | "fine-tuning"
-  | "trajectories"
-  | "lifo"
-  | "voice"
-  | "runtime"
-  | "database"
-  | "settings"
-  | "logs"
-  | "security";
-
-export interface TabGroup {
-  label: string;
-  tabs: Tab[];
-  icon: LucideIcon;
-  description?: string;
-}
-
-export const ALL_TAB_GROUPS: TabGroup[] = [
-  {
-    label: "Chat",
-    tabs: ["chat"],
-    icon: MessageSquare,
-    description: "Conversations and messaging",
-  },
-  {
-    label: "Stream",
-    tabs: ["stream"],
-    icon: Radio,
-    description: "Live streaming controls",
-  },
-  {
-    label: "Wallets",
-    tabs: ["wallets"],
-    icon: Wallet,
-    description: "Crypto wallets and inventory",
-  },
-  {
-    label: "Knowledge",
-    tabs: ["knowledge"],
-    icon: Brain,
-    description: "Documents and memory",
-  },
-  {
-    label: "Connectors",
-    tabs: ["connectors"],
-    icon: Share2,
-    description: "Service and data source connections",
-  },
-  {
-    label: "Apps",
-    tabs: ["apps"],
-    icon: Gamepad2,
-    description: "Games and integrations",
-  },
-  {
-    label: "Settings",
-    tabs: ["settings"],
-    icon: Settings,
-    description: "Configuration and preferences",
-  },
-  {
-    label: "Heartbeats",
-    tabs: ["triggers"],
-    icon: Clock3,
-    description: "Scheduled autonomous automations",
-  },
-
-  {
-    label: "Advanced",
-    tabs: [
-      "advanced",
-      "plugins",
-      "skills",
-      "actions",
-      "fine-tuning",
-      "trajectories",
-      "lifo",
-      "runtime",
-      "database",
-      "logs",
-      "security",
-    ],
-    icon: Sparkles,
-    description: "Developer and power user tools",
-  },
-];
-
-/** Compute visible tab groups. Pass streamEnabled explicitly for React reactivity. */
-export function getTabGroups(streamEnabled = STREAM_ENABLED): TabGroup[] {
-  return ALL_TAB_GROUPS.filter(
-    (g) =>
-      (APPS_ENABLED || g.label !== "Apps") &&
-      (streamEnabled || g.label !== "Stream"),
-  );
-}
-
-const TAB_PATHS: Record<Tab, string> = {
-  chat: "/chat",
-  companion: "/companion",
-  stream: "/stream",
-  apps: "/apps",
-  character: "/character",
-  "character-select": "/character-select",
-  triggers: "/triggers",
-  wallets: "/wallets",
-  knowledge: "/knowledge",
-  connectors: "/connectors",
-  plugins: "/plugins",
-  skills: "/skills",
-  actions: "/actions",
-  advanced: "/advanced",
-  "fine-tuning": "/fine-tuning",
-  trajectories: "/trajectories",
-  lifo: "/lifo",
-  voice: "/voice",
-  runtime: "/runtime",
-  database: "/database",
-  settings: "/settings",
-  logs: "/logs",
-  security: "/security",
-};
-
-/** Legacy path redirects — old paths that now map to new tabs. */
-const LEGACY_PATHS: Record<string, Tab> = {
-  "/game": "apps",
-  "/agent": "character",
-  "/inventory": "wallets",
-  "/features": "plugins",
-  "/admin": "advanced",
-  "/config": "settings",
-  "/triggers": "triggers",
-};
-
-const PATH_TO_TAB = new Map(
-  Object.entries(TAB_PATHS).map(([tab, p]) => [p, tab as Tab]),
-);
-
-export function pathForTab(tab: Tab, basePath = ""): string {
-  const base = normalizeBasePath(basePath);
-  const p = TAB_PATHS[tab];
-  return base ? `${base}${p}` : p;
-}
-
-export function tabFromPath(pathname: string, basePath = ""): Tab | null {
-  const base = normalizeBasePath(basePath);
-  let p = pathname || "/";
-  if (base) {
-    if (p === base) p = "/";
-    else if (p.startsWith(`${base}/`)) p = p.slice(base.length);
-  }
-  let normalized = normalizePath(p).toLowerCase();
-  if (normalized.endsWith("/index.html")) normalized = "/";
-  if (normalized === "/") return "chat";
-  if (normalized === "/voice") return "settings";
-  // Companion disabled unless explicitly feature-flagged
-  if (
-    !COMPANION_ENABLED &&
-    (normalized === "/companion" || normalized === "/character-select")
-  ) {
-    return "chat";
-  }
-  // Apps disabled in production builds — redirect to chat
-  if (!APPS_ENABLED && (normalized === "/apps" || normalized === "/game")) {
-    return "chat";
-  }
-  // Stream tab (always enabled)
-  // Check current paths first, then legacy redirects
-  return PATH_TO_TAB.get(normalized) ?? LEGACY_PATHS[normalized] ?? null;
-}
-
-function normalizeBasePath(basePath: string): string {
-  if (!basePath) return "";
-  let base = basePath.trim();
-  if (!base.startsWith("/")) base = `/${base}`;
-  if (base === "/") return "";
-  if (base.endsWith("/")) base = base.slice(0, -1);
-  return base;
-}
-
-function normalizePath(p: string): string {
-  if (!p) return "/";
-  let normalized = p.trim();
-  if (!normalized.startsWith("/")) normalized = `/${normalized}`;
-  if (normalized.length > 1 && normalized.endsWith("/"))
-    normalized = normalized.slice(0, -1);
-  return normalized;
-}
-
-export function titleForTab(tab: Tab): string {
-  switch (tab) {
-    case "chat":
-      return "Chat";
-    case "companion":
-      return "Companion";
-    case "apps":
-      return "Apps";
-    case "character":
-      return "Character";
-    case "character-select":
-      return "Character Select";
-    case "triggers":
-      return "Heartbeats";
-    case "wallets":
-      return "Wallets";
-    case "knowledge":
-      return "Knowledge";
-    case "connectors":
-      return "Connectors";
-    case "plugins":
-      return "Plugins";
-    case "skills":
-      return "Skills";
-    case "actions":
-      return "Actions";
-    case "advanced":
-      return "Advanced";
-    case "fine-tuning":
-      return "Fine-Tuning";
-    case "trajectories":
-      return "Trajectories";
-    case "lifo":
-      return "Lifo";
-    case "voice":
-      return "Voice";
-    case "runtime":
-      return "Runtime";
-    case "database":
-      return "Databases";
-    case "settings":
-      return "Settings";
-    case "logs":
-      return "Logs";
-    case "stream":
-      return "Stream";
-    case "security":
-      return "Security";
-    default:
-      return DEFAULT_BRANDING.appName;
-  }
-}

package/src/navigation.test.ts

@@ -1,189 +0,0 @@
-import {
-  ALL_TAB_GROUPS,
-  APPS_ENABLED,
-  getTabGroups,
-  pathForTab,
-  type Tab,
-  tabFromPath,
-  titleForTab,
-} from "@elizaos/app-core/navigation";
-import { describe, expect, it } from "vitest";
-
-describe("tabFromPath", () => {
-  it("maps core tabs", () => {
-    expect(tabFromPath("/")).toBe("chat");
-    expect(tabFromPath("/chat")).toBe("chat");
-    expect(tabFromPath("/companion")).toBe("companion");
-    expect(tabFromPath("/stream")).toBe("stream");
-    expect(tabFromPath("/character")).toBe("character");
-    expect(tabFromPath("/character-select")).toBe("character-select");
-    expect(tabFromPath("/wallets")).toBe("wallets");
-    expect(tabFromPath("/knowledge")).toBe("knowledge");
-    expect(tabFromPath("/connectors")).toBe("connectors");
-    expect(tabFromPath("/settings")).toBe("settings");
-    expect(tabFromPath("/voice")).toBe("settings");
-  });
-
-  it("maps advanced sub-tabs", () => {
-    expect(tabFromPath("/advanced")).toBe("advanced");
-    expect(tabFromPath("/plugins")).toBe("plugins");
-    expect(tabFromPath("/skills")).toBe("skills");
-    expect(tabFromPath("/actions")).toBe("actions");
-    expect(tabFromPath("/triggers")).toBe("triggers");
-    expect(tabFromPath("/fine-tuning")).toBe("fine-tuning");
-    expect(tabFromPath("/trajectories")).toBe("trajectories");
-    expect(tabFromPath("/lifo")).toBe("lifo");
-    expect(tabFromPath("/runtime")).toBe("runtime");
-    expect(tabFromPath("/database")).toBe("database");
-    expect(tabFromPath("/logs")).toBe("logs");
-    expect(tabFromPath("/security")).toBe("security");
-  });
-
-  it("maps legacy paths", () => {
-    expect(tabFromPath("/game")).toBe(APPS_ENABLED ? "apps" : "chat");
-    expect(tabFromPath("/agent")).toBe("character");
-    expect(tabFromPath("/inventory")).toBe("wallets");
-    expect(tabFromPath("/features")).toBe("plugins");
-    expect(tabFromPath("/admin")).toBe("advanced");
-    expect(tabFromPath("/config")).toBe("settings");
-  });
-
-  it("is case-insensitive for current paths", () => {
-    expect(tabFromPath("/ADVANCED")).toBe("advanced");
-    expect(tabFromPath("/Skills")).toBe("skills");
-  });
-
-  it("returns null for unknown paths", () => {
-    expect(tabFromPath("/workflows")).toBeNull();
-    expect(tabFromPath("/nonexistent")).toBeNull();
-  });
-});
-
-describe("pathForTab", () => {
-  const roundTripTabs: Tab[] = [
-    "chat",
-    "companion",
-    "stream",
-    "character",
-    "character-select",
-    "wallets",
-    "knowledge",
-    "connectors",
-    "plugins",
-    "skills",
-    "actions",
-    "triggers",
-    "advanced",
-    "fine-tuning",
-    "trajectories",
-    "lifo",
-    "runtime",
-    "database",
-    "settings",
-    "logs",
-    "security",
-  ];
-  if (APPS_ENABLED) {
-    roundTripTabs.splice(3, 0, "apps");
-  }
-
-  it("round-trips every routed tab through tabFromPath", () => {
-    for (const tab of roundTripTabs) {
-      const path = pathForTab(tab);
-      expect(tabFromPath(path), `${tab} -> ${path}`).toBe(tab);
-    }
-  });
-
-  it("applies basePath prefixes", () => {
-    expect(pathForTab("chat", "/app")).toBe("/app/chat");
-    expect(pathForTab("actions", "/app")).toBe("/app/actions");
-  });
-});
-
-describe("tab groups", () => {
-  it("removes Character from the top-level navigation groups", () => {
-    expect(ALL_TAB_GROUPS.map((group) => group.label)).not.toContain(
-      "Character",
-    );
-    expect(getTabGroups(false).map((group) => group.label)).not.toContain(
-      "Character",
-    );
-  });
-
-  it("promotes heartbeats to a top-level group and keeps advanced tools grouped together", () => {
-    const settings = ALL_TAB_GROUPS.find((group) => group.label === "Settings");
-    expect(settings?.tabs).toEqual(["settings"]);
-
-    const heartbeats = ALL_TAB_GROUPS.find(
-      (group) => group.label === "Heartbeats",
-    );
-    expect(heartbeats?.tabs).toEqual(["triggers"]);
-
-    const advanced = ALL_TAB_GROUPS.find((group) => group.label === "Advanced");
-    expect(advanced?.tabs).toEqual([
-      "advanced",
-      "plugins",
-      "skills",
-      "actions",
-      "fine-tuning",
-      "trajectories",
-      "lifo",
-      "runtime",
-      "database",
-      "logs",
-      "security",
-    ]);
-  });
-
-  it("keeps every supported tab in at least one group", () => {
-    const groupedTabs = new Set(ALL_TAB_GROUPS.flatMap((group) => group.tabs));
-    const expectedTabs: Tab[] = [
-      "chat",
-      "stream",
-      "apps",
-      "wallets",
-      "knowledge",
-      "connectors",
-      "plugins",
-      "skills",
-      "actions",
-      "triggers",
-      "advanced",
-      "fine-tuning",
-      "trajectories",
-      "lifo",
-      "runtime",
-      "database",
-      "logs",
-      "security",
-      "settings",
-    ];
-
-    for (const tab of expectedTabs) {
-      expect(groupedTabs.has(tab), `missing group for ${tab}`).toBe(true);
-    }
-  });
-
-  it("drops the stream group when stream is disabled", () => {
-    expect(getTabGroups(false).map((group) => group.label)).not.toContain(
-      "Stream",
-    );
-    expect(getTabGroups(true).map((group) => group.label)).toContain("Stream");
-  });
-
-  it("shows Heartbeats in the visible top-level groups", () => {
-    expect(getTabGroups(false).map((group) => group.label)).toContain(
-      "Heartbeats",
-    );
-  });
-});
-
-describe("titleForTab", () => {
-  it("returns human-friendly titles for representative tabs", () => {
-    expect(titleForTab("chat")).toBe("Chat");
-    expect(titleForTab("actions")).toBe("Actions");
-    expect(titleForTab("advanced")).toBe("Advanced");
-    expect(titleForTab("stream")).toBe("Stream");
-    expect(titleForTab("database")).toBe("Databases");
-  });
-});

package/src/onboarding-config.test.ts

@@ -1,104 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import {
-  buildOnboardingConnectionConfig,
-  isElizaCloudConnectionReady,
-} from "./onboarding-config";
-
-describe("buildOnboardingConnectionConfig", () => {
-  it("builds a cloud-managed connection when Eliza Cloud is selected", () => {
-    expect(
-      buildOnboardingConnectionConfig({
-        onboardingRunMode: "cloud",
-        onboardingCloudProvider: "elizacloud",
-        onboardingProvider: "",
-        onboardingApiKey: "ck-test",
-        onboardingPrimaryModel: "",
-        onboardingOpenRouterModel: "",
-        onboardingRemoteConnected: false,
-        onboardingRemoteApiBase: "",
-        onboardingRemoteToken: "",
-        onboardingSmallModel: "openai/gpt-5-mini",
-        onboardingLargeModel: "anthropic/claude-sonnet-4.5",
-      }),
-    ).toEqual({
-      kind: "cloud-managed",
-      cloudProvider: "elizacloud",
-      apiKey: "ck-test",
-      smallModel: "openai/gpt-5-mini",
-      largeModel: "anthropic/claude-sonnet-4.5",
-    });
-  });
-
-  it("builds a local provider connection and carries the openrouter model override", () => {
-    expect(
-      buildOnboardingConnectionConfig({
-        onboardingRunMode: "local",
-        onboardingCloudProvider: "",
-        onboardingProvider: "openrouter",
-        onboardingApiKey: "sk-or-test",
-        onboardingPrimaryModel: "",
-        onboardingOpenRouterModel: "openai/gpt-5-mini",
-        onboardingRemoteConnected: false,
-        onboardingRemoteApiBase: "",
-        onboardingRemoteToken: "",
-        onboardingSmallModel: "",
-        onboardingLargeModel: "",
-      }),
-    ).toEqual({
-      kind: "local-provider",
-      provider: "openrouter",
-      apiKey: "sk-or-test",
-      primaryModel: "openai/gpt-5-mini",
-    });
-  });
-
-  it("builds a remote-provider connection when a remote backend is selected", () => {
-    expect(
-      buildOnboardingConnectionConfig({
-        onboardingRunMode: "cloud",
-        onboardingCloudProvider: "remote",
-        onboardingProvider: "anthropic-subscription",
-        onboardingApiKey: "sk-ant-oat01-test",
-        onboardingPrimaryModel: "",
-        onboardingOpenRouterModel: "",
-        onboardingRemoteConnected: true,
-        onboardingRemoteApiBase: "https://example.com/api",
-        onboardingRemoteToken: "remote-key",
-        onboardingSmallModel: "",
-        onboardingLargeModel: "",
-      }),
-    ).toEqual({
-      kind: "remote-provider",
-      remoteApiBase: "https://example.com/api",
-      remoteAccessToken: "remote-key",
-      provider: "anthropic-subscription",
-      apiKey: "sk-ant-oat01-test",
-      primaryModel: undefined,
-    });
-  });
-});
-
-describe("isElizaCloudConnectionReady", () => {
-  it("treats an existing Eliza Cloud login as ready", () => {
-    expect(
-      isElizaCloudConnectionReady({
-        connection: null,
-        elizaCloudConnected: true,
-      }),
-    ).toBe(true);
-  });
-
-  it("treats a cloud-managed API key connection as ready", () => {
-    expect(
-      isElizaCloudConnectionReady({
-        connection: {
-          kind: "cloud-managed",
-          cloudProvider: "elizacloud",
-          apiKey: "ck-ready",
-        },
-        elizaCloudConnected: false,
-      }),
-    ).toBe(true);
-  });
-});