reachy-mini 1.2.5rc1__py3-none-any.whl

reachy_mini/daemon/app/dashboard/static/js/appstore.js

@@ -0,0 +1,167 @@
+
+const hfAppsStore = {
+    refreshAppList: async () => {
+        const appsData = await hfAppsStore.fetchAvailableApps();
+        await hfAppsStore.displayAvailableApps(appsData);
+    },
+    fetchAvailableApps: async () => {
+        // Decide which source to query based on the toggle state.
+        const includeCommunity = document.getElementById('hf-show-community')?.checked === true;
+        const source = includeCommunity ? 'hf_space' : 'dashboard_selection';
+        const resAvailable = await fetch(`/api/apps/list-available/${source}`);
+        const appsData = await resAvailable.json();
+        return appsData;
+    },
+
+    isInstalling: false,
+
+    installApp: async (app) => {
+        if (hfAppsStore.isInstalling) {
+            console.warn('An installation is already in progress.');
+            return;
+        }
+        hfAppsStore.isInstalling = true;
+
+        const appName = app.extra.cardData.title || app.name;
+        console.log(`Installing ${app.name}...`);
+
+        const resp = await fetch('/api/apps/install', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(app)
+        });
+        const data = await resp.json();
+        const jobId = data.job_id;
+
+        hfAppsStore.appInstallLogHandler(appName, jobId);
+    },
+
+    displayAvailableApps: async (appsData) => {
+        const appsListElement = document.getElementById('hf-available-apps');
+        appsListElement.innerHTML = '';
+
+        if (!appsData || appsData.length === 0) {
+            appsListElement.innerHTML = '<li>No available apps found.</li>';
+            return;
+        }
+
+        const hfApps = appsData.filter(app => app.source_kind === 'hf_space');
+        const installedApps = await fetch('/api/apps/list-available/installed').then(res => res.json());
+
+        hfApps.forEach(app => {
+            const li = document.createElement('li');
+            li.className = 'app-list-item';
+            const isInstalled = installedApps.some(installedApp => installedApp.name === app.name);
+            li.appendChild(hfAppsStore.createAppElement(app, isInstalled));
+            appsListElement.appendChild(li);
+        });
+    },
+
+    createAppElement: (app, isInstalled) => {
+        const container = document.createElement('div');
+        container.className = 'grid grid-cols-[2rem_auto_8rem] justify-stretch gap-x-6';
+
+        const iconDiv = document.createElement('div');
+        iconDiv.className = 'hf-app-icon row-span-2 my-1';
+        iconDiv.textContent = app.extra.cardData.emoji || '📦';
+        container.appendChild(iconDiv);
+
+        const nameDiv = document.createElement('div');
+        nameDiv.className = 'flex flex-col';
+
+        const titleDiv = document.createElement('a');
+        titleDiv.href = app.url;
+        titleDiv.target = '_blank';
+        titleDiv.rel = 'noopener noreferrer';
+        titleDiv.className = 'hf-app-title';
+        titleDiv.textContent = app.extra.cardData.title || app.name;
+        nameDiv.appendChild(titleDiv);
+        const descriptionDiv = document.createElement('span');
+        descriptionDiv.className = 'hf-app-description';
+        descriptionDiv.textContent = app.description || 'No description available.';
+        nameDiv.appendChild(descriptionDiv);
+        container.appendChild(nameDiv);
+
+        const installButtonDiv = document.createElement('button');
+        installButtonDiv.className = 'row-span-2 my-2 hf-app-install-button';
+
+        if (isInstalled) {
+            installButtonDiv.classList.add('bg-gray-400', 'cursor-not-allowed');
+            installButtonDiv.textContent = 'Installed';
+            installButtonDiv.disabled = true;
+        } else {
+            installButtonDiv.classList.add('border', 'border-red-600');
+            installButtonDiv.textContent = 'Install';
+            installButtonDiv.onclick = async () => {
+                hfAppsStore.installApp(app);
+            };
+        }
+
+        container.appendChild(installButtonDiv);
+
+        return container;
+    },
+
+    appInstallLogHandler: async (appName, jobId) => {
+        const installModal = document.getElementById('install-modal');
+        const modalTitle = installModal.querySelector('#modal-title');
+        modalTitle.textContent = `Installing ${appName}...`;
+        installModal.classList.remove('hidden');
+
+        const logsDiv = document.getElementById('install-logs');
+        logsDiv.textContent = '';
+
+        const closeButton = document.getElementById('modal-close-button');
+        closeButton.onclick = () => {
+            installModal.classList.add('hidden');
+        };
+        closeButton.classList = "hidden";
+        closeButton.textContent = '';
+
+        const ws = new WebSocket(`ws://${location.host}/api/apps/ws/apps-manager/${jobId}`);
+        ws.onmessage = (event) => {
+            try {
+                if (event.data.startsWith('{') && event.data.endsWith('}')) {
+                    const data = JSON.parse(event.data);
+
+                    if (data.status === "failed") {
+                        closeButton.classList = "text-white bg-red-700 hover:bg-red-800 focus:ring-4 focus:outline-none focus:ring-red-300 font-medium rounded-lg text-sm px-5 py-2.5 text-center dark:bg-red-600 dark:hover:bg-red-700 dark:focus:ring-red-800";
+                        closeButton.textContent = 'Close';
+                        console.error(`Installation of ${appName} failed.`);
+                    } else if (data.status === "done") {
+                        closeButton.classList = "text-white bg-green-700 hover:bg-green-800 focus:ring-4 focus:outline-none focus:ring-green-300 font-medium rounded-lg text-sm px-5 py-2.5 text-center dark:bg-green-600 dark:hover:bg-green-700 dark:focus:ring-green-800";
+                        closeButton.textContent = 'Install done';
+                        console.log(`Installation of ${appName} completed.`);
+
+                    }
+                }
+                else {
+                    logsDiv.innerHTML += event.data + '\n';
+                    logsDiv.scrollTop = logsDiv.scrollHeight;
+                }
+
+
+            } catch {
+                logsDiv.innerHTML += event.data + '\n';
+                logsDiv.scrollTop = logsDiv.scrollHeight;
+            }
+        };
+        ws.onclose = async () => {
+            hfAppsStore.isInstalling = false;
+            hfAppsStore.refreshAppList();
+            installedApps.refreshAppList();
+        };
+    },
+};
+
+
+window.addEventListener('load', async () => {
+    // Attach change listener to community toggle if present
+    const communityToggle = document.getElementById('hf-show-community');
+    if (communityToggle) {
+        communityToggle.addEventListener('change', async () => {
+            await hfAppsStore.refreshAppList();
+        });
+    }
+    await hfAppsStore.refreshAppList();
+});

