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

package/src/hooks/useKeyboardShortcuts.ts

@@ -1,86 +0,0 @@
-/**
- * Keyboard shortcuts manager for the application.
- */
-
-import { useCallback, useEffect } from "react";
-
-export interface ShortcutConfig {
-  key: string;
-  ctrl?: boolean;
-  shift?: boolean;
-  alt?: boolean;
-  meta?: boolean;
-  handler: () => void;
-  description: string;
-  scope?: "global" | "chat" | "settings";
-}
-
-export function useKeyboardShortcuts(shortcuts: ShortcutConfig[]) {
-  const handleKeyDown = useCallback(
-    (event: KeyboardEvent) => {
-      for (const shortcut of shortcuts) {
-        const keyMatch = event.key.toLowerCase() === shortcut.key.toLowerCase();
-        const ctrlMatch = !!shortcut.ctrl === event.ctrlKey;
-        const shiftMatch = !!shortcut.shift === event.shiftKey;
-        const altMatch = !!shortcut.alt === event.altKey;
-        const metaMatch = !!shortcut.meta === event.metaKey;
-
-        if (keyMatch && ctrlMatch && shiftMatch && altMatch && metaMatch) {
-          event.preventDefault();
-          shortcut.handler();
-          break;
-        }
-      }
-    },
-    [shortcuts],
-  );
-
-  useEffect(() => {
-    window.addEventListener("keydown", handleKeyDown);
-    return () => window.removeEventListener("keydown", handleKeyDown);
-  }, [handleKeyDown]);
-}
-
-// Common shortcuts
-export const COMMON_SHORTCUTS: Omit<ShortcutConfig, "handler">[] = [
-  {
-    key: "k",
-    ctrl: true,
-    description: "Open command palette",
-    scope: "global",
-  },
-  { key: "Enter", ctrl: true, description: "Send message", scope: "chat" },
-  { key: "Escape", description: "Close modal / Cancel", scope: "global" },
-  {
-    key: "?",
-    shift: true,
-    description: "Show keyboard shortcuts",
-    scope: "global",
-  },
-  { key: "r", ctrl: true, description: "Restart agent", scope: "global" },
-  { key: " ", description: "Pause/Resume agent", scope: "global" },
-  {
-    key: "t",
-    ctrl: true,
-    shift: true,
-    description: "Toggle terminal",
-    scope: "global",
-  },
-];
-
-// Hook to get shortcuts display
-export function useShortcutsHelp(): string {
-  return COMMON_SHORTCUTS.map(
-    (s) => `${formatShortcut(s)} — ${s.description}`,
-  ).join("\n");
-}
-
-function formatShortcut(s: Omit<ShortcutConfig, "handler">): string {
-  const parts: string[] = [];
-  if (s.ctrl) parts.push("Ctrl");
-  if (s.shift) parts.push("Shift");
-  if (s.alt) parts.push("Alt");
-  if (s.meta) parts.push("Cmd");
-  parts.push(s.key.length === 1 ? s.key.toUpperCase() : s.key);
-  return parts.join("+");
-}

package/src/hooks/useLifoSync.ts

