Upload 30 files

CHANGELOG.md

@@ -1,13 +1,24 @@
 # Virtual Kimi Changelog
 
-# [1.1.0] - 2025-08-28
+# [1.1.1] - 2025-08-29
 
-### Added
+### Improvements
 
-- **Recommended LLMs**: Updated the list of recommended LLM models to reflect current recommendations and improvements.
+- Improved language and voice selection logic: normalization, fallback, and robust preference management across all modules.
+- Enhanced voice compatibility and ensured consistent language handling.
+
+### Bug Fixes
+
+- Fixed issue where videos could freeze after opening or closing the memory modal or changing memory sections.
+- Added automatic reset to neutral video state after UI interactions to prevent stuck/frozen videos.
+- Fixed import/export functions for preferences and data to ensure exported files can be re-imported correctly.
+
+# [1.1.0] - 2025-08-28
 
 ### Changed
 
+- **Recommended LLMs**: Updated the list of recommended LLM models to reflect current recommendations and improvements.
+
 - **Settings modal UI/UX**: Updated tab layout and visual behavior in the settings modal for clearer navigation and improved usability.
 
 ### Fixed

index.html

@@ -56,8 +56,8 @@
             "name": "Jean & Kimi"
         },
         "dateCreated": "2025-07-16",
-        "dateModified": "2025-08-28",
-        "version": "v1.1.0"
+        "dateModified": "2025-08-29",
+        "version": "v1.1.1"
     }
     </script>
 
@@ -1072,8 +1072,8 @@
                     <h3><i class="fas fa-code"></i> Technical Information</h3>
                     <div class="tech-info">
                         <p><strong>Created date :</strong> July 16, 2025</p>
-                        <p><strong>Version :</strong> v1.1.0</p>
-                        <p><strong>Last update :</strong> August 28, 2025</p>
+                        <p><strong>Version :</strong> v1.1.1</p>
+                        <p><strong>Last update :</strong> August 29, 2025</p>
                         <p><strong>Technologies :</strong> HTML5, CSS3, JavaScript ES6+, IndexedDB, Web Speech
                             API</p>
                         <p><strong>Status :</strong> ✅ Stable and functional</p>
@@ -1126,7 +1126,7 @@
                 "name": "Jean & Kimi"
             },
             "dateCreated": "2025-07-16",
-                "version": "v1.1.0"
+                "version": "v1.1.1"
         }
     }
     </script>

kimi-js/kimi-database.js

@@ -89,6 +89,51 @@ class KimiDatabase {
             });
     }
 