reachy_mini/daemon/app/dashboard/static/js/daemon.js

@@ -0,0 +1,169 @@
+
+
+
+const daemon = {
+    currentStatus: {
+        state: null,
+    },
+
+    start: async (wakeUp) => {
+        await fetch(`/api/daemon/start?wake_up=${wakeUp}`, {
+            method: 'POST',
+        })
+            .then((response) => {
+                if (!response.ok) {
+                    throw new Error(`HTTP error! status: ${response.status}`);
+                }
+                return response.json();
+            })
+            .then(async (data) => {
+                await daemon.checkStatusUpdate();
+            })
+            .catch((error) => {
+                console.error('Error starting daemon:', error);
+            });
+    },
+
+    stop: async (gotoSleep) => {
+        await fetch(`/api/daemon/stop?goto_sleep=${gotoSleep}`, {
+            method: 'POST',
+        })
+            .then((response) => {
+                if (!response.ok) {
+                    throw new Error(`HTTP error! status: ${response.status}`);
+                }
+                return response.json();
+            })
+            .then(async (data) => {
+                await daemon.checkStatusUpdate();
+            })
+            .catch((error) => {
+                console.error('Error stopping daemon:', error);
+            });
+    },
+
+    getStatus: async () => {
+        await fetch('/api/daemon/status')
+            .then((response) => response.json())
+            .then(async (data) => {
+                let currentState = daemon.currentStatus.state;
+                let newState = data.state || null;
+
+                daemon.currentStatus = data;
+
+                if (currentState === null || currentState !== newState) {
+                    await daemon.updateUI();
+                }
+
+            })
+            .catch((error) => {
+                console.error('Error fetching daemon status:', error);
+            });
+    },
+
+    checkStatusUpdate: async (initialState) => {
+        await daemon.getStatus();
+
+        if (!initialState) {
+            initialState = daemon.currentStatus.state;
+        }
+
+        let currentState = daemon.currentStatus.state;
+
+        if (currentState !== "error" && (currentState === initialState || currentState === "starting" || currentState === "stopping")) {
+            setTimeout(() => {
+                daemon.checkStatusUpdate(initialState);
+            }, 500);
+        }
+    },
+
+    toggleSwitch: async () => {
+        const toggleDaemonSwitch = document.getElementById('daemon-toggle');
+
+        if (toggleDaemonSwitch.checked) {
+            console.log('Toggle switched ON. Starting daemon...');
+            await daemon.start(true);
+        } else {
+            console.log('Toggle switched OFF. Stopping daemon...');
+            await daemon.stop(true);
+        }
+
+        await daemon.updateToggle();
+    },
+
+    updateUI: async () => {
+        const daemonStatusAnim = document.getElementById('daemon-status-anim');
+        const toggleDaemonSwitch = document.getElementById('daemon-toggle');
+        const backendStatusIcon = document.getElementById('backend-status-icon');
+        const backendStatusText = document.getElementById('backend-status-text');
+
+        let daemonState = daemon.currentStatus.state;
+
+        toggleDaemonSwitch.disabled = false;
+        backendStatusIcon.classList.remove('bg-green-500', 'bg-yellow-500', 'bg-red-500');
+
+        if (daemonState === 'starting') {
+            // daemonStatusAnim.setAttribute('data', '/static/assets/reachy-mini-wake-up-animation.svg');
+            daemonStatusAnim.setAttribute('data', '/static/assets/awake-cartoon.svg');
+            toggleDaemonSwitch.disabled = true;
+            toggleDaemonSwitch.checked = true;
+            backendStatusIcon.classList.add('bg-yellow-500');
+            backendStatusText.textContent = 'Waking up...';
+        }
+        else if (daemonState === 'running') {
+            // daemonStatusAnim.setAttribute('data', '/static/assets/reachy-mini-awake.svg');
+            daemonStatusAnim.setAttribute('data', '/static/assets/awake-cartoon-static.svg');
+            toggleDaemonSwitch.checked = true;
+            backendStatusIcon.classList.add('bg-green-500');
+            backendStatusText.textContent = 'Up and ready';
+        }
+        else if (daemonState === 'stopping') {
+            // daemonStatusAnim.setAttribute('data', '/static/assets/reachy-mini-go-to-sleep-animation.svg');
+            daemonStatusAnim.setAttribute('data', '/static/assets/go-to-sleep-cartoon.svg');
+            toggleDaemonSwitch.disabled = true;
+            toggleDaemonSwitch.checked = false;
+            backendStatusIcon.classList.add('bg-yellow-500');
+            backendStatusText.textContent = 'Going to sleep...';
+        }
+        else if (daemonState === 'stopped' || daemonState === 'not_initialized') {
+            // daemonStatusAnim.setAttribute('data', '/static/assets/reachy-mini-sleeping.svg');
+            daemonStatusAnim.setAttribute('data', '/static/assets/reachy-mini-sleeping-static.svg');
+            toggleDaemonSwitch.checked = false;
+            backendStatusIcon.classList.add('bg-yellow-500');
+            backendStatusText.textContent = 'Stopped';
+        }
+        else if (daemonState === 'error') {
+            daemonStatusAnim.setAttribute('data', '/static/assets/no-wifi-cartoon.svg');
+            toggleDaemonSwitch.checked = false;
+            backendStatusIcon.classList.add('bg-red-500');
+            backendStatusText.textContent = 'Error occurred';
+
+            notificationCenter.showError(daemon.currentStatus.error);
+        }
+
+        await daemon.updateToggle();
+    },
+
+    updateToggle: async () => {
+        const toggle = document.getElementById('daemon-toggle');
+        const toggleSlider = document.getElementById('daemon-toggle-slider');
+        const toggleOnLabel = document.getElementById('daemon-toggle-on');
+        const toggleOffLabel = document.getElementById('daemon-toggle-off');
+
+        toggleSlider.classList.remove('hidden');
+
+        if (toggle.checked) {
+            toggleOnLabel.classList.remove('hidden');
+            toggleOffLabel.classList.add('hidden');
+        } else {
+            toggleOnLabel.classList.add('hidden');
+            toggleOffLabel.classList.remove('hidden');
+        }
+    },
+};
+
+
+window.addEventListener('load', async () => {
+    document.getElementById('daemon-toggle').onchange = daemon.toggleSwitch;
+    await daemon.getStatus();
+});

