citrascope 0.3.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

citrascope/web/static/app.js

@@ -1,6 +1,6 @@
 // CitraScope Dashboard - Main Application
 import { connectWebSocket } from './websocket.js';
-import { initConfig, currentConfig } from './config.js';
+import { initConfig, currentConfig, initFilterConfig, setupAutofocusButton } from './config.js';
 import { getTasks, getLogs } from './api.js';
 
 function updateAppUrlLinks() {
@@ -13,7 +13,154 @@ function updateAppUrlLinks() {
     });
 }
 
-// Global state for countdown
+// --- Version Checking ---
+
+/**
+ * Compare two semantic version strings
+ * Returns: 1 if v1 > v2, -1 if v1 < v2, 0 if equal
+ */
+function compareVersions(v1, v2) {
+    // Strip 'v' prefix if present
+    v1 = v1.replace(/^v/, '');
+    v2 = v2.replace(/^v/, '');
+
+    const parts1 = v1.split('.').map(n => parseInt(n) || 0);
+    const parts2 = v2.split('.').map(n => parseInt(n) || 0);
+
+    const maxLen = Math.max(parts1.length, parts2.length);
+
+    for (let i = 0; i < maxLen; i++) {
+        const num1 = parts1[i] || 0;
+        const num2 = parts2[i] || 0;
+
+        if (num1 > num2) return 1;
+        if (num1 < num2) return -1;
+    }
+
+    return 0;
+}
+
+/**
+ * Fetch and display current version
+ */
+async function fetchVersion() {
+    try {
+        const response = await fetch('/api/version');
+        const data = await response.json();
+
+        // Update header version
+        const headerVersionEl = document.getElementById('headerVersion');
+
+        if (headerVersionEl && data.version) {
+            // Show "dev" for development, "v" prefix for releases
+            if (data.version === 'development') {
+                headerVersionEl.textContent = 'dev';
+            } else {
+                headerVersionEl.textContent = 'v' + data.version;
+            }
+        }
+    } catch (error) {
+        console.error('Error fetching version:', error);
+        const headerVersionEl = document.getElementById('headerVersion');
+
+        if (headerVersionEl) {
+            headerVersionEl.textContent = 'v?';
+        }
+    }
+}
+
+/**
+ * Check for available updates from GitHub
+ * Returns the check result for modal display
+ */
+async function checkForUpdates() {
+    try {
+        // Get current version
+        const versionResponse = await fetch('/api/version');
+        const versionData = await versionResponse.json();
+        const currentVersion = versionData.version;
+
+        // Check GitHub for latest release
+        const githubResponse = await fetch('https://api.github.com/repos/citra-space/citrascope/releases/latest');
+        if (!githubResponse.ok) {
+            return { status: 'error', currentVersion };
+        }
+
+        const releaseData = await githubResponse.json();
+        const latestVersion = releaseData.tag_name.replace(/^v/, '');
+        const releaseUrl = releaseData.html_url;
+
+        // Skip comparison for development versions
+        if (currentVersion === 'development' || currentVersion === 'unknown') {
+            return { status: 'up-to-date', currentVersion };
+        }
+
+        // Compare versions
+        if (compareVersions(latestVersion, currentVersion) > 0) {
+            // Update available - show indicator badge with version
+            const indicator = document.getElementById('updateIndicator');
+            if (indicator) {
+                indicator.textContent = `${latestVersion} Available!`;
+                indicator.style.display = 'inline-block';
+            }
+
+            return {
+                status: 'update-available',
+                currentVersion,
+                latestVersion,
+                releaseUrl
+            };
+        } else {
+            // Up to date - hide indicator badge
+            const indicator = document.getElementById('updateIndicator');
+            if (indicator) {
+                indicator.style.display = 'none';
+            }
+
+            return { status: 'up-to-date', currentVersion };
+        }
+    } catch (error) {
+        // Network error
+        console.debug('Update check failed:', error);
+        return { status: 'error', currentVersion: 'unknown' };
+    }
+}
+
+/**
+ * Show version check modal with results
+ */
+async function showVersionModal() {
+    const modal = new bootstrap.Modal(document.getElementById('versionModal'));
+    modal.show();
+
+    // Show loading state
+    document.getElementById('versionCheckLoading').style.display = 'block';
+    document.getElementById('versionCheckUpToDate').style.display = 'none';
+    document.getElementById('versionCheckUpdateAvailable').style.display = 'none';
+    document.getElementById('versionCheckError').style.display = 'none';
+
+    // Perform check
+    const result = await checkForUpdates();
+
+    // Hide loading
+    document.getElementById('versionCheckLoading').style.display = 'none';
+
+    // Show appropriate result
+    if (result.status === 'update-available') {
+        document.getElementById('modalCurrentVersion').textContent = 'v' + result.currentVersion;
+        document.getElementById('modalLatestVersion').textContent = 'v' + result.latestVersion;
+        document.getElementById('releaseNotesLink').href = result.releaseUrl;
+        document.getElementById('versionCheckUpdateAvailable').style.display = 'block';
+    } else if (result.status === 'up-to-date') {
+        document.getElementById('modalCurrentVersionUpToDate').textContent = result.currentVersion === 'development' ? 'development' : 'v' + result.currentVersion;
+        document.getElementById('versionCheckUpToDate').style.display = 'block';
+    } else {
+        document.getElementById('modalCurrentVersionError').textContent = result.currentVersion === 'development' ? 'development' : result.currentVersion;
+        document.getElementById('versionCheckError').style.display = 'block';
+    }
+}
+
+// --- Task Management ---
 let nextTaskStartTime = null;
 let countdownInterval = null;
 let isTaskActive = false;
