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

package/hooks/useMemoryMonitor.js

@@ -0,0 +1,209 @@
+/**
+ * Memory monitoring hook for detecting memory leaks.
+ *
+ * Uses the Performance API's memory metrics (Chrome/Edge only) to track
+ * heap usage over time and detect potential memory leaks by analyzing
+ * growth patterns.
+ *
+ * Usage:
+ *   const { metrics, isLeaking, trend } = useMemoryMonitor({ enabled: true });
+ *
+ * The hook samples memory at regular intervals and calculates:
+ * - Current heap usage
+ * - Heap growth trend (MB/min)
+ * - Leak detection based on sustained growth
+ */
+import { useCallback, useEffect, useRef, useState } from "react";
+const DEFAULT_OPTIONS = {
+    enabled: Boolean(import.meta.env.DEV),
+    sampleInterval: 5000,
+    maxSamples: 60,
+    leakThresholdMbPerMin: 1.0,
+    minSamplesForDetection: 12,
+};
+function getMemoryInfo() {
+    const perf = performance;
+    return perf.memory ?? null;
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}
+function calculateTrend(samples) {
+    if (samples.length < 2)
+        return null;
+    const firstSample = samples[0];
+    const lastSample = samples[samples.length - 1];
+    const durationMs = lastSample.timestamp - firstSample.timestamp;
+    if (durationMs <= 0)
+        return null;
+    const durationMinutes = durationMs / (1000 * 60);
+    const heapChange = lastSample.usedHeapSize - firstSample.usedHeapSize;
+    const bytesPerMinute = heapChange / durationMinutes;
+    const mbPerMinute = bytesPerMinute / (1024 * 1024);
+    return {
+        bytesPerMinute,
+        mbPerMinute,
+        sampleCount: samples.length,
+        windowMinutes: durationMinutes,
+    };
+}
+export function useMemoryMonitor(options = {}) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    const { enabled, sampleInterval, maxSamples, leakThresholdMbPerMin, minSamplesForDetection, } = opts;
+    const [supported, setSupported] = useState(false);
+    const [metrics, setMetrics] = useState(null);
+    const [samples, setSamples] = useState([]);
+    const [trend, setTrend] = useState(null);
+    const [isLeaking, setIsLeaking] = useState(false);
+    const onLeakDetectedRef = useRef(options.onLeakDetected);
+    onLeakDetectedRef.current = options.onLeakDetected;
+    const lastLeakNotifyRef = useRef(0);
+    // Check browser support
+    useEffect(() => {
+        const memInfo = getMemoryInfo();
+        setSupported(memInfo !== null);
+    }, []);
+    // Sample memory at intervals
+    useEffect(() => {
+        if (!enabled || !supported)
+            return;
+        const sample = () => {
+            const memInfo = getMemoryInfo();
+            if (!memInfo)
+                return;
+            const now = Date.now();
+            const currentMetrics = {
+                usedHeapSize: memInfo.usedJSHeapSize,
+                totalHeapSize: memInfo.totalJSHeapSize,
+                heapSizeLimit: memInfo.jsHeapSizeLimit,
+                usagePercent: (memInfo.usedJSHeapSize / memInfo.jsHeapSizeLimit) * 100,
+                timestamp: now,
+            };
+            setMetrics(currentMetrics);
+            setSamples((prev) => {
+                const newSample = {
+                    usedHeapSize: memInfo.usedJSHeapSize,
+                    timestamp: now,
+                };
+                const updated = [...prev, newSample];
+                if (updated.length > maxSamples) {
+                    updated.splice(0, updated.length - maxSamples);
+                }
+                return updated;
+            });
+        };
+        // Initial sample
+        sample();
+        const intervalId = setInterval(sample, sampleInterval);
+        return () => clearInterval(intervalId);
+    }, [enabled, supported, sampleInterval, maxSamples]);
+    // Calculate trend and detect leaks
+    useEffect(() => {
+        if (samples.length < 2) {
+            setTrend(null);
+            setIsLeaking(false);
+            return;
+        }
+        const currentTrend = calculateTrend(samples);
+        setTrend(currentTrend);
+        if (!currentTrend || samples.length < minSamplesForDetection) {
+            setIsLeaking(false);
+            return;
+        }
+        // Detect sustained memory growth
+        const leaking = currentTrend.mbPerMinute > leakThresholdMbPerMin;
+        setIsLeaking(leaking);
+        // Notify callback (throttled to once per minute)
+        if (leaking && metrics && onLeakDetectedRef.current) {
+            const now = Date.now();
+            if (now - lastLeakNotifyRef.current > 60000) {
+                lastLeakNotifyRef.current = now;
+                onLeakDetectedRef.current(currentTrend, metrics);
+            }
+        }
+    }, [samples, minSamplesForDetection, leakThresholdMbPerMin, metrics]);
+    const forceGC = useCallback(() => {
+        // gc() is only available when Chrome is started with --js-flags="--expose-gc"
+        const win = window;
+        if (typeof win.gc === "function") {
+            win.gc();
+        }
+    }, []);
+    const clearHistory = useCallback(() => {
+        setSamples([]);
+        setTrend(null);
+        setIsLeaking(false);
+    }, []);
+    const getFormattedStats = useCallback(() => {
+        if (!metrics)
+            return "Memory monitoring not available";
+        const lines = [
+            `Heap Used: ${formatBytes(metrics.usedHeapSize)}`,
+            `Heap Total: ${formatBytes(metrics.totalHeapSize)}`,
+            `Heap Limit: ${formatBytes(metrics.heapSizeLimit)}`,
+            `Usage: ${metrics.usagePercent.toFixed(1)}%`,
+        ];
+        if (trend) {
+            const trendSign = trend.mbPerMinute >= 0 ? "+" : "";
+            lines.push(`Trend: ${trendSign}${trend.mbPerMinute.toFixed(2)} MB/min`, `Samples: ${trend.sampleCount} (${trend.windowMinutes.toFixed(1)} min)`);
+        }
+        if (isLeaking) {
+            lines.push("WARNING: Potential memory leak detected!");
+        }
+        return lines.join("\n");
+    }, [metrics, trend, isLeaking]);
+    return {
+        supported,
+        metrics,
+        trend,
+        isLeaking,
+        samples,
+        forceGC,
+        clearHistory,
+        getFormattedStats,
+    };
+}
+/**
+ * Lightweight memory leak detector that logs warnings to console.
+ * Can be used as a standalone function without React.
+ */
+export function startMemoryLeakDetector(options) {
+    const intervalMs = options?.intervalMs ?? 10000;
+    const thresholdMbPerMin = options?.thresholdMbPerMin ?? 2.0;
+    const samples = [];
+    const maxSamples = 30;
+    const intervalId = setInterval(() => {
+        const memInfo = getMemoryInfo();
+        if (!memInfo)
+            return;
+        const now = Date.now();
+        samples.push({
+            usedHeapSize: memInfo.usedJSHeapSize,
+            timestamp: now,
+        });
+        if (samples.length > maxSamples) {
+            samples.shift();
+        }
+        if (samples.length >= 6) {
+            const trend = calculateTrend(samples);
+            if (trend && trend.mbPerMinute > thresholdMbPerMin) {
+                const currentMb = memInfo.usedJSHeapSize / (1024 * 1024);
+                console.warn(`[MemoryLeakDetector] Potential memory leak detected!\n` +
+                    `  Growth rate: +${trend.mbPerMinute.toFixed(2)} MB/min\n` +
+                    `  Current heap: ${currentMb.toFixed(1)} MB\n` +
+                    `  Window: ${trend.windowMinutes.toFixed(1)} min (${trend.sampleCount} samples)`);
+                options?.onLeak?.({
+                    mbPerMinute: trend.mbPerMinute,
+                    currentMb,
+                });
+            }
+        }
+    }, intervalMs);
+    return () => clearInterval(intervalId);
+}