reachy_mini/daemon/app/dashboard/static/js/health_check.js

@@ -0,0 +1,9 @@
+window.addEventListener("load", () => {
+    const healthCheckInterval = setInterval(async () => {
+        const response = await fetch("/health-check", { method: "POST" });
+        if (!response.ok) {
+            console.error("Health check failed");
+            clearInterval(healthCheckInterval);
+        }
+    }, 2500);
+});

reachy_mini/daemon/app/dashboard/static/js/move_player.js

@@ -0,0 +1,132 @@
+const updateMoveItems = async (dataset) => {
+    fetch(`/api/move/recorded-move-datasets/list/${dataset}`)
+        .then(response => response.json())
+        .then(data => {
+            // Update the UI with the list of recorded moves
+            const moveSelectToggle = document.getElementById('move-select-toggle');
+            moveSelectToggle.innerHTML = '';
+
+            data.forEach(moveName => {
+                const option = document.createElement('option');
+                option.value = moveName;
+                option.textContent = moveName;
+                moveSelectToggle.appendChild(option);
+            });
+
+        })
+        .catch(error => {
+            console.error(`Error fetching recorded moves for dataset '${dataset}':`, error);
+        });
+};
+
+const movePlayer = {
+    playing: false,
+    currentMove: null,
+
+    playRecordedMove: async (dataset, move) => {
+        console.log(`Requesting play move '${move}' from dataset '${dataset}'`);
+
+        // movePlayer.playing = true;
+        // movePlayer.updateUI();
+
+        await fetch(`/api/move/play/recorded-move-dataset/${dataset}/${move}`, {
+            method: 'POST'
+        }).then(response => {
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            return response.json();
+        }
+        ).then(data => {
+            movePlayer.currentMove = data.uuid;
+        }).catch(error => {
+            console.error(`Error playing move '${move}' from dataset '${dataset}':`, error);
+            // movePlayer.playing = false;
+            // movePlayer.currentMove = null;
+            // movePlayer.updateUI();
+        });
+    },
+
+    stopMove: async () => {
+        console.log(`Requesting stop of current move`);
+
+        await fetch(`/api/move/stop`, {
+            method: 'POST',
+            body: JSON.stringify({ uuid: movePlayer.currentMove }),
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        });
+    },
+
+    updateUI: () => {
+        const movePlayBtn = document.getElementById('move-play-btn');
+        const moveStopBtn = document.getElementById('move-stop-btn');
+
+        if (movePlayer.playing) {
+            movePlayBtn.disabled = true;
+            moveStopBtn.disabled = false;
+        } else {
+            movePlayBtn.disabled = false;
+            moveStopBtn.disabled = true;
+        }
+    },
+
+    checkMoveStatus: async () => {
+        let ws = new WebSocket(`ws://${window.location.host}/api/move/ws/updates`);
+
+        ws.onmessage = (event) => {
+            const data = JSON.parse(event.data);
+            if (data.type === 'move_started') {
+                movePlayer.playing = true;
+                movePlayer.currentMove = data.move_id;
+            }
+            else if (data.type === 'move_completed') {
+                movePlayer.playing = false;
+                movePlayer.currentMove = null;
+            }
+            else if (data.type === 'move_failed' || data.type === 'move_cancelled') {
+                movePlayer.playing = false;
+                movePlayer.currentMove = null;
+            }
+
+            movePlayer.updateUI();
+        };
+
+        ws.onclose = () => {
+            console.log('Move status WebSocket closed, reconnecting in 1 second...');
+            setTimeout(() => {
+                movePlayer.checkMoveStatus();
+            }, 1000);
+        };
+    }
+};
+
+window.addEventListener('DOMContentLoaded', (event) => {
+    const moveDatasetToggle = document.getElementById('move-dataset-toggle');
+
+    moveDatasetToggle.addEventListener('change', (_) => {
+        const selectedDataset = moveDatasetToggle.value;
+        updateMoveItems(selectedDataset);
+    });
+
+    const movePlayBtn = document.getElementById('move-play-btn');
+    movePlayBtn.addEventListener('click', async () => {
+        const selectedDataset = moveDatasetToggle.value;
+        const moveSelectToggle = document.getElementById('move-select-toggle');
+        const selectedMove = moveSelectToggle.value;
+
+        await movePlayer.playRecordedMove(selectedDataset, selectedMove);
+    });
+
+    const moveStopBtn = document.getElementById('move-stop-btn');
+    moveStopBtn.addEventListener('click', async () => {
+        await movePlayer.stopMove();
+    });
+
+    // Initialize move items on page load
+    updateMoveItems(moveDatasetToggle.value);
+
+    movePlayer.checkMoveStatus();
+    movePlayer.updateUI();
+});