@@ -1,143 +0,0 @@
-import { useCallback, useEffect, useRef } from "react";
-import {
-  getLifoSyncChannelName,
-  type LifoRuntime,
-  type LifoSyncMessage,
-  normalizeTerminalText,
-} from "../platform";
-
-interface UseLifoSyncOptions {
-  popoutMode: boolean;
-  lifoSessionId: string | null;
-  runtimeRef: React.RefObject<LifoRuntime | null>;
-  appendOutput: (line: string) => void;
-  setRunCount: React.Dispatch<React.SetStateAction<number>>;
-  setSessionKey: React.Dispatch<React.SetStateAction<number>>;
-  setControllerOnline: React.Dispatch<React.SetStateAction<boolean>>;
-  controllerHeartbeatAtRef: React.MutableRefObject<number>;
-}
-
-interface UseLifoSyncReturn {
-  broadcastSyncMessage: (message: Omit<LifoSyncMessage, "source">) => void;
-  syncChannelRef: React.RefObject<BroadcastChannel | null>;
-}
-
-export function useLifoSync({
-  popoutMode,
-  lifoSessionId,
-  runtimeRef,
-  appendOutput,
-  setRunCount,
-  setSessionKey,
-  setControllerOnline,
-  controllerHeartbeatAtRef,
-}: UseLifoSyncOptions): UseLifoSyncReturn {
-  const syncChannelRef = useRef<BroadcastChannel | null>(null);
-
-  const broadcastSyncMessage = useCallback(
-    (message: Omit<LifoSyncMessage, "source">) => {
-      if (!popoutMode) return;
-      syncChannelRef.current?.postMessage({
-        source: "controller",
-        ...message,
-      } satisfies LifoSyncMessage);
-    },
-    [popoutMode],
-  );
-
-  useEffect(() => {
-    if (typeof BroadcastChannel === "undefined") return;
-
-    const channel = new BroadcastChannel(getLifoSyncChannelName(lifoSessionId));
-    syncChannelRef.current = channel;
-
-    let heartbeatInterval: ReturnType<typeof setInterval> | null = null;
-    let heartbeatWatchInterval: ReturnType<typeof setInterval> | null = null;
-
-    if (popoutMode) {
-      setControllerOnline(true);
-      broadcastSyncMessage({ type: "heartbeat" });
-      heartbeatInterval = setInterval(() => {
-        broadcastSyncMessage({ type: "heartbeat" });
-      }, 1000);
-    } else {
-      heartbeatWatchInterval = setInterval(() => {
-        const online = Date.now() - controllerHeartbeatAtRef.current < 3500;
-        setControllerOnline(online);
-      }, 1000);
-    }
-
-    channel.onmessage = (event: MessageEvent<unknown>) => {
-      if (popoutMode) return;
-      const data = event.data as Partial<LifoSyncMessage> | null;
-      if (!data || data.source !== "controller") return;
-
-      if (data.type === "heartbeat") {
-        controllerHeartbeatAtRef.current = Date.now();
-        setControllerOnline(true);
-        return;
-      }
-
-      const runtime = runtimeRef.current;
-      if (!runtime) return;
-
-      switch (data.type) {
-        case "session-reset":
-          setSessionKey((value) => value + 1);
-          break;
-        case "command-start":
-          if (typeof data.command !== "string") return;
-          runtime.terminal.writeln(`$ ${data.command}`);
-          appendOutput(`$ ${data.command}`);
-          setRunCount((prev) => prev + 1);
-          break;
-        case "stdout":
-          if (typeof data.chunk !== "string") return;
-          runtime.terminal.write(normalizeTerminalText(data.chunk));
-          if (data.chunk.trimEnd()) appendOutput(data.chunk.trimEnd());
-          break;
-        case "stderr":
-          if (typeof data.chunk !== "string") return;
-          runtime.terminal.write(normalizeTerminalText(data.chunk));
-          if (data.chunk.trimEnd()) {
-            appendOutput(`stderr: ${data.chunk.trimEnd()}`);
-          }
-          break;
-        case "command-exit":
-          if (typeof data.exitCode !== "number") return;
-          runtime.terminal.writeln(`[exit ${data.exitCode}]`);
-          appendOutput(`[exit ${data.exitCode}]`);
-          try {
-            runtime.explorer.refresh();
-          } catch {
-            // Ignore refresh failures when mirroring popout events.
-          }
-          break;
-        case "command-error":
-          if (typeof data.message !== "string") return;
-          runtime.terminal.writeln(`error: ${data.message}`);
-          appendOutput(`error: ${data.message}`);
-          break;
-      }
-    };
-
-    return () => {
-      if (heartbeatInterval) clearInterval(heartbeatInterval);
-      if (heartbeatWatchInterval) clearInterval(heartbeatWatchInterval);
-      syncChannelRef.current = null;
-      channel.close();
-    };
-  }, [
-    appendOutput,
-    broadcastSyncMessage,
-    controllerHeartbeatAtRef,
-    lifoSessionId,
-    popoutMode,
-    runtimeRef,
-    setControllerOnline,
-    setRunCount,
-    setSessionKey,
-  ]);
-
-  return { broadcastSyncMessage, syncChannelRef };
-}

package/src/hooks/useMemoryMonitor.ts