package/hooks/useRenderGuard.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Development-only render-rate guard.
+ *
+ * Tracks render timestamps for the named component and logs a console warning
+ * when the component re-renders {@link THRESHOLD} or more times within
+ * {@link WINDOW_MS} ms.  No-op in production builds.
+ *
+ * Usage:
+ * ```ts
+ * function MyComponent() {
+ *   useRenderGuard("MyComponent");
+ *   // …
+ * }
+ * ```
+ */
+export declare function useRenderGuard(name: string): void;
+//# sourceMappingURL=useRenderGuard.d.ts.map

package/hooks/useRenderGuard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRenderGuard.d.ts","sourceRoot":"","sources":["../../src/hooks/useRenderGuard.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAmBjD"}

package/hooks/useRenderGuard.js

@@ -0,0 +1,36 @@
+import { useRef } from "react";
+const THRESHOLD = 3;
+const WINDOW_MS = 1000;
+const IS_DEV = typeof process !== "undefined" &&
+    (process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test");
+/**
+ * Development-only render-rate guard.
+ *
+ * Tracks render timestamps for the named component and logs a console warning
+ * when the component re-renders {@link THRESHOLD} or more times within
+ * {@link WINDOW_MS} ms.  No-op in production builds.
+ *
+ * Usage:
+ * ```ts
+ * function MyComponent() {
+ *   useRenderGuard("MyComponent");
+ *   // …
+ * }
+ * ```
+ */
+export function useRenderGuard(name) {
+    // Always call the hook (preserve hook call order) but skip work in prod.
+    const timestamps = useRef([]);
+    if (!IS_DEV)
+        return;
+    const now = Date.now();
+    const ts = timestamps.current;
+    ts.push(now);
+    // Prune old entries outside the window
+    while (ts.length > 0 && ts[0] < now - WINDOW_MS) {
+        ts.shift();
+    }
+    if (ts.length >= THRESHOLD) {
+        console.warn(`[RenderGuard] "${name}" rendered ${ts.length}× in the last ${WINDOW_MS}ms`);
+    }
+}

package/hooks/useRetakeCapture.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Hook that controls desktop native frame capture for retake.tv streaming.
+ *
+ * Uses the native desktop capture path through the renderer bridge — this captures
+ * the full compositor output including cross-origin iframes (unlike the old canvas approach
+ * which was blocked by same-origin policy).
+ *
+ * The main process handles capture + HTTP POST to /api/stream/frame directly.
+ * This hook just sends start/stop signals.
+ */
+export declare function useRetakeCapture(_iframeRef: React.RefObject<HTMLIFrameElement | null>, active: boolean, fps?: number): void;
+//# sourceMappingURL=useRetakeCapture.d.ts.map

package/hooks/useRetakeCapture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRetakeCapture.d.ts","sourceRoot":"","sources":["../../src/hooks/useRetakeCapture.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AASH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,KAAK,CAAC,SAAS,CAAC,iBAAiB,GAAG,IAAI,CAAC,EACrD,MAAM,EAAE,OAAO,EACf,GAAG,SAAc,QA8ClB"}

package/hooks/useRetakeCapture.js

@@ -0,0 +1,60 @@
+/**
+ * Hook that controls desktop native frame capture for retake.tv streaming.
+ *
+ * Uses the native desktop capture path through the renderer bridge — this captures
+ * the full compositor output including cross-origin iframes (unlike the old canvas approach
+ * which was blocked by same-origin policy).
+ *
+ * The main process handles capture + HTTP POST to /api/stream/frame directly.
+ * This hook just sends start/stop signals.
+ */
+import { useEffect, useRef } from "react";
+import { invokeDesktopBridgeRequest } from "../bridge";
+import { getElizaApiBase } from "../utils/eliza-globals";
+const DEFAULT_FPS = 15;
+const JPEG_QUALITY = 70;
+export function useRetakeCapture(_iframeRef, active, fps = DEFAULT_FPS) {
+    const activeRef = useRef(false);
+    useEffect(() => {
+        if (active && !activeRef.current) {
+            activeRef.current = true;
+            void invokeDesktopBridgeRequest({
+                rpcMethod: "screencaptureStartFrameCapture",
+                ipcChannel: "screencapture:startFrameCapture",
+                params: {
+                    fps,
+                    quality: JPEG_QUALITY,
+                    apiBase: getElizaApiBase() ?? "http://localhost:2138",
+                    endpoint: "/api/stream/frame",
+                },
+            })
+                .then((result) => {
+                if (result === null) {
+                    activeRef.current = false;
+                }
+            })
+                .catch((err) => {
+                console.warn("[retake] Failed to start frame capture:", err);
+                activeRef.current = false;
+            });
+        }
+        else if (!active && activeRef.current) {
+            activeRef.current = false;
+            void invokeDesktopBridgeRequest({
+                rpcMethod: "screencaptureStopFrameCapture",
+                ipcChannel: "screencapture:stopFrameCapture",
+            }).catch((err) => {
+                console.warn("[retake] Failed to stop frame capture:", err);
+            });
+        }
+        return () => {
+            if (activeRef.current) {
+                activeRef.current = false;
+                void invokeDesktopBridgeRequest({
+                    rpcMethod: "screencaptureStopFrameCapture",
+                    ipcChannel: "screencapture:stopFrameCapture",
+                }).catch(() => { });
+            }
+        };
+    }, [active, fps]);
+}

package/hooks/useStreamPopoutNavigation.d.ts

@@ -0,0 +1,3 @@
+export declare function getNextTabForStreamPopoutEvent<TTab extends string>(_detail: unknown): TTab | null;
+export declare function useStreamPopoutNavigation<TTab extends string>(setTab: (tab: TTab) => void): void;
+//# sourceMappingURL=useStreamPopoutNavigation.d.ts.map

package/hooks/useStreamPopoutNavigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useStreamPopoutNavigation.d.ts","sourceRoot":"","sources":["../../src/hooks/useStreamPopoutNavigation.ts"],"names":[],"mappings":"AAEA,wBAAgB,8BAA8B,CAAC,IAAI,SAAS,MAAM,EAChE,OAAO,EAAE,OAAO,GACf,IAAI,GAAG,IAAI,CAEb;AAED,wBAAgB,yBAAyB,CAAC,IAAI,SAAS,MAAM,EAC3D,MAAM,EAAE,CAAC,GAAG,EAAE,IAAI,KAAK,IAAI,GAC1B,IAAI,CAgBN"}

package/hooks/useStreamPopoutNavigation.js

@@ -0,0 +1,17 @@
+import { useEffect } from "react";
+export function getNextTabForStreamPopoutEvent(_detail) {
+    return null;
+}
+export function useStreamPopoutNavigation(setTab) {
+    useEffect(() => {
+        const target = typeof window !== "undefined" ? window : globalThis;
+        const handler = (event) => {
+            const nextTab = getNextTabForStreamPopoutEvent(event.detail);
+            if (nextTab) {
+                setTab(nextTab);
+            }
+        };
+        target.addEventListener("stream-popout", handler);
+        return () => target.removeEventListener("stream-popout", handler);
+    }, [setTab]);
+}

package/hooks/useTimeout.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Custom hook to safely manage `setTimeout` calls within React components.
+ * Automatically clears the timeout if the component unmounts before it fires.
+ *
+ * Returns `{ setTimeout, clearTimeout }` which mimic the global functions.
+ */
+export declare function useTimeout(): {
+    setTimeout: (callback: () => void, ms: number) => NodeJS.Timeout;
+    clearTimeout: (id: ReturnType<typeof setTimeout>) => void;
+};
+//# sourceMappingURL=useTimeout.d.ts.map

package/hooks/useTimeout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTimeout.d.ts","sourceRoot":"","sources":["../../src/hooks/useTimeout.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAgB,UAAU;2BAGsB,MAAM,IAAI,MAAM,MAAM;uBAS1B,UAAU,CAAC,OAAO,UAAU,CAAC;EAgBxE"}

package/hooks/useTimeout.js

@@ -0,0 +1,32 @@
+import { useCallback, useEffect, useRef } from "react";
+/**
+ * Custom hook to safely manage `setTimeout` calls within React components.
+ * Automatically clears the timeout if the component unmounts before it fires.
+ *
+ * Returns `{ setTimeout, clearTimeout }` which mimic the global functions.
+ */
+export function useTimeout() {
+    const timeoutRefs = useRef(new Set());
+    const setSafeTimeout = useCallback((callback, ms) => {
+        const id = setTimeout(() => {
+            timeoutRefs.current.delete(id);
+            callback();
+        }, ms);
+        timeoutRefs.current.add(id);
+        return id;
+    }, []);
+    const clearSafeTimeout = useCallback((id) => {
+        clearTimeout(id);
+        timeoutRefs.current.delete(id);
+    }, []);
+    useEffect(() => {
+        const refs = timeoutRefs;
+        return () => {
+            for (const id of refs.current) {
+                clearTimeout(id);
+            }
+            refs.current.clear();
+        };
+    }, []);
+    return { setTimeout: setSafeTimeout, clearTimeout: clearSafeTimeout };
+}

package/hooks/useVoiceChat.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Bidirectional voice hook for chat + avatar lip sync.
+ *
+ * TTS providers (in priority order):
+ *  1. ElevenLabs  — low-latency streaming endpoint + first-sentence cache.
+ *  2. Browser SpeechSynthesis — fallback when ElevenLabs isn't configured.
+ *
+ * STT: Web Speech API (SpeechRecognition) for user voice input.
+ */
+import type { VoiceConfig } from "../api/client";
+type SpeechSegmentKind = "full" | "first-sentence" | "remainder";
+type SpeechProviderKind = "elevenlabs" | "browser";
+export type VoiceCaptureMode = "idle" | "compose" | "push-to-talk";
+export interface VoicePlaybackStartEvent {
+    text: string;
+    segment: SpeechSegmentKind;
+    provider: SpeechProviderKind;
+    cached: boolean;
+    startedAtMs: number;
+}
+export interface VoiceTranscriptPreviewEvent {
+    mode: Exclude<VoiceCaptureMode, "idle">;
+    isFinal: boolean;
+}
+export interface VoiceChatOptions {
+    /** Called when a final transcript is ready to send */
+    onTranscript: (text: string) => void;
+    /** Called whenever the live transcript buffer changes */
+    onTranscriptPreview?: (text: string, event: VoiceTranscriptPreviewEvent) => void;
+    /** Called when playback of a speech segment starts */
+    onPlaybackStart?: (event: VoicePlaybackStartEvent) => void;
+    /** True when the user is authenticated to Eliza Cloud */
+    cloudConnected?: boolean;
+    /** Whether user speech should immediately interrupt assistant playback */
+    interruptOnSpeech?: boolean;
+    /** Language for speech recognition (default: "en-US") */
+    lang?: string;
+    /** Saved voice configuration — switches TTS provider when set */
+    voiceConfig?: VoiceConfig | null;
+}
+export interface VoiceChatState {
+    /** Whether voice input is currently active */
+    isListening: boolean;
+    /** Current mic capture mode */
+    captureMode: VoiceCaptureMode;
+    /** Whether the agent is currently speaking */
+    isSpeaking: boolean;
+    /** Current mouth openness (0-1) for lip sync */
+    mouthOpen: number;
+    /** Current interim transcript being recognized */
+    interimTranscript: string;
+    /** Whether Web Speech API is supported */
+    supported: boolean;
+    /** True when using real audio analysis (ElevenLabs) for mouth */
+    usingAudioAnalysis: boolean;
+    /** Toggle voice listening on/off */
+    toggleListening: () => void;
+    /** Begin voice capture in compose or push-to-talk mode */
+    startListening: (mode?: Exclude<VoiceCaptureMode, "idle">) => Promise<void>;
+    /** End voice capture and optionally submit the transcript */
+    stopListening: (options?: {
+        submit?: boolean;
+    }) => Promise<void>;
+    /** Speak text aloud with mouth animation */
+    speak: (text: string, options?: {
+        append?: boolean;
+    }) => void;
+    /** Progressively speak an assistant message while it streams */
+    queueAssistantSpeech: (messageId: string, text: string, isFinal: boolean) => void;
+    /** Stop any current speech */
+    stopSpeaking: () => void;
+}
+export declare function nextIdleMouthOpen(currentValue: number): number;
+declare function toSpeakableText(input: string): string;
+declare function splitFirstSentence(text: string): {
+    complete: boolean;
+    firstSentence: string;
+    remainder: string;
+};
+declare function remainderAfter(fullText: string, firstSentence: string): string;
+declare function queueableSpeechPrefix(text: string, isFinal: boolean): string;
+declare function resolveEffectiveVoiceConfig(config: VoiceConfig | null | undefined, options?: {
+    cloudConnected?: boolean;
+}): VoiceConfig | null;
+export declare const __voiceChatInternals: {
+    splitFirstSentence: typeof splitFirstSentence;
+    remainderAfter: typeof remainderAfter;
+    queueableSpeechPrefix: typeof queueableSpeechPrefix;
+    resolveEffectiveVoiceConfig: typeof resolveEffectiveVoiceConfig;
+    toSpeakableText: typeof toSpeakableText;
+};
+export declare function useVoiceChat(options: VoiceChatOptions): VoiceChatState;
+export {};
+//# sourceMappingURL=useVoiceChat.d.ts.map

package/hooks/useVoiceChat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useVoiceChat.d.ts","sourceRoot":"","sources":["../../src/hooks/useVoiceChat.ts"],"names":[],"mappings":"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"}