reachy_mini/daemon/app/dashboard/static/js/notification.js

@@ -0,0 +1,41 @@
+const notificationCenter = {
+
+    showInfo: (message, duration = 5000, autoclose = true) => {
+        notificationCenter.showNotification(message, false, duration, autoclose);
+    },
+    showError: (message, duration = 5000, autoclose = false) => {
+        message = notificationCenter.errorTranslation(message);
+        notificationCenter.showNotification(message, true, duration, autoclose);
+    },
+
+    showNotification: (message, error, duration = 5000, autoclose = true) => {
+        document.getElementById('notification-message').textContent = message;
+        document.getElementById('notification-modal').style.display = 'block';
+
+        if (error) {
+            document.getElementById('notification-content').classList.add('error');
+            document.getElementById('notification-content').classList.remove('info');
+        } else {
+            document.getElementById('notification-content').classList.remove('error');
+            document.getElementById('notification-content').classList.add('info');
+        }
+
+        if (autoclose) {
+            setTimeout(notificationCenter.closeNotification, duration);
+        }
+    },
+
+    closeNotification: () => {
+        document.getElementById('notification-modal').style.display = 'none';
+    },
+
+    errorTranslation: (errorMessage) => {
+        if (errorMessage.includes('No Reachy Mini serial port found.')) {
+            return 'Reachy Mini not detected on USB. Please check that the USB cable is properly connected.';
+        }
+
+        console.log('No translation found for error message:', errorMessage);
+        return errorMessage;
+    },
+
+};

