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

package/src/types/react-test-renderer.d.ts

@@ -1,45 +0,0 @@
-declare module "react-test-renderer" {
-  import type * as React from "react";
-
-  export interface ReactTestInstance {
-    type: unknown;
-    props: Record<string, unknown>;
-    children: Array<ReactTestInstance | string>;
-    parent: ReactTestInstance | null;
-    find(predicate: (node: ReactTestInstance) => boolean): ReactTestInstance;
-    findAll(
-      predicate: (node: ReactTestInstance) => boolean,
-      options?: { deep?: boolean },
-    ): ReactTestInstance[];
-    findByType(type: unknown): ReactTestInstance;
-    findAllByType(
-      type: unknown,
-      options?: { deep?: boolean },
-    ): ReactTestInstance[];
-    findByProps(props: Record<string, unknown>): ReactTestInstance;
-    findAllByProps(
-      props: Record<string, unknown>,
-      options?: { deep?: boolean },
-    ): ReactTestInstance[];
-  }
-
-  export interface ReactTestRenderer {
-    root: ReactTestInstance;
-    update(nextElement: React.ReactElement): void;
-    unmount(nextElement?: React.ReactElement): void;
-    toJSON(): unknown;
-  }
-
-  export function create(element: React.ReactElement): ReactTestRenderer;
-  export function act<T>(
-    callback: () => Promise<T>,
-  ): Promise<Awaited<T> | undefined>;
-  export function act<T>(callback: () => T): T;
-
-  const TestRenderer: {
-    create: typeof create;
-    act: typeof act;
-  };
-
-  export default TestRenderer;
-}

package/src/utils/asset-url.ts

