commons-proxy 2.0.0

package/public/js/utils/model-config.js

@@ -0,0 +1,42 @@
+/**
+ * Model Configuration Utilities
+ * Shared functions for model configuration updates
+ */
+window.ModelConfigUtils = window.ModelConfigUtils || {};
+
+/**
+ * Update model configuration with authentication and optimistic updates
+ * @param {string} modelId - The model ID to update
+ * @param {object} configUpdates - Configuration updates (pinned, hidden, alias, mapping)
+ * @returns {Promise<void>}
+ */
+window.ModelConfigUtils.updateModelConfig = async function(modelId, configUpdates) {
+    return window.ErrorHandler.safeAsync(async () => {
+        const store = Alpine.store('global');
+
+        const { response, newPassword } = await window.utils.request('/api/models/config', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ modelId, config: configUpdates })
+        }, store.webuiPassword);
+
+        // Update password if server provided a new one
+        if (newPassword) {
+            store.webuiPassword = newPassword;
+        }
+
+        if (!response.ok) {
+            throw new Error(store.t('failedToUpdateModelConfig'));
+        }
+
+        // Optimistic update of local state
+        const dataStore = Alpine.store('data');
+        dataStore.modelConfig[modelId] = {
+            ...dataStore.modelConfig[modelId],
+            ...configUpdates
+        };
+
+        // Recompute quota rows to reflect changes
+        dataStore.computeQuotaRows();
+    }, Alpine.store('global').t('failedToUpdateModelConfig'));
+};

package/public/js/utils/ui-logger.js

@@ -0,0 +1,143 @@
+/**
+ * UI Logger Utility
+ * Provides conditional logging for the web UI to reduce console spam in production.
+ * Wraps console methods and only outputs when debug mode is enabled.
+ *
+ * Usage:
+ *   window.UILogger.debug('message')  - Only logs if debug mode enabled
+ *   window.UILogger.info('message')   - Only logs if debug mode enabled
+ *   window.UILogger.warn('message')   - Always logs (important warnings)
+ *   window.UILogger.error('message')  - Always logs (errors should always be visible)
+ *
+ * Enable debug mode:
+ *   - Set localStorage.setItem('ag_debug', 'true') in browser console
+ *   - Or pass ?debug=true in URL
+ */
+
+(function() {
+    'use strict';
+
+    // Check if debug mode is enabled
+    function isDebugEnabled() {
+        // Check URL parameter
+        const urlParams = new URLSearchParams(window.location.search);
+        if (urlParams.get('debug') === 'true') {
+            return true;
+        }
+
+        // Check localStorage
+        try {
+            return localStorage.getItem('ag_debug') === 'true';
+        } catch (e) {
+            return false;
+        }
+    }
+
+    // Cache debug state (can be refreshed)
+    let debugEnabled = isDebugEnabled();
+
+    window.UILogger = {
+        /**
+         * Refresh debug state (call after changing localStorage)
+         */
+        refresh() {
+            debugEnabled = isDebugEnabled();
+        },
+
+        /**
+         * Enable debug mode
+         */
+        enableDebug() {
+            try {
+                localStorage.setItem('ag_debug', 'true');
+                debugEnabled = true;
+                console.info('[UILogger] Debug mode enabled. Refresh page to see all logs.');
+            } catch (e) {
+                console.warn('[UILogger] Could not save debug preference');
+            }
+        },
+
+        /**
+         * Disable debug mode
+         */
+        disableDebug() {
+            try {
+                localStorage.removeItem('ag_debug');
+                debugEnabled = false;
+                console.info('[UILogger] Debug mode disabled.');
+            } catch (e) {
+                // Ignore
+            }
+        },
+
+        /**
+         * Check if debug mode is enabled
+         * @returns {boolean}
+         */
+        isDebug() {
+            return debugEnabled;
+        },
+
+        /**
+         * Debug level - only logs if debug mode enabled
+         * Use for verbose debugging info (chart updates, cache operations, etc.)
+         */
+        debug(...args) {
+            if (debugEnabled) {
+                console.log('[DEBUG]', ...args);
+            }
+        },
+
+        /**
+         * Info level - only logs if debug mode enabled
+         * Use for informational messages that aren't errors
+         */
+        info(...args) {
+            if (debugEnabled) {
+                console.info('[INFO]', ...args);
+            }
+        },
+
+        /**
+         * Log level - alias for debug
+         */
+        log(...args) {
+            if (debugEnabled) {
+                console.log(...args);
+            }
+        },
+
+        /**
+         * Warn level - always logs
+         * Use for important warnings that users should see
+         * But suppress noisy/expected warnings unless in debug mode
+         */
+        warn(...args) {
+            // In production, only show critical warnings
+            // In debug mode, show all warnings
+            if (debugEnabled) {
+                console.warn(...args);
+            }
+        },
+
+        /**
+         * Warn level that always shows (for critical warnings)
+         */
+        warnAlways(...args) {
+            console.warn(...args);
+        },
+
+        /**
+         * Error level - always logs
+         * Errors should always be visible for debugging
+         */
+        error(...args) {
+            console.error(...args);
+        }
+    };
+
+    // Log initial state (only in debug mode)
+    if (debugEnabled) {
+        console.info('[UILogger] Debug mode is ON. Set localStorage ag_debug=false to disable.');
+    }
+})();