reachy_mini/daemon/app/dashboard/static/js/update.js

@@ -0,0 +1,132 @@
+const updateManager = {
+    busy: false,
+    preRelease: false,
+
+    checkForUpdate: async () => {
+        await updateManager.updateUI();  // Clear previous state
+
+        await fetch('/update/available?pre_release=' + updateManager.preRelease)
+            .then(async response => {
+                if (!response.ok) {
+                    return false;
+                }
+                const data = await response.json();
+                await updateManager.updateUI(data);
+            }).catch(error => {
+                console.error('Error checking for updates:', error);
+            });
+    },
+
+    startUpdate: async () => {
+        if (updateManager.busy) {
+            console.warn('An update is already in progress.');
+            return;
+        }
+        updateManager.busy = true;
+
+        fetch('/update/start?pre_release=' + updateManager.preRelease, { method: 'POST' })
+            .then(response => {
+                if (response.ok) {
+                    return response.json();
+                } else {
+                    return response.json().then(data => {
+                        throw new Error(data.detail || 'Error starting update');
+                    });
+                }
+            })
+            .then(data => {
+                const jobId = data.job_id;
+                updateManager.connectLogsWebSocket(jobId);
+            })
+            .catch(error => {
+                console.error('Error triggering update:', error);
+                updateManager.busy = false;
+            });
+    },
+
+    connectLogsWebSocket: (jobId) => {
+        const updateModal = document.getElementById('update-modal');
+        const updateModalTitle = document.getElementById('update-modal-title');
+        const logsDiv = document.getElementById('update-logs');
+        const closeButton = document.getElementById('update-modal-close-button');
+
+        updateModalTitle.textContent = 'Updating...';
+
+        closeButton.onclick = () => {
+            updateModal.classList.add('hidden');
+        };
+
+        updateModal.classList.remove('hidden');
+
+        const ws = new WebSocket(`ws://${location.host}/update/ws/logs?job_id=${jobId}`);
+
+        ws.onmessage = (event) => {
+            // console.log('Update log:', event);
+            logsDiv.innerHTML += event.data + '<br>';
+            logsDiv.scrollTop = logsDiv.scrollHeight;
+        };
+        ws.onclose = async () => {
+            console.log('Update logs WebSocket closed');
+            closeButton.classList.remove('hidden');
+            closeButton.textContent = 'Close';
+            updateModalTitle.textContent = 'Update Completed ✅';
+
+            updateManager.busy = false;
+            await updateManager.checkForUpdate();
+        };
+    },
+
+    updateUI: async (update) => {
+        // updateManager.updateMainPage(isUpdateAvailable);
+        updateManager.updateUpdatePage(update);
+    },
+
+    // updateMainPage: async (update) => {
+    //     const daemonUpdateBtn = document.getElementById('daemon-update-btn');
+    //     if (!daemonUpdateBtn) return;
+
+    //     if (isUpdateAvailable) {
+    //         daemonUpdateBtn.innerHTML = 'Update <span class="rounded-full bg-blue-700 text-white text-xs font-semibold px-2 py-1 ml-2">1</span>';
+    //     } else {
+    //         daemonUpdateBtn.innerHTML = 'Update';
+    //     }
+    // },
+    updateUpdatePage: async (data) => {
+        const statusElem = document.getElementById('update-status');
+        if (!statusElem) return;
+
+        const currentVersionElem = document.getElementById('current-version');
+        const availableVersionElem = document.getElementById('available-version');
+        const availableVersionContainer = document.getElementById('available-version-container');
+        const startUpdateBtn = document.getElementById('start-update-btn');
+
+        if (!data || !data.update || !data.update.reachy_mini) {
+            statusElem.innerHTML = 'Checking for updates...';
+            if (currentVersionElem) currentVersionElem.textContent = '';
+            if (availableVersionElem) availableVersionElem.textContent = '';
+            return;
+        }
+
+        const updateInfo = data.update.reachy_mini;
+        const isUpdateAvailable = updateInfo.is_available;
+        const currentVersion = updateInfo.current_version || '-';
+        const availableVersion = updateInfo.available_version || '-';
+
+        if (currentVersionElem) currentVersionElem.textContent = `Current version: ${currentVersion}`;
+        if (availableVersionElem) availableVersionElem.textContent = `Available version: ${availableVersion}`;
+
+        if (isUpdateAvailable) {
+            statusElem.innerHTML = 'An update is available!';
+            if (availableVersionContainer) availableVersionContainer.classList.remove('hidden');
+            startUpdateBtn.classList.remove('hidden');
+        } else {
+            statusElem.innerHTML = 'Your system is up to date.';
+            if (availableVersionContainer) availableVersionContainer.classList.add('hidden');
+            startUpdateBtn.classList.add('hidden');
+        }
+    }
+};
+
+window.addEventListener('load', async () => {
+    await updateManager.checkForUpdate();
+});