@elizaos/agent 2.0.0-alpha.358 → 2.0.0-alpha.376

package/packages/app-core/src/hooks/useContextMenu.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Listens for native desktop context-menu events
+ * and dispatches actions into the app state.
+ */
+import { type SavedCustomCommand } from "../chat";
+export type CustomCommand = SavedCustomCommand;
+/** Read saved custom commands from localStorage. */
+export declare function loadCustomCommands(): CustomCommand[];
+export interface ContextMenuState {
+    saveCommandModalOpen: boolean;
+    saveCommandText: string;
+    customCommands: CustomCommand[];
+    closeSaveCommandModal: () => void;
+    confirmSaveCommand: (name: string) => void;
+}
+export declare function useContextMenu(): ContextMenuState;
+//# sourceMappingURL=useContextMenu.d.ts.map

package/packages/app-core/src/hooks/useContextMenu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useContextMenu.d.ts","sourceRoot":"","sources":["../../../../../../app-core/src/hooks/useContextMenu.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAQH,OAAO,EAGL,KAAK,kBAAkB,EACxB,MAAM,SAAS,CAAC;AAIjB,MAAM,MAAM,aAAa,GAAG,kBAAkB,CAAC;AAE/C,oDAAoD;AACpD,wBAAgB,kBAAkB,IAAI,aAAa,EAAE,CAEpD;AAED,MAAM,WAAW,gBAAgB;IAC/B,oBAAoB,EAAE,OAAO,CAAC;IAC9B,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,aAAa,EAAE,CAAC;IAChC,qBAAqB,EAAE,MAAM,IAAI,CAAC;IAClC,kBAAkB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAC5C;AAmBD,wBAAgB,cAAc,IAAI,gBAAgB,CAmIjD"}

package/packages/app-core/src/hooks/useContextMenu.js

