@elizaos/app-core 2.0.0-alpha.52 → 2.0.0-alpha.53

package/src/hooks/useWhatsAppPairing.ts

@@ -1,123 +0,0 @@
-import { useCallback, useEffect, useState } from "react";
-import { client } from "../api/client";
-
-export type WhatsAppPairingStatus =
-  | "idle"
-  | "initializing"
-  | "waiting_for_qr"
-  | "connected"
-  | "disconnected"
-  | "timeout"
-  | "error";
-
-interface WhatsAppPairingState {
-  status: WhatsAppPairingStatus;
-  qrDataUrl: string | null;
-  phoneNumber: string | null;
-  error: string | null;
-}
-
-export function useWhatsAppPairing(accountId = "default") {
-  const [state, setState] = useState<WhatsAppPairingState>({
-    status: "idle",
-    qrDataUrl: null,
-    phoneNumber: null,
-    error: null,
-  });
-
-  useEffect(() => {
-    client
-      .getWhatsAppStatus(accountId)
-      .then((res) => {
-        if (res.authExists) {
-          setState((prev) => ({
-            ...prev,
-            status: "connected",
-          }));
-        }
-      })
-      .catch(() => {
-        // Non-fatal — just means we can't check initial status.
-      });
-  }, [accountId]);
-
-  useEffect(() => {
-    const unbindQr = client.onWsEvent(
-      "whatsapp-qr",
-      (data: Record<string, unknown>) => {
-        if (data.accountId !== accountId) return;
-        setState((prev) => ({
-          ...prev,
-          status: "waiting_for_qr",
-          qrDataUrl: data.qrDataUrl as string,
-        }));
-      },
-    );
-
-    const unbindStatus = client.onWsEvent(
-      "whatsapp-status",
-      (data: Record<string, unknown>) => {
-        if (data.accountId !== accountId) return;
-        setState((prev) => ({
-          ...prev,
-          status: data.status as WhatsAppPairingStatus,
-          phoneNumber: (data.phoneNumber as string) ?? prev.phoneNumber,
-          error: (data.error as string) ?? null,
-          qrDataUrl: data.status === "connected" ? null : prev.qrDataUrl,
-        }));
-      },
-    );
-
-    return () => {
-      unbindQr();
-      unbindStatus();
-    };
-  }, [accountId]);
-
-  const startPairing = useCallback(async () => {
-    setState({
-      status: "initializing",
-      qrDataUrl: null,
-      phoneNumber: null,
-      error: null,
-    });
-    try {
-      const result = await client.startWhatsAppPairing(accountId);
-      if (!result.ok) {
-        setState((prev) => ({
-          ...prev,
-          status: "error",
-          error: result.error ?? "Failed to start pairing",
-        }));
-      }
-    } catch (err) {
-      setState((prev) => ({
-        ...prev,
-        status: "error",
-        error: err instanceof Error ? err.message : String(err),
-      }));
-    }
-  }, [accountId]);
-
-  const stopPairing = useCallback(async () => {
-    await client.stopWhatsAppPairing(accountId).catch(() => {});
-    setState({
-      status: "idle",
-      qrDataUrl: null,
-      phoneNumber: null,
-      error: null,
-    });
-  }, [accountId]);
-
-  const disconnect = useCallback(async () => {
-    await client.disconnectWhatsApp(accountId).catch(() => {});
-    setState({
-      status: "idle",
-      qrDataUrl: null,
-      phoneNumber: null,
-      error: null,
-    });
-  }, [accountId]);
-
-  return { ...state, startPairing, stopPairing, disconnect };
-}

package/src/i18n/index.ts

@@ -1,76 +0,0 @@
-import {
-  DEFAULT_UI_LANGUAGE,
-  MESSAGES,
-  type MessageDict,
-  UI_LANGUAGES,
-  type UiLanguage,
-} from "./messages";
-
-export type TranslationVars = Record<
-  string,
-  string | number | boolean | null | undefined
->;
-
-const UI_LANGUAGE_SET = new Set<string>(UI_LANGUAGES);
-
-function interpolate(template: string, vars?: TranslationVars): string {
-  if (!vars) return template;
-  return template.replace(/\{\{(\w+)\}\}/g, (_, key: string) => {
-    const raw = vars[key];
-    if (raw == null) return "";
-    return String(raw);
-  });
-}
-
-export function normalizeLanguage(input: unknown): UiLanguage {
-  if (typeof input !== "string") return DEFAULT_UI_LANGUAGE;
-  const trimmed = input.trim();
-  if (!trimmed) return DEFAULT_UI_LANGUAGE;
-  if (UI_LANGUAGE_SET.has(trimmed)) return trimmed as UiLanguage;
-
-  const lower = trimmed.toLowerCase();
-  if (lower === "zh" || lower === "zh-cn" || lower.startsWith("zh-hans")) {
-    return "zh-CN";
-  }
-  if (lower === "en" || lower.startsWith("en-")) {
-    return "en";
-  }
-  if (lower.startsWith("ko")) return "ko";
-  if (lower.startsWith("es")) return "es";
-  if (lower.startsWith("pt")) return "pt";
-  return DEFAULT_UI_LANGUAGE;
-}
-
-function messageForLanguage(lang: UiLanguage): MessageDict {
-  return MESSAGES[lang] ?? MESSAGES[DEFAULT_UI_LANGUAGE];
-}
-
-export function t(
-  lang: UiLanguage | string | null | undefined,
-  key: string,
-  vars?: TranslationVars,
-): string {
-  const normalized = normalizeLanguage(lang);
-  const localized = messageForLanguage(normalized);
-  const english = messageForLanguage("en");
-  const defaultValue =
-    typeof vars?.defaultValue === "string" && vars.defaultValue.trim()
-      ? vars.defaultValue
-      : undefined;
-  const template = localized[key] ?? english[key] ?? defaultValue ?? key;
-  return interpolate(template, vars);
-}
-
-export function createTranslator(lang: UiLanguage | string | null | undefined) {
-  const normalized = normalizeLanguage(lang);
-  return (key: string, vars?: TranslationVars): string =>
-    t(normalized, key, vars);
-}
-
-export {
-  DEFAULT_UI_LANGUAGE,
-  MESSAGES,
-  type MessageDict,
-  UI_LANGUAGES,
-  type UiLanguage,
-};

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/index.ts

@@ -1,6 +0,0 @@
-export * from "./App";
-export * from "./api/client";
-export * from "./events";
-export * from "./navigation";
-// Note: types/index.ts has overlapping exports with api/client.ts
-// Use "@elizaos/app-core/types" directly for type-only imports

package/src/navigation/index.ts

@@ -1,282 +0,0 @@
-/**
- * Navigation — tabs + onboarding.
- */
-
-import type { LucideIcon } from "lucide-react";
-import {
-  Brain,
-  Clock3,
-  Gamepad2,
-  MessageSquare,
-  Radio,
-  Settings,
-  Share2,
-  Sparkles,
-  Wallet,
-} from "lucide-react";
-
-/** 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") {
-    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 "Milady";
-  }
-}

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");
-  });
-});