package/public/js/utils/validators.js

@@ -0,0 +1,77 @@
+/**
+ * Input Validation Utilities
+ * Provides validation functions for user inputs
+ */
+window.Validators = window.Validators || {};
+
+/**
+ * Validate a number is within a range
+ * @param {number} value - Value to validate
+ * @param {number} min - Minimum allowed value (inclusive)
+ * @param {number} max - Maximum allowed value (inclusive)
+ * @param {string} fieldName - Name of the field for error messages
+ * @returns {object} { isValid: boolean, value: number, error: string|null }
+ */
+window.Validators.validateRange = function(value, min, max, fieldName = 'Value') {
+    const numValue = Number(value);
+    const t = Alpine.store('global').t;
+
+    if (isNaN(numValue)) {
+        return {
+            isValid: false,
+            value: min,
+            error: t('mustBeValidNumber', { fieldName })
+        };
+    }
+
+    if (numValue < min) {
+        return {
+            isValid: false,
+            value: min,
+            error: t('mustBeAtLeast', { fieldName, min })
+        };
+    }
+
+    if (numValue > max) {
+        return {
+            isValid: false,
+            value: max,
+            error: t('mustBeAtMost', { fieldName, max })
+        };
+    }
+
+    return {
+        isValid: true,
+        value: numValue,
+        error: null
+    };
+};
+
+/**
+ * Validate a timeout/duration value (in milliseconds)
+ * @param {number} value - Timeout value in ms
+ * @param {number} minMs - Minimum allowed timeout (default: from constants)
+ * @param {number} maxMs - Maximum allowed timeout (default: from constants)
+ * @returns {object} { isValid: boolean, value: number, error: string|null }
+ */
+window.Validators.validateTimeout = function(value, minMs = null, maxMs = null) {
+    const { TIMEOUT_MIN, TIMEOUT_MAX } = window.AppConstants.VALIDATION;
+    return window.Validators.validateRange(value, minMs ?? TIMEOUT_MIN, maxMs ?? TIMEOUT_MAX, 'Timeout');
+};
+
+/**
+ * Validate and sanitize input with custom validator
+ * @param {any} value - Value to validate
+ * @param {Function} validator - Validator function
+ * @param {boolean} showError - Whether to show error toast (default: true)
+ * @returns {object} Validation result
+ */
+window.Validators.validate = function(value, validator, showError = true) {
+    const result = validator(value);
+
+    if (!result.isValid && showError && result.error) {
+        window.ErrorHandler.showError(result.error);
+    }
+
+    return result;
+};

package/public/js/utils.js

@@ -0,0 +1,69 @@
+/**
+ * Utility functions for Antigravity Console
+ */
+
+window.utils = {
+    // Shared Request Wrapper
+    async request(url, options = {}, webuiPassword = '') {
+        options.headers = options.headers || {};
+        if (webuiPassword) {
+            options.headers['x-webui-password'] = webuiPassword;
+        }
+
+        let response = await fetch(url, options);
+
+        if (response.status === 401) {
+            const store = Alpine.store('global');
+            const password = prompt(store ? store.t('enterPassword') : 'Enter Web UI Password:');
+            if (password) {
+                // Return new password so caller can update state
+                // This implies we need a way to propagate the new password back
+                // For simplicity in this functional utility, we might need a callback or state access
+                // But generally utils shouldn't probably depend on global state directly if possible
+                // let's stick to the current logic but wrapped
+                localStorage.setItem('commons_webui_password', password);
+                options.headers['x-webui-password'] = password;
+                response = await fetch(url, options);
+                return { response, newPassword: password };
+            }
+        }
+
+        return { response, newPassword: null };
+    },
+
+    formatTimeUntil(isoTime) {
+        const store = Alpine.store('global');
+        const diff = new Date(isoTime) - new Date();
+        if (diff <= 0) return store ? store.t('ready') : 'READY';
+        const mins = Math.floor(diff / 60000);
+        const hrs = Math.floor(mins / 60);
+
+        const hSuffix = store ? store.t('timeH') : 'H';
+        const mSuffix = store ? store.t('timeM') : 'M';
+
+        if (hrs > 0) return `${hrs}${hSuffix} ${mins % 60}${mSuffix}`;
+        return `${mins}${mSuffix}`;
+    },
+
+    getThemeColor(name) {
+        return getComputedStyle(document.documentElement).getPropertyValue(name).trim();
+    },
+
+    /**
+     * Debounce function - delays execution until after specified wait time
+     * @param {Function} func - Function to debounce
+     * @param {number} wait - Wait time in milliseconds
+     * @returns {Function} Debounced function
+     */
+    debounce(func, wait) {
+        let timeout;
+        return function executedFunction(...args) {
+            const later = () => {
+                clearTimeout(timeout);
+                func(...args);
+            };
+            clearTimeout(timeout);
+            timeout = setTimeout(later, wait);
+        };
+    }
+};