@@ -0,0 +1,142 @@
+/**
+ * Listens for native desktop context-menu events
+ * and dispatches actions into the app state.
+ */
+import { useCallback, useEffect, useState } from "react";
+import { invokeDesktopBridgeRequest, isElectrobunRuntime, subscribeDesktopBridgeEvent, } from "../bridge";
+import { appendSavedCustomCommand, loadSavedCustomCommands, } from "../chat";
+import { useChatInputRef } from "../state/ChatComposerContext";
+import { useApp } from "../state/useApp";
+/** Read saved custom commands from localStorage. */
+export function loadCustomCommands() {
+    return loadSavedCustomCommands();
+}
+function getSelectedText(target) {
+    if (target instanceof HTMLInputElement ||
+        target instanceof HTMLTextAreaElement) {
+        const start = target.selectionStart ?? 0;
+        const end = target.selectionEnd ?? start;
+        return target.value.slice(start, end).trim();
+    }
+    if (typeof window.getSelection === "function") {
+        return window.getSelection()?.toString().trim() ?? "";
+    }
+    return "";
+}
+export function useContextMenu() {
+    const { setState, handleChatSend, setActionNotice } = useApp();
+    // useChatInputRef() returns a stable MutableRefObject — subscribing to it never
+    // causes re-renders, so App.tsx (which calls this hook) stays quiet while typing.
+    const chatInputRef = useChatInputRef();
+    const desktopRuntime = isElectrobunRuntime();
+    const [saveCommandModalOpen, setSaveCommandModalOpen] = useState(false);
+    const [saveCommandText, setSaveCommandText] = useState("");
+    const [customCommands, setCustomCommands] = useState(loadCustomCommands);
+    useEffect(() => {
+        const onSaveAsCommand = (payload) => {
+            const command = payload;
+            if (!command?.text)
+                return;
+            setSaveCommandText(command.text);
+            setSaveCommandModalOpen(true);
+        };
+        const onAskAgent = (payload) => {
+            const command = payload;
+            if (!command?.text)
+                return;
+            setState("chatInput", command.text);
+            // Defer send to next tick so chatInput state propagates
+            setTimeout(() => handleChatSend(), 0);
+        };
+        const onCreateSkill = (payload) => {
+            const command = payload;
+            if (!command?.text)
+                return;
+            const prompt = `Create a skill from the following content:\n\n"""${command.text}"""\n\nAnalyze this and create a reusable skill.`;
+            setState("chatInput", prompt);
+            setTimeout(() => handleChatSend(), 0);
+        };
+        const onQuoteInChat = (payload) => {
+            const command = payload;
+            if (!command?.text)
+                return;
+            const quoted = `> ${command.text}\n\n`;
+            const existing = chatInputRef?.current ?? "";
+            setState("chatInput", quoted + existing);
+        };
+        const unsubscribers = [
+            subscribeDesktopBridgeEvent({
+                rpcMessage: "contextMenuSaveAsCommand",
+                ipcChannel: "contextMenu:saveAsCommand",
+                listener: onSaveAsCommand,
+            }),
+            subscribeDesktopBridgeEvent({
+                rpcMessage: "contextMenuAskAgent",
+                ipcChannel: "contextMenu:askAgent",
+                listener: onAskAgent,
+            }),
+            subscribeDesktopBridgeEvent({
+                rpcMessage: "contextMenuCreateSkill",
+                ipcChannel: "contextMenu:createSkill",
+                listener: onCreateSkill,
+            }),
+            subscribeDesktopBridgeEvent({
+                rpcMessage: "contextMenuQuoteInChat",
+                ipcChannel: "contextMenu:quoteInChat",
+                listener: onQuoteInChat,
+            }),
+        ];
+        return () => {
+            for (const unsubscribe of unsubscribers) {
+                unsubscribe();
+            }
+        };
+    }, [setState, handleChatSend, chatInputRef]);
+    useEffect(() => {
+        if (!desktopRuntime || typeof window === "undefined") {
+            return;
+        }
+        const onContextMenu = (event) => {
+            if (event.defaultPrevented) {
+                return;
+            }
+            const text = getSelectedText(event.target);
+            if (!text) {
+                return;
+            }
+            event.preventDefault();
+            void invokeDesktopBridgeRequest({
+                rpcMethod: "desktopShowSelectionContextMenu",
+                ipcChannel: "desktop:showSelectionContextMenu",
+                params: { text },
+            });
+        };
+        window.addEventListener("contextmenu", onContextMenu);
+        return () => {
+            window.removeEventListener("contextmenu", onContextMenu);
+        };
+    }, [desktopRuntime]);
+    const closeSaveCommandModal = useCallback(() => {
+        setSaveCommandModalOpen(false);
+        setSaveCommandText("");
+    }, []);
+    const confirmSaveCommand = useCallback((name) => {
+        const cmd = {
+            name,
+            text: saveCommandText,
+            createdAt: Date.now(),
+        };
+        appendSavedCustomCommand(cmd);
+        setCustomCommands(loadCustomCommands());
+        setSaveCommandModalOpen(false);
+        setSaveCommandText("");
+        setActionNotice(`Saved /${name} command`, "success");
+    }, [saveCommandText, setActionNotice]);
+    return {
+        saveCommandModalOpen,
+        saveCommandText,
+        customCommands,
+        closeSaveCommandModal,
+        confirmSaveCommand,
+    };
+}

package/packages/app-core/src/hooks/useGoogleLifeOpsConnector.d.ts