@@ -139,6 +286,11 @@ function initNavigation() {
                 const section = link.getAttribute('data-section');
                 activateNav(link);
                 showSection(section);
+
+                // Reload filter config when config section is shown
+                if (section === 'config') {
+                    initFilterConfig();
+                }
             }
         });
 
@@ -207,7 +359,9 @@ function updateStatus(status) {
     }
     // If isTaskActive is already false, don't touch the display (countdown is updating it)
 
-    document.getElementById('tasksPending').textContent = status.tasks_pending || '0';
+    if (status.tasks_pending !== undefined) {
+        document.getElementById('tasksPending').textContent = status.tasks_pending || '0';
+    }
 
     if (status.telescope_ra !== null) {
         document.getElementById('telescopeRA').textContent = status.telescope_ra.toFixed(4) + '°';
@@ -217,20 +371,45 @@ function updateStatus(status) {
     }
 
     // Update ground station information
-    const gsNameEl = document.getElementById('groundStationName');
-    const taskScopeButton = document.getElementById('taskScopeButton');
-
-    if (status.ground_station_name && status.ground_station_url) {
-        gsNameEl.innerHTML = `<a href="${status.ground_station_url}" target="_blank" class="ground-station-link">${status.ground_station_name} ↗</a>`;
-        // Update the Task My Scope button
-        taskScopeButton.href = status.ground_station_url;
-        taskScopeButton.style.display = 'inline-block';
-    } else if (status.ground_station_name) {
-        gsNameEl.textContent = status.ground_station_name;
-        taskScopeButton.style.display = 'none';
+    if (status.ground_station_name !== undefined || status.ground_station_url !== undefined) {
+        const gsNameEl = document.getElementById('groundStationName');
+        const taskScopeButton = document.getElementById('taskScopeButton');
+
+        if (status.ground_station_name && status.ground_station_url) {
+            gsNameEl.innerHTML = `<a href="${status.ground_station_url}" target="_blank" class="ground-station-link">${status.ground_station_name} ↗</a>`;
+            // Update the Task My Scope button
+            taskScopeButton.href = status.ground_station_url;
+            taskScopeButton.style.display = 'inline-block';
+        } else if (status.ground_station_name) {
+            gsNameEl.textContent = status.ground_station_name;
+            taskScopeButton.style.display = 'none';
+        } else {
+            gsNameEl.textContent = '-';
+            taskScopeButton.style.display = 'none';
+        }
+    }
+
+    // Update task processing state
+    if (status.processing_active !== undefined) {
+        updateProcessingState(status.processing_active);
+    }
+}
+
+function updateProcessingState(isActive) {
+    const statusEl = document.getElementById('processingStatus');
+    const button = document.getElementById('toggleProcessingButton');
+    const icon = document.getElementById('processingButtonIcon');
+
+    if (!statusEl || !button || !icon) return;
+
+    if (isActive) {
+        statusEl.innerHTML = '<span class="badge rounded-pill bg-success">Active</span>';
+        icon.textContent = 'Pause';
+        button.title = 'Pause task processing';
     } else {
-        gsNameEl.textContent = '-';
-        taskScopeButton.style.display = 'none';
+        statusEl.innerHTML = '<span class="badge rounded-pill bg-warning">Paused</span>';
+        icon.textContent = 'Resume';
+        button.title = 'Resume task processing';
     }
 }
 
@@ -412,12 +591,14 @@ function updateLatestLogLine() {
 
         const timestamp = new Date(latestLog.timestamp).toLocaleTimeString();
         const cleanMessage = stripAnsiCodes(latestLog.message);
+        // Truncate message to ~150 chars for collapsed header (approx 2 lines)
+        const truncatedMessage = cleanMessage.length > 150 ? cleanMessage.substring(0, 150) + '...' : cleanMessage;
 
         content.querySelector('.log-timestamp').textContent = timestamp;
         const levelSpan = content.querySelector('.log-level');
         levelSpan.classList.add(`log-level-${latestLog.level}`);
         levelSpan.textContent = latestLog.level;
-        content.querySelector('.log-message').textContent = cleanMessage;
+        content.querySelector('.log-message').textContent = truncatedMessage;
 
         latestLogLine.innerHTML = '';
         latestLogLine.appendChild(content);
@@ -483,9 +664,28 @@ document.addEventListener('DOMContentLoaded', async function() {
     // Initialize configuration management (loads config)
     await initConfig();
 
+    // Initialize filter configuration
+    await initFilterConfig();
+
+    // Setup autofocus button (only once)
+    setupAutofocusButton();
+
     // Update app URL links from loaded config
     updateAppUrlLinks();
 
+    // Fetch and display version
+    fetchVersion();
+
+    // Check for updates on load and every hour
+    checkForUpdates();
+    setInterval(checkForUpdates, 3600000); // Check every hour
+
+    // Wire up version click to open modal
+    const headerVersion = document.getElementById('headerVersion');
+    if (headerVersion) {
+        headerVersion.addEventListener('click', showVersionModal);
+    }
+
     // Connect WebSocket with handlers
     connectWebSocket({
         onStatus: updateStatus,
@@ -497,4 +697,33 @@ document.addEventListener('DOMContentLoaded', async function() {
     // Load initial data
     loadTasks();
     loadLogs();
+
+    // Add pause/resume button handler
+    const toggleButton = document.getElementById('toggleProcessingButton');
+    if (toggleButton) {
+        toggleButton.addEventListener('click', async () => {
+            const icon = document.getElementById('processingButtonIcon');
+            const currentlyPaused = icon && icon.textContent === 'Resume';
+            const endpoint = currentlyPaused ? '/api/tasks/resume' : '/api/tasks/pause';
+
+            try {
+                toggleButton.disabled = true;
+                const response = await fetch(endpoint, { method: 'POST' });
+                const result = await response.json();
+
+                if (!response.ok) {
+                    console.error('Failed to toggle processing:', result);
+                    // Show specific error message (e.g., "Cannot resume during autofocus")
+                    alert((result.error || 'Failed to toggle task processing') +
+                          (response.status === 409 ? '' : ' - Unknown error'));
+                }
+                // State will be updated via WebSocket broadcast within 2 seconds
+            } catch (error) {
+                console.error('Error toggling processing:', error);
+                alert('Error toggling task processing');
+            } finally {
+                toggleButton.disabled = false;
+            }
+        });
+    }
 });

citrascope/web/static/config.js

@@ -2,12 +2,14 @@
 
 import { getConfig, saveConfig, getConfigStatus, getHardwareAdapters, getAdapterSchema } from './api.js';
 
+// API Host constants - must match backend constants in app.py
+const PROD_API_HOST = 'api.citra.space';
+const DEV_API_HOST = 'dev.api.citra.space';
+const DEFAULT_API_PORT = 443;
+
 let currentAdapterSchema = [];
 export let currentConfig = {};
 
-/**
- * Initialize configuration management
- */
 export async function initConfig() {
     // Populate hardware adapter dropdown
     await loadAdapterOptions();
@@ -25,6 +27,19 @@ export async function initConfig() {
         });
     }
 
+    // API endpoint selection change
+    const apiEndpointSelect = document.getElementById('apiEndpoint');
+    if (apiEndpointSelect) {
+        apiEndpointSelect.addEventListener('change', function(e) {
+            const customContainer = document.getElementById('customHostContainer');
+            if (e.target.value === 'custom') {
+                customContainer.style.display = 'block';
+            } else {
+                customContainer.style.display = 'none';
+            }
+        });
+    }
+
     // Config form submission
     const configForm = document.getElementById('configForm');
     if (configForm) {
@@ -114,6 +129,27 @@ async function loadConfiguration() {
             imagesDirElement.textContent = config.images_dir_path;
         }
 
+        // API endpoint selector
+        const apiEndpointSelect = document.getElementById('apiEndpoint');
+        const customHostContainer = document.getElementById('customHostContainer');
+        const customHost = document.getElementById('customHost');
+        const customPort = document.getElementById('customPort');
+        const customUseSsl = document.getElementById('customUseSsl');
+
+        if (config.host === PROD_API_HOST) {
+            apiEndpointSelect.value = 'production';
+            customHostContainer.style.display = 'none';
+        } else if (config.host === DEV_API_HOST) {
+            apiEndpointSelect.value = 'development';
+            customHostContainer.style.display = 'none';
+        } else {
+            apiEndpointSelect.value = 'custom';
+            customHostContainer.style.display = 'block';
+            customHost.value = config.host || '';
+            customPort.value = config.port || DEFAULT_API_PORT;
+            customUseSsl.checked = config.use_ssl !== undefined ? config.use_ssl : true;
+        }
+
         // Core fields
         document.getElementById('personal_access_token').value = config.personal_access_token || '';
         document.getElementById('telescopeId').value = config.telescope_id || '';
@@ -274,6 +310,24 @@ async function saveConfiguration(event) {
     // Hide previous messages
     hideConfigMessages();
 
+    // Determine API host settings based on endpoint selection
+    const apiEndpoint = document.getElementById('apiEndpoint').value;
+    let host, port, use_ssl;
+
+    if (apiEndpoint === 'production') {
+        host = PROD_API_HOST;
+        port = DEFAULT_API_PORT;
+        use_ssl = true;
+    } else if (apiEndpoint === 'development') {
+        host = DEV_API_HOST;
+        port = DEFAULT_API_PORT;
+        use_ssl = true;
+    } else { // custom
+        host = document.getElementById('customHost').value;
+        port = parseInt(document.getElementById('customPort').value, 10);
+        use_ssl = document.getElementById('customUseSsl').checked;
+    }
+
     const config = {
         personal_access_token: document.getElementById('personal_access_token').value,
         telescope_id: document.getElementById('telescopeId').value,
@@ -282,10 +336,11 @@ async function saveConfiguration(event) {
         log_level: document.getElementById('logLevel').value,
         keep_images: document.getElementById('keep_images').checked,
         file_logging_enabled: document.getElementById('file_logging_enabled').checked,
-        // Preserve API settings from loaded config
-        host: currentConfig.host || 'api.citra.space',
-        port: currentConfig.port || 443,
-        use_ssl: currentConfig.use_ssl !== undefined ? currentConfig.use_ssl : true,
+        // API settings from endpoint selector
+        host: host,
+        port: port,
+        use_ssl: use_ssl,
+        // Preserve other settings from loaded config
         max_task_retries: currentConfig.max_task_retries || 3,
         initial_retry_delay_seconds: currentConfig.initial_retry_delay_seconds || 30,
         max_retry_delay_seconds: currentConfig.max_retry_delay_seconds || 300,
@@ -296,9 +351,23 @@ async function saveConfiguration(event) {
         const result = await saveConfig(config);
 
         if (result.ok) {
-            showConfigSuccess(result.data.message || 'Configuration saved and applied successfully!');
+            // After config saved successfully, save any modified filter focus positions
+            const filterResults = await saveModifiedFilters();
+
+            // Build success message based on results
+            let message = result.data.message || 'Configuration saved and applied successfully!';
+            if (filterResults.success > 0) {
+                message += ` Updated ${filterResults.success} filter focus position${filterResults.success > 1 ? 's' : ''}.`;
+            }
+            if (filterResults.failed > 0) {
+                message += ` Warning: ${filterResults.failed} filter update${filterResults.failed > 1 ? 's' : ''} failed.`;
+            }
+
+            showConfigSuccess(message);
         } else {
-            showConfigError(result.data.error || result.data.message || 'Failed to save configuration');
+            // Check for specific error codes
+            const errorMsg = result.data.error || result.data.message || 'Failed to save configuration';
+            showConfigError(errorMsg);
         }
     } catch (error) {
         showConfigError('Failed to save configuration: ' + error.message);
@@ -358,5 +427,175 @@ export function showConfigSection() {
     }
 }
 
+/**
+ * Load and display filter configuration
+ */
+async function loadFilterConfig() {
+    const filterSection = document.getElementById('filterConfigSection');
+
+    try {
+        const response = await fetch('/api/adapter/filters');
+
+        if (response.status === 404 || response.status === 503) {
+            // Adapter doesn't support filters or isn't available
+            if (filterSection) filterSection.style.display = 'none';
+            return;
+        }
+
+        const data = await response.json();
+
+        if (response.ok && data.filters) {
+            // Show the filter section
+            if (filterSection) filterSection.style.display = 'block';
+
+            // Populate filter table
+            const tbody = document.getElementById('filterTableBody');
+            const noFiltersMsg = document.getElementById('noFiltersMessage');
+
+            if (tbody) {
+                tbody.innerHTML = '';
+                const filters = data.filters;
+                const filterIds = Object.keys(filters).sort();
+
+                if (filterIds.length === 0) {
+                    if (noFiltersMsg) noFiltersMsg.style.display = 'block';
+                } else {
+                    if (noFiltersMsg) noFiltersMsg.style.display = 'none';
+
+                    filterIds.forEach(filterId => {
+                        const filter = filters[filterId];
+                        const row = document.createElement('tr');
+                        row.innerHTML = `
+                            <td>${filterId}</td>
+                            <td>${filter.name}</td>
+                            <td>
+                                <input type="number"
+                                       class="form-control form-control-sm filter-focus-input"
+                                       data-filter-id="${filterId}"
+                                       value="${filter.focus_position}"
+                                       min="0"
+                                       step="1">
+                            </td>
+                        `;
+                        tbody.appendChild(row);
+                    });
+                }
+            }
+        } else {
+            if (filterSection) filterSection.style.display = 'none';
+        }
+    } catch (error) {
+        console.error('Error loading filter config:', error);
+        if (filterSection) filterSection.style.display = 'none';
+    }
+}
+
+/**
+ * Save all filter focus positions (called during main config save)
+ * Returns: Object with { success: number, failed: number }
+ */
+async function saveModifiedFilters() {
+    const inputs = document.querySelectorAll('.filter-focus-input');
+    if (inputs.length === 0) return { success: 0, failed: 0 }; // No filters to save
+
+    let successCount = 0;
+    let failedCount = 0;
+
+    // Save all filter values
+    for (const input of inputs) {
+        const filterId = input.dataset.filterId;
+        const focusPosition = parseInt(input.value);
+
+        if (isNaN(focusPosition) || focusPosition < 0) {
+            failedCount++;
+            continue;
+        }
+
+        try {
+            const response = await fetch(`/api/adapter/filters/${filterId}`, {
+                method: 'PATCH',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({ focus_position: focusPosition })
+            });
+
+            if (response.ok) {
+                successCount++;
+            } else {
+                failedCount++;
+                console.error(`Failed to save filter ${filterId}: HTTP ${response.status}`);
+            }
+        } catch (error) {
+            failedCount++;
+            console.error(`Error saving filter ${filterId}:`, error);
+        }
+    }
+
+    return { success: successCount, failed: failedCount };
+}
+
+/**
+ * Trigger autofocus routine
+ */
+async function triggerAutofocus() {
+    const button = document.getElementById('runAutofocusButton');
+    const buttonText = document.getElementById('autofocusButtonText');
+    const buttonSpinner = document.getElementById('autofocusButtonSpinner');
+
+    if (!button || !buttonText || !buttonSpinner) return;
+
+    // Clear any previous messages
+    hideConfigMessages();
+
+    // Disable button and show spinner
+    button.disabled = true;
+    buttonText.textContent = 'Running Autofocus...';
+    buttonSpinner.style.display = 'inline-block';
+
+    try {
+        const response = await fetch('/api/adapter/autofocus', {
+            method: 'POST'
+        });
+
+        const data = await response.json();
+
+        if (response.ok) {
+            showConfigSuccess('Autofocus completed successfully');
+            // Reload filter config to show updated focus positions
+            await loadFilterConfig();
+        } else {
+            // Show clear error message (e.g., if autofocus already running or other conflict)
+            showConfigError(data.error || 'Autofocus failed');
+        }
+    } catch (error) {
+        console.error('Error triggering autofocus:', error);
+        showConfigError('Failed to trigger autofocus');
+    } finally {
+        // Re-enable button
+        button.disabled = false;
+        buttonText.textContent = 'Run Autofocus';
+        buttonSpinner.style.display = 'none';
+    }
+}
+
+/**
+ * Initialize filter configuration on page load
+ */
+export async function initFilterConfig() {
+    // Load filter config when config section is visible
+    await loadFilterConfig();
+}
+
+/**
+ * Setup autofocus button event listener (call once during init)
+ */
+export function setupAutofocusButton() {
+    const autofocusBtn = document.getElementById('runAutofocusButton');
+    if (autofocusBtn) {
+        autofocusBtn.addEventListener('click', triggerAutofocus);
+    }
+}
+
 // Make showConfigSection available globally for onclick handlers in HTML
 window.showConfigSection = showConfigSection;

citrascope/web/static/style.css

@@ -57,6 +57,29 @@ body {
 /* Log accordion customization */
 .log-accordion-button {
     border-bottom: 1px solid #444 !important;
+    position: relative;
+}
+
+.accordion-social-links {
+    position: absolute;
+    right: 50px; /* Position to the left of the accordion arrow */
+    top: 50%;
+    transform: translateY(-50%);
+    display: flex;
+    gap: 12px;
+    align-items: center;
+}
+
+.social-link {
+    color: #a0aec0;
+    transition: color 0.2s ease;
+    display: flex;
+    align-items: center;
+    text-decoration: none;
+}
+
+.social-link:hover {
+    color: #e2e8f0;
 }
 
 .log-accordion-body {
@@ -72,6 +95,15 @@ body {
 .log-latest-line {
     font-family: monospace;
     color: #e2e8f0;
+    display: block;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    display: -webkit-box;
+    -webkit-line-clamp: 2;
+    -webkit-box-orient: vertical;
+    line-height: 1.4em;
+    max-height: 2.8em;
+    padding-right: 130px; /* Make room for 3 social icons and accordion arrow */
 }
 
 /* Task display */