+    async setConversationsBatch(conversationsArray) {
+        if (!Array.isArray(conversationsArray)) return;
+        try {
+            await this.db.conversations.clear();
+            if (conversationsArray.length) {
+                await this.db.conversations.bulkPut(conversationsArray);
+            }
+        } catch (error) {
+            console.error("Error restoring conversations:", error);
+        }
+    }
+
+    async setLLMModelsBatch(modelsArray) {
+        if (!Array.isArray(modelsArray)) return;
+        try {
+            await this.db.llmModels.clear();
+            if (modelsArray.length) {
+                await this.db.llmModels.bulkPut(modelsArray);
+            }
+        } catch (error) {
+            console.error("Error restoring LLM models:", error);
+        }
+    }
+
+    async getAllMemories() {
+        try {
+            return await this.db.memories.toArray();
+        } catch (error) {
+            console.warn("Error getting all memories:", error);
+            return [];
+        }
+    }
+
+    async setAllMemories(memoriesArray) {
+        if (!Array.isArray(memoriesArray)) return;
+        try {
+            await this.db.memories.clear();
+            if (memoriesArray.length) {
+                await this.db.memories.bulkPut(memoriesArray);
+            }
+        } catch (error) {
+            console.error("Error restoring memories:", error);
+        }
+    }
+
     async init() {
         await this.db.open();
         await this.initializeDefaultsIfNeeded();
@@ -357,6 +402,58 @@ class KimiDatabase {
             } catch (mErr) {
                 // Non-blocking: ignore migration error
             }
+
+            // MIGRATION: Normalize legacy selectedLanguage values to primary subtag (e.g., 'en-US'|'en_US'|'us:en' -> 'en')
+            try {
+                const langRecord = await this.db.preferences.get("selectedLanguage");
+                if (langRecord && typeof langRecord.value === "string") {
+                    let raw = String(langRecord.value).toLowerCase();
+                    // handle 'us:en' -> take part after ':'
+                    if (raw.includes(":")) {
+                        const parts = raw.split(":");
+                        raw = parts[parts.length - 1];
+                    }
+                    raw = raw.replace("_", "-");
+                    const primary = raw.includes("-") ? raw.split("-")[0] : raw;
+                    if (primary && primary !== langRecord.value) {
+                        await this.db.preferences.put({
+                            key: "selectedLanguage",
+                            value: primary,
+                            updated: new Date().toISOString()
+                        });
+                        console.log(`🔧 Migration: Normalized selectedLanguage '${langRecord.value}' -> '${primary}'`);
+                    }
+                }
+            } catch (normErr) {
+                // Non-blocking
+            }
+
+            // FORCED MIGRATION: Normalize any preference keys containing the word 'language' to primary subtag
+            // WARNING: This is destructive by design and will overwrite values without backup as requested.
+            try {
+                const allPrefs = await this.db.preferences.toArray();
+                const langKeyRegex = /\blanguage\b/i;
+                let modified = 0;
+                for (const p of allPrefs) {
+                    if (!p || typeof p.key !== "string" || typeof p.value !== "string") continue;
+                    if (!langKeyRegex.test(p.key)) continue;
+                    let raw = String(p.value).toLowerCase();
+                    if (raw.includes(":")) raw = raw.split(":").pop();
+                    raw = raw.replace("_", "-");
+                    const primary = raw.includes("-") ? raw.split("-")[0] : raw;
+                    if (primary && primary !== p.value) {
+                        await this.db.preferences.put({ key: p.key, value: primary, updated: new Date().toISOString() });
+                        modified++;
+                    }
+                }
+                if (modified) {
+                    console.log(
+                        `🔧 Forced Migration: Normalized ${modified} language-related preference(s) to primary subtag (no backup)`
+                    );
+                }
+            } catch (fmErr) {
+                console.warn("Forced migration failed:", fmErr);
+            }
         } catch {}
     }
 
@@ -491,6 +588,28 @@ class KimiDatabase {
                 }
             }
 
+            // Normalize specific preferences for backward-compatibility
+            if (key === "selectedLanguage" && typeof value === "string") {
+                try {
+                    let raw = String(value).toLowerCase();
+                    if (raw.includes(":")) raw = raw.split(":").pop();
+                    raw = raw.replace("_", "-");
+                    const primary = raw.includes("-") ? raw.split("-")[0] : raw;
+                    if (primary && primary !== value) {
+                        // Persist normalized primary subtag to DB for future reads
+                        try {
+                            await this.db.preferences.put({ key: key, value: primary, updated: new Date().toISOString() });
+                            value = primary;
+                        } catch (mErr) {
+                            // ignore persistence error, but return normalized value
+                            value = primary;
+                        }
+                    }
+                } catch (e) {
+                    // ignore normalization errors
+                }
+            }
+
             // Cache the result
             const cache =
                 window.KimiCacheManager && typeof window.KimiCacheManager.set === "function" ? window.KimiCacheManager : null;