@@ -0,0 +1,20 @@
+import type { LifeOpsConnectorMode, LifeOpsConnectorSide, LifeOpsGoogleConnectorStatus } from "@elizaos/app-lifeops";
+export interface UseGoogleLifeOpsConnectorOptions {
+    includeAccounts?: boolean;
+    pollIntervalMs?: number;
+    pollWhileDisconnected?: boolean;
+    side?: LifeOpsConnectorSide;
+}
+export declare function useGoogleLifeOpsConnector(options?: UseGoogleLifeOpsConnectorOptions): {
+    readonly accounts: LifeOpsGoogleConnectorStatus[];
+    readonly error: string;
+    readonly loading: boolean;
+    readonly refresh: ({ silent, mode, }?: {
+        silent?: boolean;
+        mode?: LifeOpsConnectorMode | null;
+    }) => Promise<void>;
+    readonly selectedMode: "local" | "remote" | "cloud_managed";
+    readonly side: "agent" | "owner";
+    readonly status: LifeOpsGoogleConnectorStatus;
+};
+//# sourceMappingURL=useGoogleLifeOpsConnector.d.ts.map

package/packages/app-core/src/hooks/useGoogleLifeOpsConnector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGoogleLifeOpsConnector.d.ts","sourceRoot":"","sources":["../../../../../../app-core/src/hooks/useGoogleLifeOpsConnector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,oBAAoB,EACpB,oBAAoB,EACpB,4BAA4B,EAC7B,MAAM,sBAAsB,CAAC;AAM9B,MAAM,WAAW,gCAAgC;IAC/C,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,IAAI,CAAC,EAAE,oBAAoB,CAAC;CAC7B;AAQD,wBAAgB,yBAAyB,CACvC,OAAO,GAAE,gCAAqC;;;;2CAqBzC;QACD,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,IAAI,CAAC,EAAE,oBAAoB,GAAG,IAAI,CAAC;KACpC;;;;EAwDJ"}

package/packages/app-core/src/hooks/useGoogleLifeOpsConnector.js