@@ -1,334 +0,0 @@
-/**
- * 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";
-
-// Extend Performance interface for memory info (Chrome/Edge only)
-interface PerformanceMemory {
-  usedJSHeapSize: number;
-  totalJSHeapSize: number;
-  jsHeapSizeLimit: number;
-}
-
-interface PerformanceWithMemory extends Performance {
-  memory?: PerformanceMemory;
-}
-
-export interface MemoryMetrics {
-  /** Current used JS heap size in bytes */
-  usedHeapSize: number;
-  /** Total JS heap size in bytes */
-  totalHeapSize: number;
-  /** JS heap size limit in bytes */
-  heapSizeLimit: number;
-  /** Heap usage as percentage of limit */
-  usagePercent: number;
-  /** Timestamp of measurement */
-  timestamp: number;
-}
-
-export interface MemorySample {
-  usedHeapSize: number;
-  timestamp: number;
-}
-
-export interface MemoryTrend {
-  /** Growth rate in bytes per minute (positive = growing) */
-  bytesPerMinute: number;
-  /** Growth rate in MB per minute */
-  mbPerMinute: number;
-  /** Number of samples in the analysis window */
-  sampleCount: number;
-  /** Duration of analysis window in minutes */
-  windowMinutes: number;
-}
-
-export interface UseMemoryMonitorOptions {
-  /** Enable memory monitoring (default: true in dev mode) */
-  enabled?: boolean;
-  /** Sampling interval in milliseconds (default: 5000) */
-  sampleInterval?: number;
-  /** Number of samples to keep for trend analysis (default: 60) */
-  maxSamples?: number;
-  /** Threshold in MB/min to consider a leak (default: 1.0) */
-  leakThresholdMbPerMin?: number;
-  /** Minimum samples before detecting leaks (default: 12) */
-  minSamplesForDetection?: number;
-  /** Callback when a potential leak is detected */
-  onLeakDetected?: (trend: MemoryTrend, metrics: MemoryMetrics) => void;
-}
-
-export interface UseMemoryMonitorResult {
-  /** Whether memory API is supported in this browser */
-  supported: boolean;
-  /** Current memory metrics (null if not supported) */
-  metrics: MemoryMetrics | null;
-  /** Memory growth trend analysis */
-  trend: MemoryTrend | null;
-  /** Whether a potential memory leak is detected */
-  isLeaking: boolean;
-  /** Historical samples for charting */
-  samples: MemorySample[];
-  /** Force garbage collection (if available) */
-  forceGC: () => void;
-  /** Clear sample history */
-  clearHistory: () => void;
-  /** Get formatted memory stats for display */
-  getFormattedStats: () => string;
-}
-
-const DEFAULT_OPTIONS: Required<
-  Omit<UseMemoryMonitorOptions, "onLeakDetected">
-> = {
-  enabled: Boolean(import.meta.env.DEV),
-  sampleInterval: 5000,
-  maxSamples: 60,
-  leakThresholdMbPerMin: 1.0,
-  minSamplesForDetection: 12,
-};
-
-function getMemoryInfo(): PerformanceMemory | null {
-  const perf = performance as PerformanceWithMemory;
-  return perf.memory ?? null;
-}
-
-function formatBytes(bytes: number): string {
-  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: MemorySample[]): MemoryTrend | null {
-  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: UseMemoryMonitorOptions = {},
-): UseMemoryMonitorResult {
-  const opts = { ...DEFAULT_OPTIONS, ...options };
-  const {
-    enabled,
-    sampleInterval,
-    maxSamples,
-    leakThresholdMbPerMin,
-    minSamplesForDetection,
-  } = opts;
-
-  const [supported, setSupported] = useState(false);
-  const [metrics, setMetrics] = useState<MemoryMetrics | null>(null);
-  const [samples, setSamples] = useState<MemorySample[]>([]);
-  const [trend, setTrend] = useState<MemoryTrend | null>(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: MemoryMetrics = {
-        usedHeapSize: memInfo.usedJSHeapSize,
-        totalHeapSize: memInfo.totalJSHeapSize,
-        heapSizeLimit: memInfo.jsHeapSizeLimit,
-        usagePercent: (memInfo.usedJSHeapSize / memInfo.jsHeapSizeLimit) * 100,
-        timestamp: now,
-      };
-
-      setMetrics(currentMetrics);
-
-      setSamples((prev) => {
-        const newSample: MemorySample = {
-          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 as Window & { gc?: () => void };
-    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?: {
-  intervalMs?: number;
-  thresholdMbPerMin?: number;
-  onLeak?: (info: { mbPerMinute: number; currentMb: number }) => void;
-}): () => void {
-  const intervalMs = options?.intervalMs ?? 10000;
-  const thresholdMbPerMin = options?.thresholdMbPerMin ?? 2.0;
-  const samples: MemorySample[] = [];
-  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);
-}