@@ -768,6 +887,18 @@ class KimiDatabase {
     }
 
     async setPreferencesBatch(prefsArray) {
+        // Backwards-compatible: accept either an array [{key,value},...] or an object map { key: value }
+        let prefsInput = prefsArray;
+        if (!Array.isArray(prefsInput) && prefsInput && typeof prefsInput === "object") {
+            // convert map to array
+            prefsInput = Object.keys(prefsInput).map(k => ({ key: k, value: prefsInput[k] }));
+            console.warn("setPreferencesBatch: converted prefs map to array for backward compatibility");
+        }
+        if (!Array.isArray(prefsInput)) {
+            console.warn("setPreferencesBatch: expected array or object, got", typeof prefsArray);
+            return;
+        }
+
         const numericMap = {
             voiceRate: "VOICE_RATE",
             voicePitch: "VOICE_PITCH",
@@ -779,7 +910,7 @@ class KimiDatabase {
             llmFrequencyPenalty: "LLM_FREQUENCY_PENALTY",
             llmPresencePenalty: "LLM_PRESENCE_PENALTY"
         };
-        const batch = prefsArray.map(({ key, value }) => {
+        const batch = prefsInput.map(({ key, value }) => {
             if (numericMap[key] && window.KIMI_CONFIG && typeof window.KIMI_CONFIG.validate === "function") {
                 const validation = window.KIMI_CONFIG.validate(value, numericMap[key]);
                 if (validation.valid) value = validation.value;

kimi-js/kimi-memory-ui.js

@@ -33,13 +33,19 @@ class KimiMemoryUI {
         // Add memory button
         const addMemoryBtn = document.getElementById("add-memory");
         if (addMemoryBtn) {
-            addMemoryBtn.addEventListener("click", () => this.addManualMemory());
+            addMemoryBtn.addEventListener("click", () => {
+                this.addManualMemory();
+                ensureVideoNeutralOnUIChange();
+            });
         }
 
         // Memory modal close
         const memoryClose = document.getElementById("memory-close");
         if (memoryClose) {
-            memoryClose.addEventListener("click", () => this.closeMemoryModal());
+            memoryClose.addEventListener("click", () => {
+                this.closeMemoryModal();
+                ensureVideoNeutralOnUIChange();
+            });
         }
 
         // Memory export
@@ -51,7 +57,10 @@ class KimiMemoryUI {
         // Memory filter
         const memoryFilter = document.getElementById("memory-filter-category");
         if (memoryFilter) {
-            memoryFilter.addEventListener("change", () => this.filterMemories());
+            memoryFilter.addEventListener("change", () => {
+                this.filterMemories();
+                ensureVideoNeutralOnUIChange();
+            });
         }
 
         // Memory search
@@ -881,3 +890,10 @@ document.addEventListener("DOMContentLoaded", async () => {
 });
 
 window.KimiMemoryUI = KimiMemoryUI;
+
+function ensureVideoNeutralOnUIChange() {
+    if (window.kimiVideo && window.kimiVideo.getCurrentVideoInfo) {
+        const info = window.kimiVideo.getCurrentVideoInfo();
+        if (info && info.ended) window.kimiVideo.returnToNeutral();
+    }
+}

kimi-js/kimi-module.js

@@ -77,9 +77,14 @@ class KimiDataManager extends KimiBaseManager {
 
         try {
             const conversations = await this.db.getAllConversations();
-            const preferences = await this.db.getAllPreferences();
+            const preferencesObj = await this.db.getAllPreferences();
+            // Export preferences as an array of {key,value} so export is directly re-importable
+            const preferences = Array.isArray(preferencesObj)
+                ? preferencesObj
+                : Object.keys(preferencesObj).map(k => ({ key: k, value: preferencesObj[k] }));
             const personalityTraits = await this.db.getAllPersonalityTraits();
             const models = await this.db.getAllLLMModels();
+            const memories = await this.db.getAllMemories();
 
             const exportData = {
                 version: "1.0",
@@ -88,11 +93,13 @@ class KimiDataManager extends KimiBaseManager {
                 preferences: preferences,
                 personalityTraits: personalityTraits,
                 models: models,
+                memories: memories,
                 metadata: {
                     totalConversations: conversations.length,
                     totalPreferences: Object.keys(preferences).length,
                     totalTraits: Object.keys(personalityTraits).length,
-                    totalModels: models.length
+                    totalModels: models.length,
+                    totalMemories: memories.length
                 }
             };
 
@@ -112,6 +119,88 @@ class KimiDataManager extends KimiBaseManager {
         }
     }
 
+    async importData(event) {
+        const file = event.target.files[0];
+        if (!file) {
+            alert("No file selected.");
+            return;
+        }
+        const reader = new FileReader();
+        reader.onload = async e => {
+            try {
+                const data = JSON.parse(e.target.result);
+                try {
+                    console.log("Import file keys:", Object.keys(data));
+                } catch (ex) {}
+
+                if (data.preferences) {
+                    try {
+                        const isArray = Array.isArray(data.preferences);
+                        const len = isArray ? data.preferences.length : Object.keys(data.preferences).length;
+                        console.log("Import: preferences type=", isArray ? "array" : "object", "length=", len);
+                    } catch (ex) {}
+                    await this.db.setPreferencesBatch(data.preferences);
+                } else {
+                    console.log("Import: no preferences found");
+                }
+
+                if (data.conversations) {
+                    try {
+                        console.log(
+                            "Import: conversations length=",
+                            Array.isArray(data.conversations) ? data.conversations.length : "not-array"
+                        );
+                    } catch (ex) {}
+                    await this.db.setConversationsBatch(data.conversations);
+                } else {
+                    console.log("Import: no conversations found");
+                }
+
+                if (data.personalityTraits) {
+                    try {
+                        console.log("Import: personalityTraits type=", typeof data.personalityTraits);
+                    } catch (ex) {}
+                    await this.db.setPersonalityBatch(data.personalityTraits);
+                } else {
+                    console.log("Import: no personalityTraits found");
+                }
+
+                if (data.models) {
+                    try {
+                        console.log("Import: models length=", Array.isArray(data.models) ? data.models.length : "not-array");
+                    } catch (ex) {}
+                    await this.db.setLLMModelsBatch(data.models);
+                } else {
+                    console.log("Import: no models found");
+                }
+
+                if (data.memories) {
+                    try {
+                        console.log(
+                            "Import: memories length=",
+                            Array.isArray(data.memories) ? data.memories.length : "not-array"
+                        );
+                    } catch (ex) {}
+                    await this.db.setAllMemories(data.memories);
+                } else {
+                    console.log("Import: no memories found");
+                }
+
+                alert("Import successful!");
+                await this.updateStorageInfo();
+
+                // Reload the page to ensure all UI state is rebuilt from the newly imported DB
+                setTimeout(() => {
+                    location.reload();
+                }, 200);
+            } catch (err) {
+                console.error("Import failed:", err);
+                alert("Import failed. Invalid file or format.");
+            }
+        };
+        reader.readAsText(file);
+    }
+
     async cleanOldData() {
         if (!this.db) {
             console.error("Database not available");
@@ -787,6 +876,14 @@ async function loadSettingsData() {
         const voicePitch = preferences.voicePitch !== undefined ? preferences.voicePitch : 1.1;
         const voiceVolume = preferences.voiceVolume !== undefined ? preferences.voiceVolume : 0.8;
         const selectedLanguage = preferences.selectedLanguage || "en";
+        // Normalize legacy formats to primary subtag (e.g., 'en-US' -> 'en')
+        const normSelectedLanguage = (function (raw) {
+            if (!raw) return "en";
+            let r = String(raw).toLowerCase();
+            if (r.includes(":")) r = r.split(":").pop();
+            r = r.replace("_", "-");
+            return r.includes("-") ? r.split("-")[0] : r;
+        })(selectedLanguage);
         const apiKey = preferences.providerApiKey || "";
         const provider = preferences.llmProvider || "openrouter";
         const baseUrl = preferences.llmBaseUrl || "https://openrouter.ai/api/v1/chat/completions";
@@ -801,7 +898,7 @@ async function loadSettingsData() {
 
         // Update UI with voice settings
         const languageSelect = document.getElementById("language-selection");
-        if (languageSelect) languageSelect.value = selectedLanguage;
+        if (languageSelect) languageSelect.value = normSelectedLanguage;
         updateSlider("voice-rate", voiceRate);
         updateSlider("voice-pitch", voicePitch);
         updateSlider("voice-volume", voiceVolume);

kimi-js/kimi-utils.js

@@ -164,6 +164,22 @@ window.KimiLanguageUtils = {
         if (/[\u3040-\u309f\u30a0-\u30ff\u4e00-\u9faf]/i.test(text)) return "ja";
         if (/[\u4e00-\u9fff]/i.test(text)) return "zh";
         return "en";
+    },
+    // Normalize language codes to a primary subtag (e.g. 'en-US' -> 'en', 'us:en' -> 'en')
+    normalizeLanguageCode(raw) {
+        if (!raw) return "";
+        try {
+            let norm = String(raw).toLowerCase();
+            if (norm.includes(":")) {
+                const parts = norm.split(":");
+                norm = parts[parts.length - 1];
+            }
+            norm = norm.replace("_", "-");
+            if (norm.includes("-")) norm = norm.split("-")[0];
+            return norm;
+        } catch (e) {
+            return "";
+        }
     }
 };
 

kimi-js/kimi-voices.js

@@ -207,7 +207,8 @@ class KimiVoiceManager {
         // Only get language from DB if not already set
         if (!this.selectedLanguage) {
             const selectedLanguage = await this.db?.getPreference("selectedLanguage", "en");
-            this.selectedLanguage = selectedLanguage || "en";
+            // Normalize legacy formats (en-US, en_US, us:en -> en) using shared util
+            this.selectedLanguage = window.KimiLanguageUtils.normalizeLanguageCode(selectedLanguage || "en") || "en";
         }
 
         const savedVoice = await this.db?.getPreference("selectedVoice", "auto");
@@ -409,7 +410,14 @@ class KimiVoiceManager {
         if (e.target.value === "auto") {
             console.log(`🎤 Voice set to automatic selection for language "${this.selectedLanguage}"`);
             await this.db?.setPreference("selectedVoice", "auto");
-            this.currentVoice = null; // Trigger auto-selection next time
+            this.currentVoice = null; // clear immediate in-memory voice
+            // Re-initialize voices synchronously so currentVoice is set before other code reacts
+            try {
+                await this.initVoices();
+            } catch (err) {
+                // If init fails, leave currentVoice null but don't throw
+                console.warn("🎤 initVoices failed after setting auto:", err);
+            }
         } else {
             this.currentVoice = this.availableVoices.find(voice => voice.name === e.target.value);
             console.log(`🎤 Voice manually selected: "${this.currentVoice?.name}" (${this.currentVoice?.lang})`);
@@ -451,15 +459,31 @@ class KimiVoiceManager {
         return languageMap[langShort] || langShort;
     }
 
+    // language normalization handled by window.KimiLanguageUtils.normalizeLanguageCode
+
     getVoicesForLanguage(language) {
-        let filteredVoices = this.availableVoices.filter(voice => voice.lang.toLowerCase().startsWith(language));
-        if (filteredVoices.length === 0) {
-            filteredVoices = this.availableVoices.filter(voice => voice.lang.toLowerCase().includes(language));
-        }
-        if (filteredVoices.length === 0) {
-            // As last resort, return all voices
-            filteredVoices = this.availableVoices;
+        const norm = window.KimiLanguageUtils.normalizeLanguageCode(language || "");
+        // First pass: voices whose lang primary subtag starts with normalized code
+        let filteredVoices = this.availableVoices.filter(voice => {
+            try {
+                const vlang = String(voice.lang || "").toLowerCase();
+                return vlang.startsWith(norm);
+            } catch (e) {
+                return false;
+            }
+        });
+
+        // Second pass: voices that contain the code anywhere
+        if (filteredVoices.length === 0 && norm) {
+            filteredVoices = this.availableVoices.filter(voice =>
+                String(voice.lang || "")
+                    .toLowerCase()
+                    .includes(norm)
+            );
         }
+
+        // Last resort: return all voices
+        if (filteredVoices.length === 0) filteredVoices = this.availableVoices;
         return filteredVoices;
     }
 
@@ -551,8 +575,32 @@ class KimiVoiceManager {
     }
 
     async speak(text, options = {}) {
-        if (!text || !this.currentVoice) {
-            console.warn("Unable to speak: empty text or voice not initialized");
+        // If no text or voice not ready, attempt short retries for voice initialization
+        if (!text) {
+            console.warn("Unable to speak: empty text");
+            return;
+        }
+
+        const maxRetries = 3;
+        let attempt = 0;
+        while (!this.currentVoice && attempt < maxRetries) {
+            // Small jittered backoff
+            const wait = 100 + Math.floor(Math.random() * 200); // 100-300ms
+            await new Promise(r => setTimeout(r, wait));
+            // If voices available, try to init
+            if (this.availableVoices.length > 0) {
+                // attempt to pick a voice for the current language
+                try {
+                    await this.initVoices();
+                } catch (e) {
+                    // ignore and retry
+                }
+            }
+            attempt++;
+        }
+
+        if (!this.currentVoice) {
+            console.warn("Unable to speak: voice not initialized after retries");
             return;
         }
         this.clearTranscriptTimeout();
@@ -1258,7 +1306,7 @@ class KimiVoiceManager {
     async handleLanguageChange(e) {
         const newLang = e.target.value;
         const oldLang = this.selectedLanguage;
-        console.log(`� Language changing: "${oldLang}" → "${newLang}"`);
+        console.log(`🎤 Language changing: "${oldLang}" → "${newLang}"`);
 
         this.selectedLanguage = newLang;
         await this.db?.setPreference("selectedLanguage", newLang);
@@ -1268,16 +1316,31 @@ class KimiVoiceManager {
             await window.kimiI18nManager.setLanguage(newLang);
         }
 
-        // ALWAYS reset voice when changing language to ensure compatibility
-        const currentVoicePref = await this.db?.getPreference("selectedVoice", "auto");
-
-        // Reset voice selection to force re-selection for new language
-        this.currentVoice = null;
-
-        // CRITICAL: Reset voice preference to "auto" to prevent old voice from being reused
-        await this.db?.setPreference("selectedVoice", "auto");
+        // Check saved voice compatibility: only reset to 'auto' if incompatible
+        try {
+            const currentVoicePref = await this.db?.getPreference("selectedVoice", "auto");
+            // Clear in-memory currentVoice to allow re-selection
+            this.currentVoice = null;
+
+            if (currentVoicePref && currentVoicePref !== "auto") {
+                // If saved voice name exists, check if it's present among filtered voices for the new language
+                const filtered = this.getVoicesForLanguage(newLang);
+                const compatible = filtered.some(v => v.name === currentVoicePref);
+                if (!compatible) {
+                    // Only write 'auto' when incompatible
+                    await this.db?.setPreference("selectedVoice", "auto");
+                }
+            }
 
-        await this.initVoices();
+            // Re-init voices to pick a correct voice for the new language
+            await this.initVoices();
+        } catch (err) {
+            // On error, fall back to safe behavior: init voices and set 'auto'
+            try {
+                await this.db?.setPreference("selectedVoice", "auto");
+            } catch {}
+            await this.initVoices();
+        }
 
         if (this.currentVoice) {
             console.log(`🎤 Voice selected for "${newLang}": "${this.currentVoice.name}" (${this.currentVoice.lang})`);