@@ -1,110 +0,0 @@
-/**
- * Resolve app-shipped public assets (e.g. vrms/, animations/) to runtime-safe URLs.
- *
- * In packaged Electron, the renderer can run on file:// and later navigate to
- * absolute paths (e.g. /chat). Root-relative assets like /vrms/1.vrm then
- * resolve to file:///vrms/1.vrm and fail. We lock the asset base URL once from
- * initial startup and resolve assets against that stable base.
- */
-
-type AssetUrlResolveOptions = {
-  currentUrl?: string;
-  baseUrl?: string;
-};
-
-let cachedRuntimeBaseHref: string | null = null;
-
-function stripLeadingPathMarkers(assetPath: string): string {
-  return assetPath
-    .trim()
-    .replace(/^\.?\//, "")
-    .replace(/^\/+/, "");
-}
-
-function isAlreadyAbsolute(assetPath: string): boolean {
-  if (assetPath.startsWith("//")) return true;
-  return /^[A-Za-z][A-Za-z0-9+.-]*:/.test(assetPath);
-}
-
-function inferBaseForUrl(url: URL): string {
-  if (url.protocol !== "file:") return "/";
-
-  const pathname = url.pathname || "/";
-  if (pathname.endsWith("/")) return pathname;
-
-  const lastSlash = pathname.lastIndexOf("/");
-  if (lastSlash < 0) return "/";
-
-  const tail = pathname.slice(lastSlash + 1);
-  // If the path ends in a file name, use that file's directory.
-  if (tail.includes(".")) return pathname.slice(0, lastSlash + 1) || "/";
-
-  return "/";
-}
-
-function computeBaseHref(currentUrl: string, baseUrl?: string): string {
-  const current = new URL(currentUrl);
-  const base = baseUrl?.trim() || inferBaseForUrl(current);
-  return new URL(base, current).href;
-}
-
-function runtimeBaseHref(): string | null {
-  if (cachedRuntimeBaseHref) return cachedRuntimeBaseHref;
-  if (typeof window === "undefined") return null;
-
-  const href = (window.location as { href?: unknown } | undefined)?.href;
-  if (typeof href !== "string" || !href) return null;
-
-  try {
-    const viteBaseUrl = (import.meta as { env?: { BASE_URL?: string } }).env
-      ?.BASE_URL;
-    cachedRuntimeBaseHref = computeBaseHref(href, viteBaseUrl);
-    return cachedRuntimeBaseHref;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Resolve an app public asset path into a URL safe across http(s), custom
- * schemes, and packaged file:// runtimes.
- */
-export function resolveAppAssetUrl(
-  assetPath: string,
-  options?: AssetUrlResolveOptions,
-): string {
-  if (!assetPath) return assetPath;
-  if (isAlreadyAbsolute(assetPath)) return assetPath;
-
-  const normalized = stripLeadingPathMarkers(assetPath);
-  if (!normalized) return normalized;
-
-  if (options?.currentUrl) {
-    try {
-      const baseHref = computeBaseHref(options.currentUrl, options.baseUrl);
-      return new URL(normalized, baseHref).toString();
-    } catch {
-      return `/${normalized}`;
-    }
-  }
-
-  const baseHref = runtimeBaseHref();
-  if (!baseHref) return `/${normalized}`;
-
-  return new URL(normalized, baseHref).toString();
-}
-
-/**
- * Resolve an API path (e.g. "/api/avatar/vrm") to a full URL reachable from
- * the renderer.  In Electron the page origin is capacitor-electron:// or
- * file://, so bare /api/... paths resolve to the SPA instead of the backend.
- * This helper prefixes with window.__MILADY_API_BASE__ when available.
- */
-export function resolveApiUrl(apiPath: string): string {
-  if (typeof window !== "undefined") {
-    const base = (window as unknown as Record<string, unknown>)
-      .__MILADY_API_BASE__ as string | undefined;
-    if (base) return `${base}${apiPath}`;
-  }
-  return apiPath;
-}

package/src/utils/assistant-text.ts

@@ -1,172 +0,0 @@
-const STAGE_DIRECTION_FIRST_WORDS = new Set([
-  "beam",
-  "beams",
-  "beaming",
-  "blink",
-  "blinks",
-  "blinking",
-  "blush",
-  "blushes",
-  "blushing",
-  "bow",
-  "bows",
-  "bowing",
-  "breathe",
-  "breathes",
-  "breathing",
-  "cheer",
-  "cheers",
-  "cheering",
-  "chuckle",
-  "chuckles",
-  "chuckling",
-  "clap",
-  "claps",
-  "clapping",
-  "cry",
-  "cries",
-  "crying",
-  "curtsy",
-  "curtsies",
-  "curtsying",
-  "dance",
-  "dances",
-  "dancing",
-  "frown",
-  "frowns",
-  "frowning",
-  "gasp",
-  "gasps",
-  "gasping",
-  "gesture",
-  "gestures",
-  "gesturing",
-  "giggle",
-  "giggles",
-  "giggling",
-  "glance",
-  "glances",
-  "glancing",
-  "grin",
-  "grins",
-  "grinning",
-  "laugh",
-  "laughs",
-  "laughing",
-  "lean",
-  "leans",
-  "leaning",
-  "look",
-  "looks",
-  "looking",
-  "nod",
-  "nods",
-  "nodding",
-  "pause",
-  "pauses",
-  "pausing",
-  "point",
-  "points",
-  "pointing",
-  "pose",
-  "poses",
-  "posing",
-  "pout",
-  "pouts",
-  "pouting",
-  "raise",
-  "raises",
-  "raising",
-  "shrug",
-  "shrugs",
-  "shrugging",
-  "sigh",
-  "sighs",
-  "sighing",
-  "smile",
-  "smiles",
-  "smiling",
-  "smirk",
-  "smirks",
-  "smirking",
-  "spin",
-  "spins",
-  "spinning",
-  "stare",
-  "stares",
-  "staring",
-  "stretch",
-  "stretches",
-  "stretching",
-  "sway",
-  "sways",
-  "swaying",
-  "tilt",
-  "tilts",
-  "tilting",
-  "wave",
-  "waves",
-  "waving",
-  "whisper",
-  "whispers",
-  "whispering",
-  "wink",
-  "winks",
-  "winking",
-  "yawn",
-  "yawns",
-  "yawning",
-]);
-
-function collapseInlineWhitespace(input: string): string {
-  return input.replace(/[ \t]+/g, " ").trim();
-}
-
-function looksLikeStageDirection(input: string): boolean {
-  const normalized = collapseInlineWhitespace(input)
-    .replace(/^[^A-Za-z]+/, "")
-    .replace(/[^A-Za-z'-]+$/, "");
-  if (!normalized) return false;
-  const [firstWord = ""] = normalized.toLowerCase().split(/\s+/, 1);
-  return STAGE_DIRECTION_FIRST_WORDS.has(firstWord);
-}
-
-function stripWrappedStageDirections(input: string, pattern: RegExp): string {
-  return input.replace(
-    pattern,
-    (match: string, inner: string, offset: number, source: string) => {
-      const prev = source[offset - 1] ?? "";
-      const next = source[offset + match.length] ?? "";
-      const hasSafeLeftBoundary =
-        offset === 0 || /[\s([{>"'“‘.!?,;:-]/.test(prev);
-      const hasSafeRightBoundary =
-        offset + match.length >= source.length ||
-        /[\s)\]}<"'”’.!?,;:-]/.test(next);
-      if (
-        !hasSafeLeftBoundary ||
-        !hasSafeRightBoundary ||
-        !looksLikeStageDirection(inner)
-      ) {
-        return match;
-      }
-      return " ";
-    },
-  );
-}
-
-function tidyAssistantTextSpacing(input: string): string {
-  return input
-    .replace(/[ \t]+\n/g, "\n")
-    .replace(/\n[ \t]+/g, "\n")
-    .replace(/[ \t]{2,}/g, " ")
-    .replace(/ ?([,.;!?])/g, "$1")
-    .replace(/\(\s+/g, "(")
-    .replace(/\s+\)/g, ")");
-}
-
-export function stripAssistantStageDirections(input: string): string {
-  let normalized = input;
-  normalized = stripWrappedStageDirections(normalized, /\*([^*\n]+)\*/g);
-  normalized = stripWrappedStageDirections(normalized, /_([^_\n]+)_/g);
-  return tidyAssistantTextSpacing(normalized);
-}

package/src/utils/clipboard.ts

@@ -1,41 +0,0 @@
-import { invokeDesktopBridgeRequest } from "../bridge/electrobun-rpc";
-
-function copyWithLegacyDomApi(text: string): boolean {
-  if (typeof document === "undefined") return false;
-
-  const textarea = document.createElement("textarea");
-  textarea.value = text;
-  textarea.setAttribute("readonly", "true");
-  textarea.style.position = "fixed";
-  textarea.style.opacity = "0";
-  textarea.style.pointerEvents = "none";
-  document.body.appendChild(textarea);
-  textarea.select();
-
-  try {
-    return document.execCommand("copy");
-  } catch {
-    return false;
-  } finally {
-    textarea.remove();
-  }
-}
-
-export async function copyTextToClipboard(text: string): Promise<void> {
-  const bridged = await invokeDesktopBridgeRequest<void>({
-    rpcMethod: "desktopWriteToClipboard",
-    ipcChannel: "desktop:writeToClipboard",
-    params: { text },
-  });
-
-  if (bridged !== null) return;
-
-  if (typeof navigator !== "undefined" && navigator.clipboard?.writeText) {
-    await navigator.clipboard.writeText(text);
-    return;
-  }
-
-  if (copyWithLegacyDomApi(text)) return;
-
-  throw new Error("Clipboard API unavailable.");
-}

package/src/utils/desktop-dialogs.ts

@@ -1,80 +0,0 @@
-import { invokeDesktopBridgeRequest } from "../bridge/electrobun-rpc";
-
-type DesktopDialogType = "none" | "info" | "error" | "question" | "warning";
-
-type DesktopAlertOptions = {
-  title: string;
-  message: string;
-  detail?: string;
-  type?: Exclude<DesktopDialogType, "question">;
-};
-
-type DesktopConfirmOptions = {
-  title: string;
-  message: string;
-  detail?: string;
-  type?: Extract<DesktopDialogType, "question" | "warning">;
-  confirmLabel?: string;
-  cancelLabel?: string;
-};
-
-function formatFallbackDialogText(options: {
-  title: string;
-  message: string;
-  detail?: string;
-}) {
-  return [options.title, options.message, options.detail]
-    .filter(Boolean)
-    .join("\n\n");
-}
-
-export async function confirmDesktopAction(
-  options: DesktopConfirmOptions,
-): Promise<boolean> {
-  const response = await invokeDesktopBridgeRequest<{ response?: number }>({
-    rpcMethod: "desktopShowMessageBox",
-    ipcChannel: "desktop:showMessageBox",
-    params: {
-      type: options.type ?? "question",
-      title: options.title,
-      message: options.message,
-      detail: options.detail,
-      buttons: [
-        options.confirmLabel ?? "Confirm",
-        options.cancelLabel ?? "Cancel",
-      ],
-      defaultId: 0,
-      cancelId: 1,
-    },
-  });
-
-  if (response) {
-    return response.response === 0;
-  }
-
-  if (typeof window === "undefined") return false;
-  return window.confirm(formatFallbackDialogText(options));
-}
-
-export async function alertDesktopMessage(
-  options: DesktopAlertOptions,
-): Promise<void> {
-  const response = await invokeDesktopBridgeRequest<{ response?: number }>({
-    rpcMethod: "desktopShowMessageBox",
-    ipcChannel: "desktop:showMessageBox",
-    params: {
-      type: options.type ?? "info",
-      title: options.title,
-      message: options.message,
-      detail: options.detail,
-      buttons: ["OK"],
-      defaultId: 0,
-      cancelId: 0,
-    },
-  });
-
-  if (response) return;
-
-  if (typeof window === "undefined") return;
-  window.alert(formatFallbackDialogText(options));
-}

package/src/utils/index.ts

@@ -1,6 +0,0 @@
-export * from "./asset-url";
-export * from "./assistant-text";
-export * from "./clipboard";
-export * from "./desktop-dialogs";
-export * from "./number-parsing";
-export * from "./openExternalUrl";

package/src/utils/number-parsing.ts

@@ -1,125 +0,0 @@
-export interface ParsePositiveNumberOptions {
-  fallback?: number;
-  floor?: boolean;
-}
-
-export interface ParseClampedNumberOptions {
-  min?: number;
-  max?: number;
-  fallback?: number;
-}
-
-export interface ParseClampedIntegerOptions {
-  min?: number;
-  max?: number;
-  fallback?: number;
-}
-
-function sanitizeNumericText(value: string | null | undefined): string {
-  return value == null ? "" : value.trim();
-}
-
-function normalizeFallback(fallback: number | undefined): number | undefined {
-  return Number.isFinite(fallback) ? fallback : undefined;
-}
-
-/**
- * Parse a positive integer.
- *
- * - trims whitespace
- * - returns `fallback` when missing/invalid/non-finite/<=0
- * - floors the value so `12.9` becomes `12`
- */
-export function parsePositiveInteger(
-  value: string | null | undefined,
-  fallback: number,
-): number;
-export function parsePositiveInteger(
-  value: string | null | undefined,
-  fallback?: number,
-): number | undefined;
-export function parsePositiveInteger(
-  value: string | null | undefined,
-  fallback?: number,
-): number | undefined {
-  const raw = sanitizeNumericText(value);
-  if (!raw) return normalizeFallback(fallback);
-
-  const parsed = Number(raw);
-  if (!Number.isFinite(parsed) || parsed <= 0)
-    return normalizeFallback(fallback);
-
-  return Math.max(1, Math.floor(parsed));
-}
-
-/**
- * Parse a positive floating-point value.
- *
- * - trims whitespace
- * - returns `fallback` when missing/invalid/non-finite/<=0
- */
-export function parsePositiveFloat(
-  value: string | null | undefined,
-  options?: ParsePositiveNumberOptions,
-): number | undefined {
-  const raw = sanitizeNumericText(value);
-  if (!raw) return normalizeFallback(options?.fallback);
-
-  const parsed = Number(raw);
-  if (!Number.isFinite(parsed) || parsed <= 0)
-    return normalizeFallback(options?.fallback);
-
-  return options?.floor ? Math.floor(parsed) : parsed;
-}
-
-/**
- * Parse and clamp a numeric value.
- */
-export function parseClampedFloat(
-  value: string | null | undefined,
-  options: ParseClampedNumberOptions & { fallback: number },
-): number;
-export function parseClampedFloat(
-  value: string | null | undefined,
-  options: ParseClampedNumberOptions = {},
-): number | undefined {
-  const raw = sanitizeNumericText(value);
-  if (!raw) return normalizeFallback(options.fallback);
-
-  const parsed = Number(raw);
-  if (!Number.isFinite(parsed)) return normalizeFallback(options.fallback);
-
-  const min = options.min ?? -Infinity;
-  const max = options.max ?? Infinity;
-  return Math.max(min, Math.min(max, parsed));
-}
-
-/**
- * Parse an integer and optionally clamp it to the provided bounds.
- */
-export function parseClampedInteger(
-  value: string | null | undefined,
-  options: ParseClampedIntegerOptions & { fallback: number },
-): number;
-export function parseClampedInteger(
-  value: string | null | undefined,
-  options?: ParseClampedIntegerOptions,
-): number | undefined;
-export function parseClampedInteger(
-  value: string | null | undefined,
-  options: ParseClampedIntegerOptions = {},
-): number | undefined {
-  const raw = sanitizeNumericText(value);
-  if (!raw) return normalizeFallback(options.fallback);
-
-  const parsed = Number.parseInt(raw, 10);
-  if (!Number.isFinite(parsed)) return normalizeFallback(options.fallback);
-
-  const min = options.min;
-  if (min !== undefined && parsed < min) return min;
-
-  const max = options.max;
-  if (max !== undefined && parsed > max) return max;
-
-  return parsed;
-}

package/src/utils/openExternalUrl.ts

@@ -1,20 +0,0 @@
-import { invokeDesktopBridgeRequest } from "../bridge/electrobun-rpc";
-
-export async function openExternalUrl(url: string): Promise<void> {
-  const bridged = await invokeDesktopBridgeRequest<void>({
-    rpcMethod: "desktopOpenExternal",
-    ipcChannel: "desktop:openExternal",
-    params: { url },
-  });
-
-  if (bridged !== null) return;
-
-  if (typeof window === "undefined" || typeof window.open !== "function") {
-    throw new Error("Popup blocked. Allow popups and try again.");
-  }
-
-  const popup = window.open(url, "_blank", "noopener,noreferrer");
-  if (!popup) {
-    throw new Error("Popup blocked. Allow popups and try again.");
-  }
-}

package/src/utils/spoken-text.ts

@@ -1,65 +0,0 @@
-function collapseWhitespace(input: string): string {
-  return input.replace(/\s+/g, " ").trim();
-}
-
-function stripUrls(input: string): string {
-  return input.replace(/\bhttps?:\/\/\S+/gi, " ");
-}
-
-function stripThinkingAndMarkup(input: string): string {
-  let text = input;
-  text = text.replace(/<think\b[^>]*>[\s\S]*?<\/think>/gi, " ");
-  text = text.replace(
-    /<(analysis|reasoning|scratchpad|tool_calls?|tools?)\b[^>]*>[\s\S]*?<\/\1>/gi,
-    " ",
-  );
-  text = text.replace(/```[\s\S]*?```/g, " ");
-  text = text.replace(/`([^`]+)`/g, "$1");
-  text = text.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
-  text = text.replace(/<[^>\n]+>/g, " ");
-  text = stripUrls(text);
-  return text;
-}
-
-const NON_SPEECH_SEGMENT_PATTERNS = [
-  /\*{1,2}[^*\n]+\*{1,2}/g,
-  /\([^()]*\)/g,
-  /\[[^[\]]*\]/g,
-  /\{[^{}]*\}/g,
-];
-
-function stripNonSpeechDirections(input: string): string {
-  let text = input;
-  while (true) {
-    const previous = text;
-    for (const pattern of NON_SPEECH_SEGMENT_PATTERNS) {
-      text = text.replace(pattern, " ");
-    }
-    if (text === previous) {
-      break;
-    }
-  }
-  return text.replace(/[*()[\]{}]+/g, " ");
-}
-
-function sanitizeSpeechPunctuation(input: string): string {
-  let text = input;
-  text = text.replace(/[•·■▪◦]/g, " ");
-  text = text.replace(/[“”]/g, '"');
-  text = text.replace(/[‘’]/g, "'");
-  text = text.replace(/[…]/g, "...");
-  text = text.replace(/[–—]/g, ", ");
-  text = text.replace(/\s*([,;:])\s*/g, "$1 ");
-  text = text.replace(/\s*([.!?])\s*/g, "$1 ");
-  text = text.replace(/[^\p{L}\p{N}\s.,!?'"%/$:+-]/gu, " ");
-  text = text.replace(/([,.!?])\1+/g, "$1");
-  text = text.replace(/^[,;:.!?]+/g, " ");
-  return text;
-}
-
-export function sanitizeSpeechText(input: string): string {
-  const normalized = input.normalize("NFKC");
-  const stripped = stripThinkingAndMarkup(normalized);
-  const withoutDirections = stripNonSpeechDirections(stripped);
-  return collapseWhitespace(sanitizeSpeechPunctuation(withoutDirections));
-}