@@ -0,0 +1,69 @@
+import { useCallback, useEffect, useState } from "react";
+import { client } from "../api";
+const DEFAULT_GOOGLE_CONNECTOR_POLL_INTERVAL_MS = 15_000;
+function formatGoogleConnectorError(cause) {
+    return cause instanceof Error && cause.message.trim().length > 0
+        ? cause.message.trim()
+        : "Google connector status failed to refresh.";
+}
+export function useGoogleLifeOpsConnector(options = {}) {
+    const includeAccounts = options.includeAccounts ?? false;
+    const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_GOOGLE_CONNECTOR_POLL_INTERVAL_MS;
+    const pollWhileDisconnected = options.pollWhileDisconnected ?? true;
+    const side = options.side ?? "owner";
+    const [status, setStatus] = useState(null);
+    const [accounts, setAccounts] = useState([]);
+    const [selectedMode, setSelectedMode] = useState(null);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const refresh = useCallback(async ({ silent = false, mode, } = {}) => {
+        if (!silent) {
+            setLoading(true);
+        }
+        try {
+            const requestedMode = mode === undefined ? selectedMode : mode;
+            const [nextStatus, nextAccounts] = await Promise.all([
+                client.getGoogleLifeOpsConnectorStatus(requestedMode ?? undefined, side),
+                includeAccounts
+                    ? client.getGoogleLifeOpsConnectorAccounts(undefined, side)
+                    : Promise.resolve([]),
+            ]);
+            setStatus(nextStatus);
+            setAccounts(nextAccounts);
+            setSelectedMode(requestedMode ?? nextStatus.mode);
+            setError(null);
+        }
+        catch (cause) {
+            setError(formatGoogleConnectorError(cause));
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [includeAccounts, selectedMode, side]);
+    useEffect(() => {
+        void refresh();
+    }, [refresh]);
+    useEffect(() => {
+        if (pollIntervalMs <= 0) {
+            return;
+        }
+        if (!pollWhileDisconnected && status?.connected !== true) {
+            return;
+        }
+        const intervalId = globalThis.setInterval(() => {
+            void refresh({ silent: true });
+        }, pollIntervalMs);
+        return () => {
+            globalThis.clearInterval(intervalId);
+        };
+    }, [pollIntervalMs, pollWhileDisconnected, refresh, status?.connected]);
+    return {
+        accounts,
+        error,
+        loading,
+        refresh,
+        selectedMode,
+        side,
+        status,
+    };
+}

package/packages/app-core/src/hooks/useKeyboardShortcuts.d.ts

@@ -0,0 +1,5 @@
+import { type ShortcutConfig } from "@elizaos/ui";
+export { formatShortcut, type ShortcutConfig, useKeyboardShortcuts, } from "@elizaos/ui";
+export declare const COMMON_SHORTCUTS: Omit<ShortcutConfig, "handler">[];
+export declare function useShortcutsHelp(): string;
+//# sourceMappingURL=useKeyboardShortcuts.d.ts.map

package/packages/app-core/src/hooks/useKeyboardShortcuts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useKeyboardShortcuts.d.ts","sourceRoot":"","sources":["../../../../../../app-core/src/hooks/useKeyboardShortcuts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,cAAc,EAAE,MAAM,aAAa,CAAC;AAElE,OAAO,EACL,cAAc,EACd,KAAK,cAAc,EACnB,oBAAoB,GACrB,MAAM,aAAa,CAAC;AAGrB,eAAO,MAAM,gBAAgB,EAAE,IAAI,CAAC,cAAc,EAAE,SAAS,CAAC,EAwB7D,CAAC;AAGF,wBAAgB,gBAAgB,IAAI,MAAM,CAIzC"}

package/packages/app-core/src/hooks/useKeyboardShortcuts.js

@@ -0,0 +1,32 @@
+import { formatShortcut } from "@elizaos/ui";
+export { formatShortcut, useKeyboardShortcuts, } from "@elizaos/ui";
+// Common shortcuts — app-specific definitions
+export const COMMON_SHORTCUTS = [
+    {
+        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() {
+    return COMMON_SHORTCUTS.map((s) => `${formatShortcut(s)} — ${s.description}`).join("\n");
+}

package/packages/app-core/src/hooks/useLifeOpsAppState.d.ts

@@ -0,0 +1,21 @@
+export declare function useLifeOpsAppState(): {
+    enabled: boolean;
+    loading: boolean;
+    saving: boolean;
+    error: string;
+    refresh: () => Promise<{
+        enabled: boolean;
+        priorityScoring: {
+            enabled: boolean;
+            model: string | null;
+        };
+    }>;
+    updateEnabled: (nextEnabled: boolean) => Promise<{
+        enabled: boolean;
+        priorityScoring: {
+            enabled: boolean;
+            model: string | null;
+        };
+    }>;
+};
+//# sourceMappingURL=useLifeOpsAppState.d.ts.map

package/packages/app-core/src/hooks/useLifeOpsAppState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLifeOpsAppState.d.ts","sourceRoot":"","sources":["../../../../../../app-core/src/hooks/useLifeOpsAppState.ts"],"names":[],"mappings":"AASA,wBAAgB,kBAAkB;;;;;;;;;;;;iCA+CsB,OAAO;;;;;;;EAyB9D"}

package/packages/app-core/src/hooks/useLifeOpsAppState.js

@@ -0,0 +1,81 @@
+import { useCallback, useEffect, useState } from "react";
+import { client } from "../api";
+function formatLifeOpsAppStateError(cause) {
+    return cause instanceof Error && cause.message.trim().length > 0
+        ? cause.message.trim()
+        : "LifeOps app state failed to load.";
+}
+export function useLifeOpsAppState() {
+    const [enabled, setEnabled] = useState(false);
+    const [loading, setLoading] = useState(true);
+    const [saving, setSaving] = useState(false);
+    const [error, setError] = useState(null);
+    const refresh = useCallback(async () => {
+        setLoading(true);
+        try {
+            const state = await client.getLifeOpsAppState();
+            setEnabled(state.enabled);
+            setError(null);
+            return state;
+        }
+        catch (cause) {
+            setError(formatLifeOpsAppStateError(cause));
+            throw cause;
+        }
+        finally {
+            setLoading(false);
+        }
+    }, []);
+    useEffect(() => {
+        let active = true;
+        void (async () => {
+            try {
+                const state = await client.getLifeOpsAppState();
+                if (!active) {
+                    return;
+                }
+                setEnabled(state.enabled);
+                setError(null);
+            }
+            catch (cause) {
+                if (active) {
+                    setError(formatLifeOpsAppStateError(cause));
+                }
+            }
+            finally {
+                if (active) {
+                    setLoading(false);
+                }
+            }
+        })();
+        return () => {
+            active = false;
+        };
+    }, []);
+    const updateEnabled = useCallback(async (nextEnabled) => {
+        setSaving(true);
+        try {
+            const state = await client.updateLifeOpsAppState({
+                enabled: nextEnabled,
+            });
+            setEnabled(state.enabled);
+            setError(null);
+            return state;
+        }
+        catch (cause) {
+            setError(formatLifeOpsAppStateError(cause));
+            throw cause;
+        }
+        finally {
+            setSaving(false);
+        }
+    }, []);
+    return {
+        enabled,
+        loading,
+        saving,
+        error,
+        refresh,
+        updateEnabled,
+    };
+}

package/packages/app-core/src/hooks/useMediaQuery.d.ts

@@ -0,0 +1,4 @@
+export declare function useMediaQuery(query: string, options?: {
+    defaultValue?: boolean;
+}): boolean;
+//# sourceMappingURL=useMediaQuery.d.ts.map

package/packages/app-core/src/hooks/useMediaQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMediaQuery.d.ts","sourceRoot":"","sources":["../../../../../../app-core/src/hooks/useMediaQuery.ts"],"names":[],"mappings":"AAaA,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE;IAAE,YAAY,CAAC,EAAE,OAAO,CAAA;CAAE,GACnC,OAAO,CAgCT"}

package/packages/app-core/src/hooks/useMediaQuery.js

@@ -0,0 +1,30 @@
+import { useCallback, useSyncExternalStore } from "react";
+function getMediaQueryMatch(query) {
+    if (typeof window === "undefined" ||
+        typeof window.matchMedia !== "function") {
+        return false;
+    }
+    return window.matchMedia(query).matches;
+}
+export function useMediaQuery(query, options) {
+    const defaultValue = options?.defaultValue ?? false;
+    const subscribe = useCallback((onStoreChange) => {
+        if (typeof window === "undefined" ||
+            typeof window.matchMedia !== "function") {
+            return () => { };
+        }
+        const mediaQuery = window.matchMedia(query);
+        const handleChange = () => {
+            onStoreChange();
+        };
+        if (typeof mediaQuery.addEventListener === "function") {
+            mediaQuery.addEventListener("change", handleChange);
+            return () => mediaQuery.removeEventListener("change", handleChange);
+        }
+        mediaQuery.addListener(handleChange);
+        return () => mediaQuery.removeListener(handleChange);
+    }, [query]);
+    const getSnapshot = useCallback(() => getMediaQueryMatch(query), [query]);
+    const getServerSnapshot = useCallback(() => defaultValue, [defaultValue]);
+    return useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+}

package/packages/app-core/src/hooks/useMusicPlayer.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Default guild/room id for plugin-music-player when Discord is not used.
+ * Keep in sync with `ELIZA_DESKTOP_MUSIC_GUILD_ID` in Electrobun `music-player.ts`.
+ */
+export declare const ELIZA_DESKTOP_MUSIC_GUILD_ID = "elizaos-desktop";
+/**
+ * Guild key used by plugin-music-player for web chat — must match
+ * `playAudio` / `queueMusic` (`web-${message.roomId}` when `room.serverId` is unset).
+ */
+export declare function getWebMusicGuildIdFromRoomId(roomId: string | null | undefined): string;
+export type MusicPlaybackUrls = {
+    apiBase: string;
+    guildId: string;
+    streamUrl: string;
+    nowPlayingUrl: string;
+    queueUrl: string;
+};
+export declare function buildMusicPlayerPaths(guildId: string): {
+    stream: string;
+    file: string;
+    nowPlaying: string;
+    queue: string;
+};
+/**
+ * Resolves absolute URLs for plugin-music-player HTTP routes.
+ * On Electrobun, prefers the main-process URL resolution (direct agent port).
+ * Otherwise uses the same API base chain as the rest of the app (boot config →
+ * shell injection → sessionStorage → same origin via empty string, which lets
+ * the Vite dev proxy forward `/music-player/*` to the agent).
+ */
+export declare function resolveMusicPlayerPlaybackUrls(options?: {
+    guildId?: string;
+}): Promise<({
+    ok: true;
+} & MusicPlaybackUrls) | {
+    ok: false;
+    reason: string;
+}>;
+/**
+ * Loads playback URLs for the music player stream. Use `attachStreamToAudioElement`
+ * to point an `<audio>` element at the Ogg Opus stream when a track is playing.
+ */
+export declare function useMusicPlayerStream(options?: {
+    guildId?: string;
+}): {
+    urls: ({
+        ok: true;
+    } & MusicPlaybackUrls) | {
+        ok: false;
+        reason: string;
+    } | null;
+    attachStreamToAudioElement: (el: HTMLAudioElement | null) => void;
+};
+//# sourceMappingURL=useMusicPlayer.d.ts.map

package/packages/app-core/src/hooks/useMusicPlayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMusicPlayer.d.ts","sourceRoot":"","sources":["../../../../../../app-core/src/hooks/useMusicPlayer.ts"],"names":[],"mappings":"AAKA;;;GAGG;AACH,eAAO,MAAM,4BAA4B,oBAAoB,CAAC;AAE9D;;;GAGG;AACH,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAChC,MAAM,CAMR;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG;IACtD,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACf,CAQA;AA6BD;;;;;;GAMG;AACH,wBAAsB,8BAA8B,CAAC,OAAO,CAAC,EAAE;IAC7D,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GAAG,OAAO,CACT,CAAC;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,GAAG,iBAAiB,CAAC,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CACnE,CAsCA;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG;IACpE,IAAI,EACA,CAAC;QAAE,EAAE,EAAE,IAAI,CAAA;KAAE,GAAG,iBAAiB,CAAC,GAClC;QAAE,EAAE,EAAE,KAAK,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAC7B,IAAI,CAAC;IACT,0BAA0B,EAAE,CAAC,EAAE,EAAE,gBAAgB,GAAG,IAAI,KAAK,IAAI,CAAC;CACnE,CA6BA"}

package/packages/app-core/src/hooks/useMusicPlayer.js

@@ -0,0 +1,117 @@
+import { useCallback, useEffect, useState } from "react";
+import { invokeDesktopBridgeRequest } from "../bridge/electrobun-rpc";
+import { getBootConfig } from "../config/boot-config";
+import { getElizaApiBase } from "../utils/eliza-globals";
+/**
+ * Default guild/room id for plugin-music-player when Discord is not used.
+ * Keep in sync with `ELIZA_DESKTOP_MUSIC_GUILD_ID` in Electrobun `music-player.ts`.
+ */
+export const ELIZA_DESKTOP_MUSIC_GUILD_ID = "elizaos-desktop";
+/**
+ * Guild key used by plugin-music-player for web chat — must match
+ * `playAudio` / `queueMusic` (`web-${message.roomId}` when `room.serverId` is unset).
+ */
+export function getWebMusicGuildIdFromRoomId(roomId) {
+    const r = roomId?.trim();
+    if (!r) {
+        return ELIZA_DESKTOP_MUSIC_GUILD_ID;
+    }
+    return `web-${r}`;
+}
+export function buildMusicPlayerPaths(guildId) {
+    const g = encodeURIComponent(guildId);
+    return {
+        stream: `/music-player/stream?guildId=${g}`,
+        file: `/music-player/file?guildId=${g}`,
+        nowPlaying: `/music-player/now-playing?guildId=${g}`,
+        queue: `/music-player/queue?guildId=${g}`,
+    };
+}
+/**
+ * Resolve the API base using the same chain as ElizaClient / resolveApiUrl:
+ * boot config → shell injection → sessionStorage → "" (same origin).
+ * An empty string means relative URLs go through the Vite dev proxy.
+ */
+function resolveApiBase() {
+    const boot = getBootConfig().apiBase?.trim();
+    if (boot)
+        return boot;
+    const injected = getElizaApiBase();
+    if (injected)
+        return injected;
+    if (typeof window !== "undefined") {
+        const stored = window.sessionStorage.getItem("elizaos_api_base")?.trim();
+        if (stored)
+            return stored;
+    }
+    return "";
+}
+/**
+ * Resolves absolute URLs for plugin-music-player HTTP routes.
+ * On Electrobun, prefers the main-process URL resolution (direct agent port).
+ * Otherwise uses the same API base chain as the rest of the app (boot config →
+ * shell injection → sessionStorage → same origin via empty string, which lets
+ * the Vite dev proxy forward `/music-player/*` to the agent).
+ */
+export async function resolveMusicPlayerPlaybackUrls(options) {
+    const guildId = options?.guildId?.trim() || ELIZA_DESKTOP_MUSIC_GUILD_ID;
+    const desktop = await invokeDesktopBridgeRequest({
+        rpcMethod: "musicPlayerGetDesktopPlaybackUrls",
+        ipcChannel: "musicPlayer:getDesktopPlaybackUrls",
+        params: { guildId },
+    });
+    if (desktop &&
+        desktop.ok === true &&
+        typeof desktop.streamUrl === "string" &&
+        typeof desktop.guildId === "string" &&
+        typeof desktop.apiBase === "string" &&
+        typeof desktop.nowPlayingUrl === "string" &&
+        typeof desktop.queueUrl === "string") {
+        return {
+            ok: true,
+            apiBase: desktop.apiBase,
+            guildId: desktop.guildId,
+            streamUrl: desktop.streamUrl,
+            nowPlayingUrl: desktop.nowPlayingUrl,
+            queueUrl: desktop.queueUrl,
+        };
+    }
+    const root = resolveApiBase().replace(/\/$/, "");
+    const paths = buildMusicPlayerPaths(guildId);
+    return {
+        ok: true,
+        apiBase: root,
+        guildId,
+        streamUrl: `${root}${paths.stream}`,
+        nowPlayingUrl: `${root}${paths.nowPlaying}`,
+        queueUrl: `${root}${paths.queue}`,
+    };
+}
+/**
+ * Loads playback URLs for the music player stream. Use `attachStreamToAudioElement`
+ * to point an `<audio>` element at the Ogg Opus stream when a track is playing.
+ */
+export function useMusicPlayerStream(options) {
+    const guildId = options?.guildId ?? ELIZA_DESKTOP_MUSIC_GUILD_ID;
+    const [urls, setUrls] = useState(null);
+    useEffect(() => {
+        let alive = true;
+        void resolveMusicPlayerPlaybackUrls({ guildId }).then((r) => {
+            if (alive)
+                setUrls(r);
+        });
+        return () => {
+            alive = false;
+        };
+    }, [guildId]);
+    const attachStreamToAudioElement = useCallback((el) => {
+        if (!el || !urls?.ok)
+            return;
+        el.crossOrigin = "anonymous";
+        if (el.src !== urls.streamUrl) {
+            el.src = urls.streamUrl;
+            el.load();
+        }
+    }, [urls]);
+    return { urls, attachStreamToAudioElement };
+}

package/packages/app-core/src/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/packages/app-core/src/hooks/useRenderGuard.d.ts.map

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