mirror of
https://github.com/m5stack/ESP-Claw.git
synced 2026-05-20 11:51:49 -07:00
1894 lines
62 KiB
JavaScript
1894 lines
62 KiB
JavaScript
/* ═══════════════════════════════════════════════════
|
||
i18n – extensible locale registry
|
||
To add a new language, append an entry to LOCALES
|
||
and add a matching key in `strings`.
|
||
═══════════════════════════════════════════════════ */
|
||
|
||
const LOCALES = [
|
||
{ id: "en", label: "English" },
|
||
{ id: "zh-cn", label: "简体中文" },
|
||
];
|
||
|
||
const strings = {
|
||
en: {
|
||
docTitle: "ESP-Claw Settings",
|
||
pageTitle: "Device Settings",
|
||
pageSubtitle:
|
||
"Configure credentials, runtime settings, and manage FATFS storage on your ESP device.",
|
||
tabConfig: "Configuration",
|
||
tabMemory: "Memory",
|
||
tabFiles: "File Manager",
|
||
|
||
statusLoading: "Loading\u2026",
|
||
statusOnline: "Wi-Fi Connected",
|
||
statusOffline: "Wi-Fi Offline",
|
||
|
||
sectionWifi: "Wi-Fi Settings",
|
||
wifiSsid: "Wi-Fi SSID",
|
||
wifiPassword: "Wi-Fi Password",
|
||
|
||
sectionLlm: "LLM Settings",
|
||
llmProvider: "LLM Provider",
|
||
llmProviderOpenai: "OpenAI",
|
||
llmProviderQwen: "Qwen Compatible",
|
||
llmProviderDeepSeek: "DeepSeek",
|
||
llmProviderAnthropic: "Anthropic",
|
||
llmProviderCustom: "Custom",
|
||
llmApiKey: "API Key",
|
||
llmModel: "Model",
|
||
llmTimeout: "Timeout (ms)",
|
||
llmTimeoutPlaceholder: "120000",
|
||
llmAdvanced: "LLM Advanced Options",
|
||
llmBackend: "Backend Type",
|
||
llmBackendPlaceholder: "openai_compatible / anthropic / custom",
|
||
llmProfile: "Profile",
|
||
llmProfilePlaceholder: "openai / qwen_compatible / custom_openai_compatible / anthropic",
|
||
llmBaseUrl: "Base URL",
|
||
llmBaseUrlPlaceholder: "https://api.openai.com/v1",
|
||
llmAuthType: "Auth Type",
|
||
llmAuthTypePlaceholder: "bearer / api-key / none",
|
||
|
||
sectionIm: "Instant Messaging (IM)",
|
||
imWechatTitle: "WeChat",
|
||
imFeishuTitle: "Feishu",
|
||
wechatLoginDesc: "QR Code Sign-in",
|
||
qqAppId: "QQ App ID",
|
||
qqAppSecret: "QQ App Secret",
|
||
feishuAppId: "Feishu App ID",
|
||
feishuAppSecret: "Feishu App Secret",
|
||
tgBotToken: "Telegram Bot Token",
|
||
wechatToken: "WeChat Token",
|
||
wechatBaseUrl: "WeChat Base URL",
|
||
wechatBaseUrlPlaceholder: "https://ilinkai.weixin.qq.com",
|
||
wechatCdnBaseUrl: "WeChat CDN Base URL",
|
||
wechatCdnBaseUrlPlaceholder: "https://novac2c.cdn.weixin.qq.com/c2c",
|
||
wechatAccountId: "WeChat Account ID",
|
||
wechatAccountIdPlaceholder: "default",
|
||
wechatLogin: "WeChat Login",
|
||
wechatLoginGenerate: "Generate QR",
|
||
wechatLoginCancel: "Cancel",
|
||
wechatLoginStatus: "Status: idle",
|
||
wechatLoginNote:
|
||
"Generate a QR code here to obtain wechat_token automatically. The token is saved to NVS after confirmation. Restart the device to apply the new login.",
|
||
wechatLoginOpenLink: "Open login link",
|
||
|
||
sectionSearch: "Search (Optional)",
|
||
searchNote:
|
||
"If set, ESP-Claw can search online. Tip: Built-in weather skill also relies on online search.",
|
||
searchBraveKey: "Brave Search API Key",
|
||
searchTavilyKey: "Tavily API Key",
|
||
|
||
sectionCapabilities: "Capability Groups",
|
||
sectionAdvanced: "Advanced Settings",
|
||
enabledCapGroups: "Enabled Capability Groups",
|
||
enabledCapGroupsHelp:
|
||
"Choose which compiled capability groups can be used after boot, and which enabled groups stay visible to the LLM. Changes take effect after restart.",
|
||
capabilitySelectAll: "Select All",
|
||
capabilityClearAll: "Clear All",
|
||
capabilityLlmDefaults: "Restore LLM Set",
|
||
capabilityLlmClear: "Clear LLM",
|
||
capabilityLoading: "Loading capabilities...",
|
||
capabilityLoadError: "Failed to load capabilities",
|
||
capabilitySelectedSummary: "{enabled} enabled, {llm} LLM-visible, total {total}",
|
||
capabilityEnabled: "Enabled",
|
||
capabilityLlmAlwaysVisible: "LLM Always Visible",
|
||
enabledLuaModules: "Enabled Lua Modules",
|
||
enabledLuaModulesHelp:
|
||
"Choose which compiled Lua modules are registered when cap_lua starts. Changes take effect after restart.",
|
||
luaModuleSelectAll: "Select All",
|
||
luaModuleClearAll: "Clear All",
|
||
luaModuleLoading: "Loading Lua modules...",
|
||
luaModuleLoadError: "Failed to load Lua modules",
|
||
luaModuleSelectedSummary: "{enabled} enabled, total {total}",
|
||
luaModuleCapabilityRequired:
|
||
"Enable the cap_lua capability group above before Lua module settings can take effect.",
|
||
timezone: "Timezone",
|
||
timezonePlaceholder: "e.g. CST-8 (Beijing) or UTC0",
|
||
timezoneHelp:
|
||
"POSIX TZ string only. The sign is INVERTED relative to common UTC notation: Beijing (UTC+8) must be written as 'CST-8'; New York (UTC-5) is 'EST5'. Names like 'Asia/Shanghai' will NOT work — please convert manually.",
|
||
saveBtn: "Save Changes",
|
||
saveSuccess: "Settings saved",
|
||
saveError: "Failed to save settings",
|
||
memoryTitle: "Memory Files",
|
||
memoryDescription: "Manage the device memory files.",
|
||
memoryCardLongTerm: "Long-term Memory",
|
||
memoryCardSoul: "Soul",
|
||
memoryCardIdentity: "Identity",
|
||
memoryCardUserInfo: "User Info",
|
||
memoryMissing: "Long-term memory file does not exist yet.",
|
||
memoryRefreshAll: "Refresh All",
|
||
memoryRefresh: "Refresh",
|
||
memoryAuxMissing: "Memory file does not exist yet.",
|
||
memoryRefreshed: "Memory reloaded",
|
||
memoryLoadError: "Failed to load memory",
|
||
memorySaveError: "Failed to save memory",
|
||
configNote:
|
||
"Changes are stored in NVS. Choose an LLM provider first, then fill the shared API key and model fields. Restart the device after updating Wi-Fi, Feishu, core LLM, capability, or Lua module settings.",
|
||
|
||
fileRefresh: "Refresh",
|
||
fileUpDir: "Up One Level",
|
||
fileNewFolder: "New folder name",
|
||
fileCreateFolder: "Create Folder",
|
||
fileUploadPath: "/example.txt",
|
||
fileChoose: "Choose File",
|
||
fileNoFileSelected: "No file selected",
|
||
fileUpload: "Upload",
|
||
fileColName: "Name",
|
||
fileColType: "Type",
|
||
fileColSize: "Size",
|
||
fileColActions: "Actions",
|
||
fileTypeFolder: "Folder",
|
||
fileTypeFile: "File",
|
||
fileEmpty: "This folder is empty.",
|
||
fileOpen: "Open",
|
||
fileEdit: "Edit",
|
||
filePreview: "Preview",
|
||
fileDownload: "Download",
|
||
fileDelete: "Delete",
|
||
fileDevMode: "Dev Mode",
|
||
fileDevModeRequired: "Enable Dev Mode to modify files.",
|
||
fileDevModeConfirm:
|
||
"After entering Dev Mode, you can upload, modify, or delete files. Incorrect changes may cause the system to fail, reboot endlessly, or behave unexpectedly. Please proceed carefully.",
|
||
fileDeleteConfirm: "Delete {path}?",
|
||
fileUploadComplete: "Upload completed",
|
||
fileFolderCreated: "Folder created",
|
||
fileDeleteComplete: "Delete completed",
|
||
fileEditorTitle: "Edit File",
|
||
fileEditorRefresh: "Refresh",
|
||
fileEditorClose: "Close",
|
||
fileEditorSave: "Save",
|
||
fileEditorSaved: "File saved",
|
||
fileEditorLoadError: "Failed to load file",
|
||
fileEditorSaveError: "Failed to save file",
|
||
fileSelectAndPath:
|
||
"Select a file and provide a target path that starts with /.",
|
||
fileFolderNameRequired: "Enter a folder name.",
|
||
},
|
||
|
||
"zh-cn": {
|
||
docTitle: "ESP-Claw 设置",
|
||
pageTitle: "设备设置",
|
||
pageSubtitle:
|
||
"配置凭据、运行时设置，并管理 ESP 设备上的 FATFS 存储。",
|
||
tabConfig: "配置管理",
|
||
tabMemory: "记忆管理",
|
||
tabFiles: "文件管理",
|
||
|
||
statusLoading: "加载中\u2026",
|
||
statusOnline: "Wi-Fi 已连接",
|
||
statusOffline: "Wi-Fi 离线",
|
||
|
||
sectionWifi: "Wi-Fi 设置",
|
||
wifiSsid: "Wi-Fi 名称 (SSID)",
|
||
wifiPassword: "Wi-Fi 密码",
|
||
|
||
sectionLlm: "LLM 设置",
|
||
llmProvider: "LLM 提供商",
|
||
llmProviderOpenai: "OpenAI",
|
||
llmProviderQwen: "Qwen 兼容",
|
||
llmProviderDeepSeek: "DeepSeek",
|
||
llmProviderAnthropic: "Anthropic",
|
||
llmProviderCustom: "自定义",
|
||
llmApiKey: "API 密钥",
|
||
llmModel: "模型",
|
||
llmTimeout: "超时 (毫秒)",
|
||
llmTimeoutPlaceholder: "120000",
|
||
llmAdvanced: "LLM 高级选项",
|
||
llmBackend: "后端类型",
|
||
llmBackendPlaceholder: "openai_compatible / anthropic / custom",
|
||
llmProfile: "配置文件",
|
||
llmProfilePlaceholder: "openai / qwen_compatible / custom_openai_compatible / anthropic",
|
||
llmBaseUrl: "Base URL",
|
||
llmBaseUrlPlaceholder: "https://api.openai.com/v1",
|
||
llmAuthType: "认证类型",
|
||
llmAuthTypePlaceholder: "bearer / api-key / none",
|
||
|
||
sectionIm: "即时通讯 (IM)",
|
||
imWechatTitle: "微信",
|
||
imFeishuTitle: "飞书",
|
||
wechatLoginDesc: "二维码登录",
|
||
qqAppId: "QQ App ID",
|
||
qqAppSecret: "QQ App Secret",
|
||
feishuAppId: "飞书 App ID",
|
||
feishuAppSecret: "飞书 App Secret",
|
||
tgBotToken: "Telegram Bot Token",
|
||
wechatToken: "微信 Token",
|
||
wechatBaseUrl: "微信 Base URL",
|
||
wechatBaseUrlPlaceholder: "https://ilinkai.weixin.qq.com",
|
||
wechatCdnBaseUrl: "微信 CDN Base URL",
|
||
wechatCdnBaseUrlPlaceholder: "https://novac2c.cdn.weixin.qq.com/c2c",
|
||
wechatAccountId: "微信账号 ID",
|
||
wechatAccountIdPlaceholder: "默认",
|
||
wechatLogin: "微信登录",
|
||
wechatLoginGenerate: "生成二维码",
|
||
wechatLoginCancel: "取消",
|
||
wechatLoginStatus: "状态：空闲",
|
||
wechatLoginNote:
|
||
"在此生成二维码以自动获取 wechat_token。确认后令牌将保存至 NVS。重启设备以应用新的登录。",
|
||
wechatLoginOpenLink: "打开登录链接",
|
||
|
||
sectionSearch: "搜索（可选）",
|
||
searchNote:
|
||
"如填写，ESP-Claw 可在运行中检索在线资源。提示：系统自带的天气 Skill 也依赖在线搜索功能。",
|
||
searchBraveKey: "Brave Search API Key",
|
||
searchTavilyKey: "Tavily API Key",
|
||
|
||
sectionCapabilities: "Capability Group",
|
||
sectionAdvanced: "高级设置",
|
||
enabledCapGroups: "启用的 Capability Group",
|
||
enabledCapGroupsHelp:
|
||
"选择设备启动后允许使用哪些已编译 capability group，以及哪些启用后的 group 对 LLM 始终可见。修改后需重启生效。",
|
||
capabilitySelectAll: "全选",
|
||
capabilityClearAll: "清空",
|
||
capabilityLlmDefaults: "恢复 LLM 集合",
|
||
capabilityLlmClear: "清空 LLM",
|
||
capabilityLoading: "正在加载 capability...",
|
||
capabilityLoadError: "加载 capability 列表失败",
|
||
capabilitySelectedSummary: "已启用 {enabled}，LLM 可见 {llm}，总计 {total}",
|
||
capabilityEnabled: "启用",
|
||
capabilityLlmAlwaysVisible: "LLM 始终可见",
|
||
enabledLuaModules: "启用的 Lua 模块",
|
||
enabledLuaModulesHelp:
|
||
"选择 cap_lua 启动时要注册哪些已编译 Lua 模块。修改后需重启生效。",
|
||
luaModuleSelectAll: "全选",
|
||
luaModuleClearAll: "清空",
|
||
luaModuleLoading: "正在加载 Lua 模块...",
|
||
luaModuleLoadError: "加载 Lua 模块列表失败",
|
||
luaModuleSelectedSummary: "已启用 {enabled}，总计 {total}",
|
||
luaModuleCapabilityRequired:
|
||
"需先在上方启用 cap_lua capability group，Lua 模块配置才会生效。",
|
||
timezone: "时区",
|
||
timezonePlaceholder: "例如 CST-8（北京时间）或 UTC0",
|
||
timezoneHelp:
|
||
"仅接受 POSIX TZ 字符串，符号与日常 UTC 表示相反。北京时间（UTC+8）应写作 “CST-8”，纽约（UTC-5）写作 “EST5”。不支持 “Asia/Shanghai” 这种 IANA 名称，请自行换算。",
|
||
saveBtn: "保存更改",
|
||
saveSuccess: "设置已保存",
|
||
saveError: "保存设置失败",
|
||
memoryTitle: "记忆文件",
|
||
memoryDescription: "管理记忆文件。",
|
||
memoryCardLongTerm: "长期记忆",
|
||
memoryCardSoul: "灵魂",
|
||
memoryCardIdentity: "身份",
|
||
memoryCardUserInfo: "用户信息",
|
||
memoryMissing: "长期记忆文件尚不存在。",
|
||
memoryRefreshAll: "全部刷新",
|
||
memoryRefresh: "刷新",
|
||
memoryAuxMissing: "记忆文件尚不存在。",
|
||
memoryRefreshed: "记忆已重新加载",
|
||
memoryLoadError: "加载记忆失败",
|
||
memorySaveError: "保存记忆失败",
|
||
configNote:
|
||
"更改存储在 NVS 中。请先选择 LLM 提供商，然后填写 API 密钥和模型字段。更新 Wi-Fi、飞书、核心 LLM、capability 或 Lua 模块设置后请重启设备。",
|
||
|
||
fileRefresh: "刷新",
|
||
fileUpDir: "返回上级",
|
||
fileNewFolder: "新文件夹名称",
|
||
fileCreateFolder: "创建文件夹",
|
||
fileUploadPath: "/example.txt",
|
||
fileChoose: "选择文件",
|
||
fileNoFileSelected: "未选择文件",
|
||
fileUpload: "上传",
|
||
fileColName: "名称",
|
||
fileColType: "类型",
|
||
fileColSize: "大小",
|
||
fileColActions: "操作",
|
||
fileTypeFolder: "文件夹",
|
||
fileTypeFile: "文件",
|
||
fileEmpty: "此文件夹为空。",
|
||
fileOpen: "打开",
|
||
fileEdit: "编辑",
|
||
filePreview: "预览",
|
||
fileDownload: "下载",
|
||
fileDelete: "删除",
|
||
fileDevMode: "开发者模式",
|
||
fileDevModeRequired: "请先启用开发者模式再修改文件。",
|
||
fileDevModeConfirm:
|
||
"进入开发者模式后，你可以上传、修改或删除文件。不正确的增删改可能导致系统无法正常运行、无限重启等问题。请注意合理修改。",
|
||
fileDeleteConfirm: "确定删除 {path}？",
|
||
fileUploadComplete: "上传完成",
|
||
fileFolderCreated: "文件夹已创建",
|
||
fileDeleteComplete: "删除完成",
|
||
fileEditorTitle: "编辑文件",
|
||
fileEditorRefresh: "刷新",
|
||
fileEditorClose: "退出",
|
||
fileEditorSave: "保存",
|
||
fileEditorSaved: "文件已保存",
|
||
fileEditorLoadError: "加载文件失败",
|
||
fileEditorSaveError: "保存文件失败",
|
||
fileSelectAndPath: "请选择文件并提供以 / 开头的目标路径。",
|
||
fileFolderNameRequired: "请输入文件夹名称。",
|
||
},
|
||
};
|
||
|
||
/* ── Current language & device state ── */
|
||
let currentLang = "en";
|
||
let wifiConnected = null; // null = unknown/loading, true/false = fetched
|
||
|
||
function t(key) {
|
||
const table = strings[currentLang] || strings["en"];
|
||
return table[key] ?? (strings["en"][key] || key);
|
||
}
|
||
|
||
function formatTemplate(key, vars) {
|
||
let value = t(key);
|
||
Object.entries(vars).forEach(([name, replacement]) => {
|
||
value = value.replaceAll(`{${name}}`, String(replacement));
|
||
});
|
||
return value;
|
||
}
|
||
|
||
function detectLang() {
|
||
const params = new URLSearchParams(window.location.search);
|
||
const fromUrl = params.get("lang");
|
||
if (fromUrl && strings[fromUrl]) return fromUrl;
|
||
|
||
const saved = localStorage.getItem("esp-claw-lang");
|
||
if (saved && strings[saved]) return saved;
|
||
|
||
const nav = (navigator.language || "").toLowerCase();
|
||
if (nav.startsWith("zh")) return "zh-cn";
|
||
return "en";
|
||
}
|
||
|
||
function applyI18n() {
|
||
document.querySelectorAll("[data-i18n]").forEach((el) => {
|
||
el.textContent = t(el.dataset.i18n);
|
||
});
|
||
document.querySelectorAll("[data-i18n-placeholder]").forEach((el) => {
|
||
el.placeholder = t(el.dataset.i18nPlaceholder);
|
||
});
|
||
document.querySelectorAll("[data-i18n-title]").forEach((el) => {
|
||
document.title = t(el.dataset.i18nTitle);
|
||
});
|
||
document.querySelectorAll("[data-i18n-option]").forEach((el) => {
|
||
el.textContent = t(el.dataset.i18nOption);
|
||
});
|
||
document.documentElement.lang = currentLang === "zh-cn" ? "zh-CN" : "en";
|
||
document.title = t("docTitle");
|
||
refreshStatusText();
|
||
}
|
||
|
||
function refreshStatusText() {
|
||
const el = document.getElementById("status-text");
|
||
if (wifiConnected === null) {
|
||
el.textContent = t("statusLoading");
|
||
} else {
|
||
el.textContent = wifiConnected ? t("statusOnline") : t("statusOffline");
|
||
}
|
||
}
|
||
|
||
function buildLocaleMenu() {
|
||
const menu = document.getElementById("locale-menu");
|
||
menu.innerHTML = "";
|
||
LOCALES.forEach((loc) => {
|
||
const li = document.createElement("li");
|
||
const a = document.createElement("a");
|
||
a.textContent = loc.label;
|
||
a.href = "#";
|
||
a.setAttribute("data-lang", loc.id);
|
||
if (loc.id === currentLang) a.classList.add("is-current");
|
||
a.addEventListener("click", (e) => {
|
||
e.preventDefault();
|
||
setLang(loc.id);
|
||
document.getElementById("lang-switcher").removeAttribute("open");
|
||
});
|
||
li.appendChild(a);
|
||
menu.appendChild(li);
|
||
});
|
||
const label = LOCALES.find((l) => l.id === currentLang);
|
||
document.getElementById("current-locale-label").textContent =
|
||
label ? label.label : currentLang;
|
||
}
|
||
|
||
function setLang(lang) {
|
||
if (!strings[lang]) return;
|
||
currentLang = lang;
|
||
localStorage.setItem("esp-claw-lang", lang);
|
||
applyI18n();
|
||
buildLocaleMenu();
|
||
renderCapabilityCheckboxes();
|
||
renderFileRows(lastFileEntries);
|
||
renderMemoryState();
|
||
updateFileDevModeUI();
|
||
}
|
||
|
||
/* ═══════════════════════════════════════════════════
|
||
Tab switching
|
||
═══════════════════════════════════════════════════ */
|
||
|
||
function initTabs() {
|
||
document.querySelectorAll(".tab-btn").forEach((btn) => {
|
||
btn.addEventListener("click", () => {
|
||
document
|
||
.querySelectorAll(".tab-btn")
|
||
.forEach((b) => b.classList.remove("active"));
|
||
document
|
||
.querySelectorAll(".tab-panel")
|
||
.forEach((p) => p.classList.remove("active"));
|
||
btn.classList.add("active");
|
||
const panel = document.getElementById("tab-" + btn.dataset.tab);
|
||
if (panel) panel.classList.add("active");
|
||
if (btn.dataset.tab === "memory") {
|
||
loadMemory().catch((err) =>
|
||
showBanner("memoryBanner", err.message || t("memoryLoadError"), true)
|
||
);
|
||
}
|
||
});
|
||
});
|
||
}
|
||
|
||
/* ═══════════════════════════════════════════════════
|
||
Config – NVS fields
|
||
═══════════════════════════════════════════════════ */
|
||
|
||
const configFields = [
|
||
"wifi_ssid",
|
||
"wifi_password",
|
||
"llm_api_key",
|
||
"llm_backend_type",
|
||
"llm_profile",
|
||
"llm_model",
|
||
"llm_base_url",
|
||
"llm_auth_type",
|
||
"llm_timeout_ms",
|
||
"qq_app_id",
|
||
"qq_app_secret",
|
||
"feishu_app_id",
|
||
"feishu_app_secret",
|
||
"tg_bot_token",
|
||
"wechat_token",
|
||
"wechat_base_url",
|
||
"wechat_cdn_base_url",
|
||
"wechat_account_id",
|
||
"search_brave_key",
|
||
"search_tavily_key",
|
||
"time_timezone",
|
||
];
|
||
|
||
const CAPABILITY_NONE_SENTINEL = "__none__";
|
||
let capabilityItems = [];
|
||
let pendingEnabledCapGroups = "";
|
||
let pendingLlmVisibleCapGroups = "";
|
||
let luaModuleItems = [];
|
||
let pendingEnabledLuaModules = "";
|
||
|
||
const llmProviderPresets = {
|
||
openai: {
|
||
llm_backend_type: "openai_compatible",
|
||
llm_profile: "openai",
|
||
llm_base_url: "https://api.openai.com/v1",
|
||
llm_auth_type: "bearer",
|
||
},
|
||
qwen: {
|
||
llm_backend_type: "openai_compatible",
|
||
llm_profile: "qwen_compatible",
|
||
llm_base_url: "https://dashscope.aliyuncs.com/compatible-mode/v1",
|
||
llm_auth_type: "bearer",
|
||
},
|
||
deepseek: {
|
||
llm_backend_type: "openai_compatible",
|
||
llm_profile: "custom_openai_compatible",
|
||
llm_base_url: "https://api.deepseek.com",
|
||
llm_auth_type: "bearer",
|
||
},
|
||
anthropic: {
|
||
llm_backend_type: "anthropic",
|
||
llm_profile: "anthropic",
|
||
llm_base_url: "https://api.anthropic.com/v1",
|
||
llm_auth_type: "none",
|
||
},
|
||
};
|
||
|
||
const llmProviderDefaultModels = {
|
||
openai: "gpt-5.4",
|
||
qwen: "qwen3.6-plus",
|
||
deepseek: "deepseek-v4-pro",
|
||
anthropic: "claude-sonnet-4-6",
|
||
};
|
||
|
||
/* ── Banner helpers ── */
|
||
|
||
function showBanner(id, message, isError = false) {
|
||
const banner = document.getElementById(id);
|
||
banner.textContent = message;
|
||
banner.classList.remove("success", "error");
|
||
banner.classList.add(isError ? "error" : "success");
|
||
banner.classList.add("visible");
|
||
}
|
||
|
||
function hideBanner(id) {
|
||
const banner = document.getElementById(id);
|
||
banner.classList.remove("visible", "success", "error");
|
||
}
|
||
|
||
/* ── Config form read / fill ── */
|
||
|
||
function readConfigForm() {
|
||
const payload = {};
|
||
configFields.forEach((field) => {
|
||
const input = document.getElementById(field);
|
||
payload[field] = input ? input.value.trim() : "";
|
||
});
|
||
payload.enabled_cap_groups = serializeCapabilitySelection();
|
||
payload.llm_visible_cap_groups = serializeLlmVisibleSelection();
|
||
payload.enabled_lua_modules = serializeLuaModuleSelection();
|
||
return payload;
|
||
}
|
||
|
||
function fillConfigForm(data) {
|
||
configFields.forEach((field) => {
|
||
const input = document.getElementById(field);
|
||
if (input && typeof data[field] === "string") {
|
||
input.value = data[field];
|
||
}
|
||
});
|
||
pendingEnabledCapGroups =
|
||
typeof data.enabled_cap_groups === "string" ? data.enabled_cap_groups : "";
|
||
pendingLlmVisibleCapGroups =
|
||
typeof data.llm_visible_cap_groups === "string"
|
||
? data.llm_visible_cap_groups
|
||
: "";
|
||
pendingEnabledLuaModules =
|
||
typeof data.enabled_lua_modules === "string" ? data.enabled_lua_modules : "";
|
||
renderCapabilityCheckboxes();
|
||
renderLuaModuleCheckboxes();
|
||
syncProviderPreset();
|
||
}
|
||
|
||
function getSelectionSet(
|
||
serialized,
|
||
items,
|
||
idKey,
|
||
selectAllIfEmpty,
|
||
defaultPredicate = null
|
||
) {
|
||
const selected = new Set();
|
||
const raw = (serialized || "").trim();
|
||
|
||
if (!raw) {
|
||
items.forEach((item) => {
|
||
if (selectAllIfEmpty || (defaultPredicate && defaultPredicate(item))) {
|
||
selected.add(item[idKey]);
|
||
}
|
||
});
|
||
return selected;
|
||
}
|
||
|
||
raw.split(",").forEach((token) => {
|
||
const itemId = token.trim();
|
||
if (!itemId || itemId === CAPABILITY_NONE_SENTINEL || itemId === "none") {
|
||
return;
|
||
}
|
||
selected.add(itemId);
|
||
});
|
||
return selected;
|
||
}
|
||
|
||
function getCapabilitySelectionSet(serialized, selectAllIfEmpty, useDefaultLlmIfEmpty) {
|
||
return getSelectionSet(
|
||
serialized,
|
||
capabilityItems,
|
||
"group_id",
|
||
selectAllIfEmpty,
|
||
useDefaultLlmIfEmpty ? (item) => item.default_llm_visible : null
|
||
);
|
||
}
|
||
|
||
function getLuaModuleSelectionSet(serialized, selectAllIfEmpty) {
|
||
return getSelectionSet(serialized, luaModuleItems, "module_id", selectAllIfEmpty);
|
||
}
|
||
|
||
function updateCapabilitySelectionSummary() {
|
||
const summary = document.getElementById("capabilitySelectionSummary");
|
||
const enabledCount = document.querySelectorAll(
|
||
'#capabilityCheckboxList input[data-role="enabled"]:checked'
|
||
).length;
|
||
const llmCount = document.querySelectorAll(
|
||
'#capabilityCheckboxList input[data-role="llm-visible"]:checked'
|
||
).length;
|
||
|
||
if (!summary) return;
|
||
if (!capabilityItems.length) {
|
||
summary.textContent = t("capabilityLoading");
|
||
return;
|
||
}
|
||
|
||
summary.textContent = formatTemplate("capabilitySelectedSummary", {
|
||
enabled: enabledCount,
|
||
llm: llmCount,
|
||
total: capabilityItems.length,
|
||
});
|
||
}
|
||
|
||
function isLuaCapabilityEnabled() {
|
||
return !!document.querySelector(
|
||
'#capabilityCheckboxList input[data-role="enabled"][value="cap_lua"]:checked'
|
||
);
|
||
}
|
||
|
||
function updateLuaModuleAvailability() {
|
||
const disabled = !isLuaCapabilityEnabled();
|
||
const list = document.getElementById("luaModuleCheckboxList");
|
||
const note = document.getElementById("luaModuleCapabilityNote");
|
||
const selectAllButton = document.getElementById("luaModuleSelectAllButton");
|
||
const clearAllButton = document.getElementById("luaModuleClearAllButton");
|
||
|
||
if (list) {
|
||
list.classList.toggle("is-disabled", disabled);
|
||
}
|
||
if (note) {
|
||
note.classList.toggle("hidden", !disabled);
|
||
}
|
||
[selectAllButton, clearAllButton].forEach((button) => {
|
||
if (button) {
|
||
button.disabled = disabled || !luaModuleItems.length;
|
||
}
|
||
});
|
||
document
|
||
.querySelectorAll('#luaModuleCheckboxList input[data-role="enabled"]')
|
||
.forEach((input) => {
|
||
input.disabled = disabled;
|
||
});
|
||
}
|
||
|
||
function updateLuaModuleSelectionSummary() {
|
||
const summary = document.getElementById("luaModuleSelectionSummary");
|
||
const enabledCount = document.querySelectorAll(
|
||
'#luaModuleCheckboxList input[data-role="enabled"]:checked'
|
||
).length;
|
||
|
||
if (!summary) return;
|
||
if (!luaModuleItems.length) {
|
||
summary.textContent = t("luaModuleLoading");
|
||
return;
|
||
}
|
||
|
||
summary.textContent = formatTemplate("luaModuleSelectedSummary", {
|
||
enabled: enabledCount,
|
||
total: luaModuleItems.length,
|
||
});
|
||
}
|
||
|
||
function renderCapabilityCheckboxes() {
|
||
const list = document.getElementById("capabilityCheckboxList");
|
||
if (!list) return;
|
||
|
||
list.innerHTML = "";
|
||
if (!capabilityItems.length) {
|
||
updateCapabilitySelectionSummary();
|
||
return;
|
||
}
|
||
|
||
const enabled = getCapabilitySelectionSet(pendingEnabledCapGroups, true, false);
|
||
const llmVisible = getCapabilitySelectionSet(
|
||
pendingLlmVisibleCapGroups,
|
||
false,
|
||
true
|
||
);
|
||
capabilityItems.forEach((item) => {
|
||
const label = document.createElement("label");
|
||
label.className = "capability-item";
|
||
|
||
const meta = document.createElement("div");
|
||
meta.className = "capability-meta";
|
||
|
||
const title = document.createElement("div");
|
||
title.className = "capability-title";
|
||
title.textContent = item.display_name || item.group_id;
|
||
|
||
const id = document.createElement("div");
|
||
id.className = "capability-id";
|
||
id.textContent = item.group_id;
|
||
|
||
meta.appendChild(title);
|
||
meta.appendChild(id);
|
||
|
||
const controls = document.createElement("div");
|
||
controls.className = "capability-controls";
|
||
|
||
const enabledToggle = document.createElement("label");
|
||
enabledToggle.className = "capability-toggle";
|
||
const enabledInput = document.createElement("input");
|
||
enabledInput.type = "checkbox";
|
||
enabledInput.value = item.group_id;
|
||
enabledInput.dataset.role = "enabled";
|
||
enabledInput.checked = enabled.has(item.group_id);
|
||
enabledToggle.appendChild(enabledInput);
|
||
enabledToggle.appendChild(document.createTextNode(t("capabilityEnabled")));
|
||
|
||
const llmToggle = document.createElement("label");
|
||
llmToggle.className = "capability-toggle";
|
||
const llmInput = document.createElement("input");
|
||
llmInput.type = "checkbox";
|
||
llmInput.value = item.group_id;
|
||
llmInput.dataset.role = "llm-visible";
|
||
llmInput.checked = enabled.has(item.group_id) && llmVisible.has(item.group_id);
|
||
llmInput.disabled = !enabledInput.checked;
|
||
llmToggle.appendChild(llmInput);
|
||
llmToggle.appendChild(
|
||
document.createTextNode(t("capabilityLlmAlwaysVisible"))
|
||
);
|
||
|
||
enabledInput.addEventListener("change", () => {
|
||
if (!enabledInput.checked) {
|
||
llmInput.checked = false;
|
||
llmInput.disabled = true;
|
||
} else {
|
||
llmInput.disabled = false;
|
||
}
|
||
updateCapabilitySelectionSummary();
|
||
updateLuaModuleAvailability();
|
||
});
|
||
llmInput.addEventListener("change", updateCapabilitySelectionSummary);
|
||
|
||
controls.appendChild(enabledToggle);
|
||
controls.appendChild(llmToggle);
|
||
meta.appendChild(controls);
|
||
|
||
label.appendChild(meta);
|
||
list.appendChild(label);
|
||
});
|
||
|
||
updateCapabilitySelectionSummary();
|
||
updateLuaModuleAvailability();
|
||
}
|
||
|
||
function serializeCapabilitySelection() {
|
||
const checked = Array.from(
|
||
document.querySelectorAll('#capabilityCheckboxList input[type="checkbox"]:checked')
|
||
).map((input) => input.value);
|
||
|
||
if (capabilityItems.length && checked.length === capabilityItems.length) {
|
||
return "";
|
||
}
|
||
if (checked.length === 0) {
|
||
return CAPABILITY_NONE_SENTINEL;
|
||
}
|
||
return checked.join(",");
|
||
}
|
||
|
||
function setAllCapabilityCheckboxes(checked) {
|
||
document
|
||
.querySelectorAll('#capabilityCheckboxList input[data-role="enabled"]')
|
||
.forEach((input) => {
|
||
input.checked = checked;
|
||
});
|
||
document
|
||
.querySelectorAll('#capabilityCheckboxList input[data-role="llm-visible"]')
|
||
.forEach((input) => {
|
||
input.disabled = !checked;
|
||
if (!checked) {
|
||
input.checked = false;
|
||
}
|
||
});
|
||
updateCapabilitySelectionSummary();
|
||
updateLuaModuleAvailability();
|
||
}
|
||
|
||
function serializeLlmVisibleSelection() {
|
||
const checked = Array.from(
|
||
document.querySelectorAll(
|
||
'#capabilityCheckboxList input[data-role="llm-visible"]:checked'
|
||
)
|
||
).map((input) => input.value);
|
||
const defaultSelected = capabilityItems
|
||
.filter((item) => item.default_llm_visible)
|
||
.map((item) => item.group_id);
|
||
|
||
if (
|
||
checked.length === defaultSelected.length &&
|
||
checked.every((groupId) => defaultSelected.includes(groupId))
|
||
) {
|
||
return "";
|
||
}
|
||
if (checked.length === 0) {
|
||
return CAPABILITY_NONE_SENTINEL;
|
||
}
|
||
return checked.join(",");
|
||
}
|
||
|
||
function setLlmVisibleSelection(mode) {
|
||
const enabled = new Set(
|
||
Array.from(
|
||
document.querySelectorAll('#capabilityCheckboxList input[data-role="enabled"]:checked')
|
||
).map((input) => input.value)
|
||
);
|
||
|
||
document
|
||
.querySelectorAll('#capabilityCheckboxList input[data-role="llm-visible"]')
|
||
.forEach((input) => {
|
||
const isEnabled = enabled.has(input.value);
|
||
input.disabled = !isEnabled;
|
||
if (!isEnabled) {
|
||
input.checked = false;
|
||
return;
|
||
}
|
||
if (mode === "defaults") {
|
||
const item = capabilityItems.find((entry) => entry.group_id === input.value);
|
||
input.checked = !!item?.default_llm_visible;
|
||
} else if (mode === "clear") {
|
||
input.checked = false;
|
||
}
|
||
});
|
||
updateCapabilitySelectionSummary();
|
||
}
|
||
|
||
function renderLuaModuleCheckboxes() {
|
||
const list = document.getElementById("luaModuleCheckboxList");
|
||
if (!list) return;
|
||
|
||
list.innerHTML = "";
|
||
if (!luaModuleItems.length) {
|
||
updateLuaModuleSelectionSummary();
|
||
updateLuaModuleAvailability();
|
||
return;
|
||
}
|
||
|
||
const enabled = getLuaModuleSelectionSet(pendingEnabledLuaModules, true);
|
||
luaModuleItems.forEach((item) => {
|
||
const label = document.createElement("label");
|
||
label.className = "capability-item";
|
||
|
||
const meta = document.createElement("div");
|
||
meta.className = "capability-meta";
|
||
|
||
const title = document.createElement("div");
|
||
title.className = "capability-title";
|
||
title.textContent = item.display_name || item.module_id;
|
||
|
||
const id = document.createElement("div");
|
||
id.className = "capability-id";
|
||
id.textContent = item.module_id;
|
||
|
||
const controls = document.createElement("div");
|
||
controls.className = "capability-controls";
|
||
|
||
const enabledToggle = document.createElement("label");
|
||
enabledToggle.className = "capability-toggle";
|
||
const enabledInput = document.createElement("input");
|
||
enabledInput.type = "checkbox";
|
||
enabledInput.value = item.module_id;
|
||
enabledInput.dataset.role = "enabled";
|
||
enabledInput.checked = enabled.has(item.module_id);
|
||
enabledInput.addEventListener("change", updateLuaModuleSelectionSummary);
|
||
enabledToggle.appendChild(enabledInput);
|
||
enabledToggle.appendChild(document.createTextNode(t("capabilityEnabled")));
|
||
|
||
controls.appendChild(enabledToggle);
|
||
meta.appendChild(title);
|
||
meta.appendChild(id);
|
||
meta.appendChild(controls);
|
||
label.appendChild(meta);
|
||
list.appendChild(label);
|
||
});
|
||
|
||
updateLuaModuleSelectionSummary();
|
||
updateLuaModuleAvailability();
|
||
}
|
||
|
||
function serializeLuaModuleSelection() {
|
||
if (!luaModuleItems.length) {
|
||
return pendingEnabledLuaModules || "";
|
||
}
|
||
|
||
const checked = Array.from(
|
||
document.querySelectorAll('#luaModuleCheckboxList input[data-role="enabled"]:checked')
|
||
).map((input) => input.value);
|
||
|
||
if (luaModuleItems.length && checked.length === luaModuleItems.length) {
|
||
return "";
|
||
}
|
||
if (checked.length === 0) {
|
||
return CAPABILITY_NONE_SENTINEL;
|
||
}
|
||
return checked.join(",");
|
||
}
|
||
|
||
function setAllLuaModuleCheckboxes(checked) {
|
||
const disabled = !isLuaCapabilityEnabled();
|
||
document
|
||
.querySelectorAll('#luaModuleCheckboxList input[data-role="enabled"]')
|
||
.forEach((input) => {
|
||
input.checked = checked;
|
||
input.disabled = disabled;
|
||
});
|
||
updateLuaModuleSelectionSummary();
|
||
}
|
||
|
||
/* ── LLM provider preset logic ── */
|
||
|
||
function detectProviderPreset() {
|
||
const backend = document.getElementById("llm_backend_type")?.value.trim();
|
||
const profile = document.getElementById("llm_profile")?.value.trim();
|
||
const baseUrl = document.getElementById("llm_base_url")?.value.trim();
|
||
const authType = document.getElementById("llm_auth_type")?.value.trim();
|
||
|
||
const match = Object.entries(llmProviderPresets).find(
|
||
([, preset]) =>
|
||
preset.llm_backend_type === backend &&
|
||
preset.llm_profile === profile &&
|
||
preset.llm_base_url === baseUrl &&
|
||
preset.llm_auth_type === authType
|
||
);
|
||
return match ? match[0] : "custom";
|
||
}
|
||
|
||
function syncProviderPreset() {
|
||
const select = document.getElementById("llm_provider_preset");
|
||
if (select) select.value = detectProviderPreset();
|
||
}
|
||
|
||
function applyProviderPreset(presetKey) {
|
||
const preset = llmProviderPresets[presetKey];
|
||
if (!preset) {
|
||
syncProviderPreset();
|
||
return;
|
||
}
|
||
Object.entries(preset).forEach(([field, value]) => {
|
||
const input = document.getElementById(field);
|
||
if (input) input.value = value;
|
||
});
|
||
const modelInput = document.getElementById("llm_model");
|
||
if (modelInput && llmProviderDefaultModels[presetKey]) {
|
||
modelInput.value = llmProviderDefaultModels[presetKey];
|
||
}
|
||
syncProviderPreset();
|
||
}
|
||
|
||
/* ═══════════════════════════════════════════════════
|
||
API calls
|
||
═══════════════════════════════════════════════════ */
|
||
|
||
async function loadStatus() {
|
||
try {
|
||
const response = await fetch("/api/status", { cache: "no-store" });
|
||
const data = await response.json();
|
||
const badge = document.getElementById("status-badge");
|
||
const bar = document.getElementById("status-bar");
|
||
|
||
wifiConnected = !!data.wifi_connected;
|
||
if (wifiConnected) {
|
||
badge.classList.remove("offline");
|
||
badge.classList.add("online");
|
||
bar.classList.add("is-online");
|
||
} else {
|
||
badge.classList.remove("online");
|
||
badge.classList.add("offline");
|
||
bar.classList.remove("is-online");
|
||
}
|
||
refreshStatusText();
|
||
|
||
if (data.ip) {
|
||
document.getElementById("info-ip").textContent = "IP: " + data.ip;
|
||
document.getElementById("info-ip").style.display = "";
|
||
document.getElementById("meta-sep-ip").style.display = "";
|
||
}
|
||
if (data.storage_base_path) {
|
||
document.getElementById("info-storage").textContent =
|
||
"Storage: " + data.storage_base_path;
|
||
document.getElementById("info-storage").style.display = "";
|
||
document.getElementById("meta-sep-storage").style.display = "";
|
||
}
|
||
} catch (err) {
|
||
showBanner("configBanner", err.message || t("statusLoading"), true);
|
||
}
|
||
}
|
||
|
||
async function loadConfig() {
|
||
hideBanner("configBanner");
|
||
const response = await fetch("/api/config", { cache: "no-store" });
|
||
if (!response.ok) throw new Error("Failed to load settings");
|
||
fillConfigForm(await response.json());
|
||
}
|
||
|
||
async function loadCapabilities() {
|
||
const response = await fetch("/api/capabilities", { cache: "no-store" });
|
||
if (!response.ok) throw new Error(t("capabilityLoadError"));
|
||
const data = await response.json();
|
||
capabilityItems = Array.isArray(data.items) ? data.items : [];
|
||
renderCapabilityCheckboxes();
|
||
}
|
||
|
||
async function loadLuaModules() {
|
||
const response = await fetch("/api/lua-modules", { cache: "no-store" });
|
||
if (!response.ok) throw new Error(t("luaModuleLoadError"));
|
||
const data = await response.json();
|
||
luaModuleItems = Array.isArray(data.items) ? data.items : [];
|
||
renderLuaModuleCheckboxes();
|
||
}
|
||
|
||
const WECHAT_FIELDS = [
|
||
"wechat_token", "wechat_base_url", "wechat_cdn_base_url", "wechat_account_id",
|
||
];
|
||
|
||
async function reloadWechatFields() {
|
||
const response = await fetch("/api/config", { cache: "no-store" });
|
||
if (!response.ok) return;
|
||
const data = await response.json();
|
||
WECHAT_FIELDS.forEach((field) => {
|
||
const input = document.getElementById(field);
|
||
if (input && typeof data[field] === "string") {
|
||
input.value = data[field];
|
||
}
|
||
});
|
||
}
|
||
|
||
async function saveConfig() {
|
||
const button = document.getElementById("saveConfigButton");
|
||
button.disabled = true;
|
||
hideBanner("configBanner");
|
||
|
||
try {
|
||
const response = await fetch("/api/config", {
|
||
method: "POST",
|
||
cache: "no-store",
|
||
headers: { "Content-Type": "application/json" },
|
||
body: JSON.stringify(readConfigForm()),
|
||
});
|
||
const responseText = await response.text();
|
||
let result = {};
|
||
if (responseText) {
|
||
try {
|
||
result = JSON.parse(responseText);
|
||
} catch (parseError) {
|
||
if (response.ok) throw parseError;
|
||
result = { error: responseText };
|
||
}
|
||
}
|
||
if (!response.ok)
|
||
throw new Error(result.error || t("saveError"));
|
||
showBanner("configBanner", result.message || t("saveSuccess"));
|
||
syncProviderPreset();
|
||
} catch (err) {
|
||
showBanner("configBanner", err.message, true);
|
||
} finally {
|
||
button.disabled = false;
|
||
}
|
||
}
|
||
|
||
/* ═══════════════════════════════════════════════════
|
||
WeChat Login
|
||
═══════════════════════════════════════════════════ */
|
||
|
||
let wechatLoginPollTimer = null;
|
||
|
||
function stopWechatLoginPolling() {
|
||
if (wechatLoginPollTimer) {
|
||
clearTimeout(wechatLoginPollTimer);
|
||
wechatLoginPollTimer = null;
|
||
}
|
||
}
|
||
|
||
function renderWechatLoginStatus(data) {
|
||
const qrCanvas = document.getElementById("wechatLoginQr");
|
||
const qrLink = document.getElementById("wechatLoginQrLink");
|
||
const meta = document.getElementById("wechatLoginMeta");
|
||
|
||
if (data.qr_data_url) {
|
||
if (typeof window.renderWechatQr === "function") {
|
||
try {
|
||
window.renderWechatQr(qrCanvas, data.qr_data_url);
|
||
} catch (error) {
|
||
console.error("Failed to render WeChat QR:", error);
|
||
}
|
||
}
|
||
qrCanvas.classList.remove("hidden");
|
||
qrLink.href = data.qr_data_url;
|
||
qrLink.textContent = t("wechatLoginOpenLink");
|
||
qrLink.classList.remove("hidden");
|
||
} else {
|
||
const ctx = qrCanvas.getContext("2d");
|
||
if (ctx) {
|
||
ctx.clearRect(0, 0, qrCanvas.width, qrCanvas.height);
|
||
}
|
||
qrCanvas.classList.add("hidden");
|
||
qrLink.removeAttribute("href");
|
||
qrLink.textContent = "";
|
||
qrLink.classList.add("hidden");
|
||
}
|
||
|
||
meta.textContent = data.status
|
||
? (currentLang === "zh-cn" ? "状态：" : "Status: ") + data.status
|
||
: t("wechatLoginStatus");
|
||
|
||
if (data.message) {
|
||
showBanner("wechatLoginBanner", data.message);
|
||
} else {
|
||
hideBanner("wechatLoginBanner");
|
||
}
|
||
|
||
if (data.completed && data.persisted) {
|
||
reloadWechatFields().catch(() => {});
|
||
}
|
||
}
|
||
|
||
async function pollWechatLoginStatus() {
|
||
try {
|
||
const response = await fetch("/api/wechat/login/status", {
|
||
cache: "no-store",
|
||
});
|
||
const data = await response.json();
|
||
if (!response.ok)
|
||
throw new Error(data.error || "Failed to fetch WeChat login status");
|
||
renderWechatLoginStatus(data);
|
||
if (data.active || (data.completed && !data.persisted)) {
|
||
wechatLoginPollTimer = setTimeout(pollWechatLoginStatus, 1500);
|
||
} else {
|
||
stopWechatLoginPolling();
|
||
}
|
||
} catch (err) {
|
||
showBanner("wechatLoginBanner", err.message, true);
|
||
stopWechatLoginPolling();
|
||
}
|
||
}
|
||
|
||
async function startWechatLogin() {
|
||
const button = document.getElementById("wechatLoginStartButton");
|
||
button.disabled = true;
|
||
hideBanner("wechatLoginBanner");
|
||
|
||
try {
|
||
const response = await fetch("/api/wechat/login/start", {
|
||
method: "POST",
|
||
cache: "no-store",
|
||
headers: { "Content-Type": "application/json" },
|
||
body: JSON.stringify({
|
||
account_id: document.getElementById("wechat_account_id").value.trim(),
|
||
force: true,
|
||
}),
|
||
});
|
||
const data = await response.json();
|
||
if (!response.ok)
|
||
throw new Error(data.error || "Failed to start WeChat login");
|
||
renderWechatLoginStatus(data);
|
||
stopWechatLoginPolling();
|
||
wechatLoginPollTimer = setTimeout(pollWechatLoginStatus, 1000);
|
||
} catch (err) {
|
||
showBanner("wechatLoginBanner", err.message, true);
|
||
} finally {
|
||
button.disabled = false;
|
||
}
|
||
}
|
||
|
||
async function cancelWechatLogin() {
|
||
try {
|
||
const response = await fetch("/api/wechat/login/cancel", {
|
||
method: "POST",
|
||
cache: "no-store",
|
||
});
|
||
const data = await response.json();
|
||
if (!response.ok)
|
||
throw new Error(data.error || "Failed to cancel WeChat login");
|
||
renderWechatLoginStatus({
|
||
status: currentLang === "zh-cn" ? "已取消" : "cancelled",
|
||
message:
|
||
data.message ||
|
||
(currentLang === "zh-cn" ? "已取消微信登录。" : "WeChat login cancelled."),
|
||
qr_data_url: "",
|
||
completed: false,
|
||
persisted: false,
|
||
});
|
||
stopWechatLoginPolling();
|
||
} catch (err) {
|
||
showBanner("wechatLoginBanner", err.message, true);
|
||
}
|
||
}
|
||
|
||
/* ═══════════════════════════════════════════════════
|
||
File Manager
|
||
═══════════════════════════════════════════════════ */
|
||
|
||
let currentPath = "/";
|
||
let lastFileEntries = [];
|
||
let fileDevModeEnabled = false;
|
||
const EDITABLE_FILE_EXTENSIONS = [".md", ".json", ".txt", ".jsonb", ".jsonc", ".lua"];
|
||
const MEMORY_FILES = [
|
||
{
|
||
id: "memoryEditor",
|
||
missingId: "memoryMissingState",
|
||
path: "/memory/memory.md",
|
||
editable: false,
|
||
},
|
||
{ id: "soulEditor", missingId: "soulMissingState", path: "/memory/soul.md", editable: true },
|
||
{ id: "identityEditor", missingId: "identityMissingState", path: "/memory/identity.md", editable: true },
|
||
{ id: "userEditor", missingId: "userMissingState", path: "/memory/user.md", editable: true },
|
||
];
|
||
let memoryLoaded = false;
|
||
let memoryContents = {};
|
||
let memoryFilePresence = {};
|
||
let activeEditorPath = "";
|
||
let activeEditorSource = "";
|
||
|
||
function isFileDevModeEnabled() {
|
||
return fileDevModeEnabled;
|
||
}
|
||
|
||
function applyFileEditorAccessMode() {
|
||
const textarea = document.getElementById("fileEditorTextarea");
|
||
const saveButton = document.getElementById("saveFileEditorButton");
|
||
if (!textarea || !saveButton) return;
|
||
|
||
const previewOnly = activeEditorSource === "files" && !isFileDevModeEnabled();
|
||
textarea.readOnly = previewOnly;
|
||
saveButton.classList.toggle("hidden", previewOnly);
|
||
saveButton.disabled = previewOnly;
|
||
}
|
||
|
||
function updateFileDevModeUI() {
|
||
const createRow = document.getElementById("fileCreateRow");
|
||
const uploadRow = document.getElementById("fileUploadRow");
|
||
const toggleButton = document.getElementById("devModeButton");
|
||
const enabled = isFileDevModeEnabled();
|
||
|
||
if (createRow) {
|
||
createRow.classList.toggle("hidden", !enabled);
|
||
}
|
||
if (uploadRow) {
|
||
uploadRow.classList.toggle("hidden", !enabled);
|
||
}
|
||
if (toggleButton) {
|
||
toggleButton.classList.toggle("active", enabled);
|
||
toggleButton.setAttribute("aria-pressed", enabled ? "true" : "false");
|
||
}
|
||
|
||
applyFileEditorAccessMode();
|
||
renderFileRows(lastFileEntries);
|
||
}
|
||
|
||
function setFileDevMode(enabled) {
|
||
fileDevModeEnabled = !!enabled;
|
||
updateFileDevModeUI();
|
||
}
|
||
|
||
function humanSize(value) {
|
||
if (value < 1024) return value + " B";
|
||
if (value < 1024 * 1024) return (value / 1024).toFixed(1) + " KB";
|
||
return (value / (1024 * 1024)).toFixed(1) + " MB";
|
||
}
|
||
|
||
function parentPath(path) {
|
||
if (path === "/") return "/";
|
||
const parts = path.split("/").filter(Boolean);
|
||
parts.pop();
|
||
return parts.length ? "/" + parts.join("/") : "/";
|
||
}
|
||
|
||
function joinPath(base, name) {
|
||
return base === "/" ? "/" + name : base + "/" + name;
|
||
}
|
||
|
||
function isEditableFile(path) {
|
||
const lowerPath = (path || "").toLowerCase();
|
||
return EDITABLE_FILE_EXTENSIONS.some((ext) => lowerPath.endsWith(ext));
|
||
}
|
||
|
||
function createActionSlot(node = null, placeholderText = "") {
|
||
const slot = document.createElement("span");
|
||
slot.className = "action-slot";
|
||
if (node) {
|
||
slot.appendChild(node);
|
||
} else {
|
||
slot.classList.add("placeholder");
|
||
slot.textContent = placeholderText;
|
||
}
|
||
return slot;
|
||
}
|
||
|
||
function renderFileRows(entries) {
|
||
lastFileEntries = entries;
|
||
const tbody = document.getElementById("fileTableBody");
|
||
tbody.innerHTML = "";
|
||
|
||
if (!entries.length) {
|
||
const row = document.createElement("tr");
|
||
const td = document.createElement("td");
|
||
td.setAttribute("colspan", "4");
|
||
td.textContent = t("fileEmpty");
|
||
td.style.color = "var(--text-muted)";
|
||
row.appendChild(td);
|
||
tbody.appendChild(row);
|
||
return;
|
||
}
|
||
|
||
entries
|
||
.sort(
|
||
(a, b) =>
|
||
Number(b.is_dir) - Number(a.is_dir) || a.name.localeCompare(b.name)
|
||
)
|
||
.forEach((entry) => {
|
||
const row = document.createElement("tr");
|
||
|
||
const tdName = document.createElement("td");
|
||
tdName.textContent = entry.name;
|
||
row.appendChild(tdName);
|
||
|
||
const tdType = document.createElement("td");
|
||
tdType.textContent = entry.is_dir ? t("fileTypeFolder") : t("fileTypeFile");
|
||
row.appendChild(tdType);
|
||
|
||
const tdSize = document.createElement("td");
|
||
tdSize.textContent = entry.is_dir ? "-" : humanSize(entry.size || 0);
|
||
row.appendChild(tdSize);
|
||
|
||
const tdActions = document.createElement("td");
|
||
tdActions.className = "actions";
|
||
let editControl = null;
|
||
let middleControl = null;
|
||
|
||
if (entry.is_dir) {
|
||
const openBtn = document.createElement("button");
|
||
openBtn.className = "link-btn";
|
||
openBtn.textContent = t("fileOpen");
|
||
openBtn.onclick = () => {
|
||
currentPath = entry.path;
|
||
loadFiles().catch((err) =>
|
||
showBanner("fileBanner", err.message, true)
|
||
);
|
||
};
|
||
middleControl = openBtn;
|
||
} else {
|
||
if (isEditableFile(entry.path)) {
|
||
const editBtn = document.createElement("button");
|
||
editBtn.className = "link-btn";
|
||
editBtn.textContent = isFileDevModeEnabled() ? t("fileEdit") : t("filePreview");
|
||
editBtn.onclick = () => {
|
||
openFileEditor(entry.path).catch((err) =>
|
||
showBanner("fileBanner", err.message || t("fileEditorLoadError"), true)
|
||
);
|
||
};
|
||
editControl = editBtn;
|
||
}
|
||
|
||
const dlLink = document.createElement("a");
|
||
dlLink.href = "/files" + entry.path;
|
||
dlLink.textContent = t("fileDownload");
|
||
dlLink.className = "link-btn";
|
||
dlLink.target = "_blank";
|
||
middleControl = dlLink;
|
||
}
|
||
|
||
const delBtn = document.createElement("button");
|
||
delBtn.className = "link-btn danger";
|
||
delBtn.textContent = t("fileDelete");
|
||
delBtn.disabled = !isFileDevModeEnabled();
|
||
delBtn.onclick = async () => {
|
||
if (!isFileDevModeEnabled()) return;
|
||
const msg = t("fileDeleteConfirm").replace("{path}", entry.path);
|
||
if (!window.confirm(msg)) return;
|
||
await deletePath(entry.path);
|
||
};
|
||
const editPlaceholder = entry.is_dir ? t("fileTypeFolder") : t("fileEdit");
|
||
tdActions.appendChild(createActionSlot(editControl, editPlaceholder));
|
||
tdActions.appendChild(createActionSlot(middleControl));
|
||
tdActions.appendChild(createActionSlot(delBtn));
|
||
|
||
row.appendChild(tdActions);
|
||
tbody.appendChild(row);
|
||
});
|
||
}
|
||
|
||
async function loadFiles() {
|
||
hideBanner("fileBanner");
|
||
document.getElementById("currentPath").textContent = currentPath;
|
||
|
||
const response = await fetch(
|
||
"/api/files?path=" + encodeURIComponent(currentPath),
|
||
{ cache: "no-store" }
|
||
);
|
||
if (!response.ok) throw new Error((await response.text()) || "Failed to load file list");
|
||
|
||
const data = await response.json();
|
||
currentPath = data.path || "/";
|
||
document.getElementById("currentPath").textContent = currentPath;
|
||
renderFileRows(data.entries || []);
|
||
}
|
||
|
||
async function uploadFile() {
|
||
if (!isFileDevModeEnabled()) {
|
||
showBanner("fileBanner", t("fileDevModeRequired"), true);
|
||
return;
|
||
}
|
||
|
||
const pathInput = document.getElementById("uploadPathInput");
|
||
const fileInput = document.getElementById("uploadFileInput");
|
||
const button = document.getElementById("uploadButton");
|
||
const file = fileInput.files[0];
|
||
const relativePath =
|
||
pathInput.value.trim() || (file ? joinPath(currentPath, file.name) : "");
|
||
|
||
if (!file || !relativePath.startsWith("/")) {
|
||
showBanner("fileBanner", t("fileSelectAndPath"), true);
|
||
return;
|
||
}
|
||
|
||
button.disabled = true;
|
||
hideBanner("fileBanner");
|
||
try {
|
||
const response = await fetch(
|
||
"/api/files/upload?path=" + encodeURIComponent(relativePath),
|
||
{ method: "POST", cache: "no-store", body: file }
|
||
);
|
||
if (!response.ok) throw new Error(await response.text());
|
||
pathInput.value = "";
|
||
fileInput.value = "";
|
||
document.getElementById("selectedFileName").textContent =
|
||
t("fileNoFileSelected");
|
||
showBanner("fileBanner", t("fileUploadComplete"));
|
||
await loadFiles();
|
||
} catch (err) {
|
||
showBanner("fileBanner", err.message || "Upload failed", true);
|
||
} finally {
|
||
button.disabled = false;
|
||
}
|
||
}
|
||
|
||
async function createFolder() {
|
||
if (!isFileDevModeEnabled()) {
|
||
showBanner("fileBanner", t("fileDevModeRequired"), true);
|
||
return;
|
||
}
|
||
|
||
const input = document.getElementById("newFolderInput");
|
||
const name = input.value.trim();
|
||
if (!name) {
|
||
showBanner("fileBanner", t("fileFolderNameRequired"), true);
|
||
return;
|
||
}
|
||
|
||
try {
|
||
const response = await fetch("/api/files/mkdir", {
|
||
method: "POST",
|
||
cache: "no-store",
|
||
headers: { "Content-Type": "application/json" },
|
||
body: JSON.stringify({ path: joinPath(currentPath, name) }),
|
||
});
|
||
if (!response.ok) throw new Error(await response.text());
|
||
input.value = "";
|
||
showBanner("fileBanner", t("fileFolderCreated"));
|
||
await loadFiles();
|
||
} catch (err) {
|
||
showBanner("fileBanner", err.message || "Failed to create folder", true);
|
||
}
|
||
}
|
||
|
||
async function deletePath(path) {
|
||
if (!isFileDevModeEnabled()) {
|
||
showBanner("fileBanner", t("fileDevModeRequired"), true);
|
||
return;
|
||
}
|
||
|
||
try {
|
||
const response = await fetch(
|
||
"/api/files?path=" + encodeURIComponent(path),
|
||
{ method: "DELETE", cache: "no-store" }
|
||
);
|
||
if (!response.ok) throw new Error(await response.text());
|
||
showBanner("fileBanner", t("fileDeleteComplete"));
|
||
await loadFiles();
|
||
} catch (err) {
|
||
showBanner("fileBanner", err.message || "Delete failed", true);
|
||
}
|
||
}
|
||
|
||
/* ═══════════════════════════════════════════════════
|
||
File Editor
|
||
═══════════════════════════════════════════════════ */
|
||
|
||
function openFileEditorModal() {
|
||
document.getElementById("fileEditorModal").classList.remove("hidden");
|
||
document.body.style.overflow = "hidden";
|
||
}
|
||
|
||
function closeFileEditorModal() {
|
||
document.getElementById("fileEditorModal").classList.add("hidden");
|
||
document.body.style.overflow = "";
|
||
const shouldRefreshMemory = activeEditorSource === "memory";
|
||
activeEditorPath = "";
|
||
activeEditorSource = "";
|
||
hideBanner("fileEditorBanner");
|
||
if (shouldRefreshMemory) {
|
||
refreshMemory({ showSuccessBanner: false }).catch((err) =>
|
||
showBanner("memoryBanner", err.message || t("memoryLoadError"), true)
|
||
);
|
||
}
|
||
}
|
||
|
||
async function loadFileIntoEditor(path, options = {}) {
|
||
const { allowMissing = false } = options;
|
||
const response = await fetch("/files" + path, { cache: "no-store" });
|
||
if (!response.ok) {
|
||
if (allowMissing && response.status === 404) {
|
||
document.getElementById("fileEditorPath").textContent = path;
|
||
document.getElementById("fileEditorTextarea").value = "";
|
||
activeEditorPath = path;
|
||
return;
|
||
}
|
||
throw new Error((await response.text()) || t("fileEditorLoadError"));
|
||
}
|
||
|
||
const content = await response.text();
|
||
document.getElementById("fileEditorPath").textContent = path;
|
||
document.getElementById("fileEditorTextarea").value = content;
|
||
activeEditorPath = path;
|
||
}
|
||
|
||
async function openFileEditor(path) {
|
||
hideBanner("fileEditorBanner");
|
||
activeEditorSource = "files";
|
||
await loadFileIntoEditor(path);
|
||
applyFileEditorAccessMode();
|
||
openFileEditorModal();
|
||
}
|
||
|
||
async function openMemoryEditor(path) {
|
||
hideBanner("fileEditorBanner");
|
||
activeEditorSource = "memory";
|
||
await loadFileIntoEditor(path, { allowMissing: true });
|
||
applyFileEditorAccessMode();
|
||
openFileEditorModal();
|
||
}
|
||
|
||
async function refreshFileEditor() {
|
||
const button = document.getElementById("refreshFileEditorButton");
|
||
if (!activeEditorPath) return;
|
||
|
||
button.disabled = true;
|
||
hideBanner("fileEditorBanner");
|
||
try {
|
||
await loadFileIntoEditor(activeEditorPath, {
|
||
allowMissing: activeEditorSource === "memory",
|
||
});
|
||
} catch (err) {
|
||
showBanner("fileEditorBanner", err.message || t("fileEditorLoadError"), true);
|
||
} finally {
|
||
button.disabled = false;
|
||
}
|
||
}
|
||
|
||
async function saveFileEditor() {
|
||
const button = document.getElementById("saveFileEditorButton");
|
||
const textarea = document.getElementById("fileEditorTextarea");
|
||
if (!activeEditorPath) return;
|
||
if (activeEditorSource === "files" && !isFileDevModeEnabled()) {
|
||
showBanner("fileEditorBanner", t("fileDevModeRequired"), true);
|
||
return;
|
||
}
|
||
|
||
button.disabled = true;
|
||
hideBanner("fileEditorBanner");
|
||
try {
|
||
const response = await fetch(
|
||
"/api/files/upload?path=" + encodeURIComponent(activeEditorPath),
|
||
{
|
||
method: "POST",
|
||
cache: "no-store",
|
||
body: new Blob([textarea.value], { type: "text/plain; charset=utf-8" }),
|
||
}
|
||
);
|
||
if (!response.ok) {
|
||
throw new Error((await response.text()) || t("fileEditorSaveError"));
|
||
}
|
||
showBanner("fileEditorBanner", t("fileEditorSaved"));
|
||
await loadFiles();
|
||
} catch (err) {
|
||
showBanner("fileEditorBanner", err.message || t("fileEditorSaveError"), true);
|
||
} finally {
|
||
button.disabled = false;
|
||
}
|
||
}
|
||
|
||
/* ═══════════════════════════════════════════════════
|
||
Memory Manager
|
||
═══════════════════════════════════════════════════ */
|
||
|
||
function renderMemoryState() {
|
||
MEMORY_FILES.forEach((file) => {
|
||
const editor = document.getElementById(file.id);
|
||
const missing = file.missingId ? document.getElementById(file.missingId) : null;
|
||
const exists = !!memoryFilePresence[file.path];
|
||
const editButton = document.querySelector(`.memory-edit-btn[data-path="${file.path}"]`);
|
||
|
||
if (editor) {
|
||
editor.value = memoryContents[file.path] || "";
|
||
editor.readOnly = true;
|
||
editor.classList.toggle("hidden", !exists);
|
||
}
|
||
if (missing) {
|
||
missing.classList.toggle("hidden", exists);
|
||
}
|
||
if (editButton) {
|
||
const showEdit = !!file.editable && exists;
|
||
editButton.classList.toggle("hidden", !showEdit);
|
||
editButton.disabled = !showEdit;
|
||
}
|
||
});
|
||
}
|
||
|
||
async function loadMemory() {
|
||
hideBanner("memoryBanner");
|
||
|
||
const dirResponse = await fetch("/api/files?path=" + encodeURIComponent("/memory"), {
|
||
cache: "no-store",
|
||
});
|
||
|
||
if (!dirResponse.ok) {
|
||
if (dirResponse.status === 404) {
|
||
memoryContents = {};
|
||
memoryFilePresence = {};
|
||
MEMORY_FILES.forEach((file) => {
|
||
memoryContents[file.path] = "";
|
||
memoryFilePresence[file.path] = false;
|
||
});
|
||
memoryLoaded = true;
|
||
renderMemoryState();
|
||
return;
|
||
}
|
||
throw new Error((await dirResponse.text()) || t("memoryLoadError"));
|
||
}
|
||
|
||
const dirData = await dirResponse.json();
|
||
const entries = dirData.entries || [];
|
||
const entryNames = new Set(entries.map((entry) => entry.name));
|
||
memoryContents = {};
|
||
memoryFilePresence = {};
|
||
|
||
for (const file of MEMORY_FILES) {
|
||
const fileName = file.path.split("/").pop();
|
||
const exists = entryNames.has(fileName);
|
||
memoryFilePresence[file.path] = exists;
|
||
if (!exists) {
|
||
memoryContents[file.path] = "";
|
||
continue;
|
||
}
|
||
|
||
const response = await fetch("/files" + file.path, {
|
||
cache: "no-store",
|
||
});
|
||
if (!response.ok) {
|
||
throw new Error((await response.text()) || t("memoryLoadError"));
|
||
}
|
||
memoryContents[file.path] = await response.text();
|
||
}
|
||
|
||
memoryLoaded = true;
|
||
renderMemoryState();
|
||
}
|
||
|
||
async function refreshMemory(options = {}) {
|
||
const { showSuccessBanner = true } = options;
|
||
const button = document.getElementById("refreshMemoryButton");
|
||
button.disabled = true;
|
||
hideBanner("memoryBanner");
|
||
|
||
try {
|
||
await loadMemory();
|
||
if (showSuccessBanner) {
|
||
showBanner("memoryBanner", t("memoryRefreshed"));
|
||
}
|
||
} catch (err) {
|
||
showBanner("memoryBanner", err.message || t("memoryLoadError"), true);
|
||
throw err;
|
||
} finally {
|
||
button.disabled = false;
|
||
}
|
||
}
|
||
|
||
async function refreshMemoryFile(path) {
|
||
hideBanner("memoryBanner");
|
||
|
||
const file = MEMORY_FILES.find((item) => item.path === path);
|
||
if (!file) return;
|
||
|
||
try {
|
||
const response = await fetch("/files" + file.path, { cache: "no-store" });
|
||
if (response.status === 404) {
|
||
memoryFilePresence[file.path] = false;
|
||
memoryContents[file.path] = "";
|
||
} else if (!response.ok) {
|
||
throw new Error((await response.text()) || t("memoryLoadError"));
|
||
} else {
|
||
memoryFilePresence[file.path] = true;
|
||
memoryContents[file.path] = await response.text();
|
||
}
|
||
renderMemoryState();
|
||
} catch (err) {
|
||
showBanner("memoryBanner", err.message || t("memoryLoadError"), true);
|
||
}
|
||
}
|
||
|
||
/* ═══════════════════════════════════════════════════
|
||
Event binding
|
||
═══════════════════════════════════════════════════ */
|
||
|
||
function bindEvents() {
|
||
initTabs();
|
||
document
|
||
.getElementById("capabilitySelectAllButton")
|
||
.addEventListener("click", () => setAllCapabilityCheckboxes(true));
|
||
document
|
||
.getElementById("capabilityClearAllButton")
|
||
.addEventListener("click", () => setAllCapabilityCheckboxes(false));
|
||
document
|
||
.getElementById("capabilityLlmSelectDefaultsButton")
|
||
.addEventListener("click", () => setLlmVisibleSelection("defaults"));
|
||
document
|
||
.getElementById("capabilityLlmClearAllButton")
|
||
.addEventListener("click", () => setLlmVisibleSelection("clear"));
|
||
document
|
||
.getElementById("luaModuleSelectAllButton")
|
||
.addEventListener("click", () => setAllLuaModuleCheckboxes(true));
|
||
document
|
||
.getElementById("luaModuleClearAllButton")
|
||
.addEventListener("click", () => setAllLuaModuleCheckboxes(false));
|
||
|
||
document.getElementById("saveConfigButton").addEventListener("click", saveConfig);
|
||
|
||
document.getElementById("llm_provider_preset").addEventListener("change", (e) => {
|
||
applyProviderPreset(e.target.value);
|
||
});
|
||
|
||
["llm_backend_type", "llm_profile", "llm_base_url", "llm_auth_type"].forEach(
|
||
(field) => {
|
||
const input = document.getElementById(field);
|
||
if (input) input.addEventListener("input", syncProviderPreset);
|
||
}
|
||
);
|
||
|
||
document
|
||
.getElementById("wechatLoginStartButton")
|
||
.addEventListener("click", startWechatLogin);
|
||
document
|
||
.getElementById("wechatLoginCancelButton")
|
||
.addEventListener("click", cancelWechatLogin);
|
||
|
||
document.getElementById("refreshFilesButton").addEventListener("click", () =>
|
||
loadFiles().catch((err) => showBanner("fileBanner", err.message, true))
|
||
);
|
||
document.getElementById("devModeButton").addEventListener("click", () => {
|
||
const nextEnabled = !isFileDevModeEnabled();
|
||
if (nextEnabled && !window.confirm(t("fileDevModeConfirm"))) {
|
||
return;
|
||
}
|
||
setFileDevMode(nextEnabled);
|
||
});
|
||
document.getElementById("upDirButton").addEventListener("click", () => {
|
||
currentPath = parentPath(currentPath);
|
||
loadFiles().catch((err) => showBanner("fileBanner", err.message, true));
|
||
});
|
||
document.getElementById("uploadButton").addEventListener("click", uploadFile);
|
||
document.getElementById("refreshMemoryButton").addEventListener("click", refreshMemory);
|
||
document.querySelectorAll(".memory-refresh-btn").forEach((button) => {
|
||
button.addEventListener("click", () => refreshMemoryFile(button.dataset.path));
|
||
});
|
||
document.querySelectorAll(".memory-edit-btn").forEach((button) => {
|
||
button.addEventListener("click", () => {
|
||
openMemoryEditor(button.dataset.path).catch((err) =>
|
||
showBanner("memoryBanner", err.message || t("fileEditorLoadError"), true)
|
||
);
|
||
});
|
||
});
|
||
document
|
||
.getElementById("closeFileEditorButton")
|
||
.addEventListener("click", closeFileEditorModal);
|
||
document
|
||
.getElementById("refreshFileEditorButton")
|
||
.addEventListener("click", refreshFileEditor);
|
||
document
|
||
.getElementById("saveFileEditorButton")
|
||
.addEventListener("click", saveFileEditor);
|
||
document.getElementById("fileEditorModal").addEventListener("click", (e) => {
|
||
if (e.target.id === "fileEditorModal") {
|
||
closeFileEditorModal();
|
||
}
|
||
});
|
||
document.getElementById("chooseFileButton").addEventListener("click", () => {
|
||
document.getElementById("uploadFileInput").click();
|
||
});
|
||
document.getElementById("createFolderButton").addEventListener("click", createFolder);
|
||
document.getElementById("uploadFileInput").addEventListener("change", (e) => {
|
||
const file = e.target.files[0];
|
||
const nameSpan = document.getElementById("selectedFileName");
|
||
if (file) {
|
||
document.getElementById("uploadPathInput").value = joinPath(
|
||
currentPath,
|
||
file.name
|
||
);
|
||
nameSpan.textContent = file.name;
|
||
} else {
|
||
nameSpan.textContent = t("fileNoFileSelected");
|
||
}
|
||
});
|
||
}
|
||
|
||
/* ═══════════════════════════════════════════════════
|
||
Bootstrap
|
||
═══════════════════════════════════════════════════ */
|
||
|
||
async function bootstrap() {
|
||
fileDevModeEnabled = false;
|
||
capabilityItems = [];
|
||
pendingEnabledCapGroups = "";
|
||
pendingLlmVisibleCapGroups = "";
|
||
luaModuleItems = [];
|
||
pendingEnabledLuaModules = "";
|
||
currentLang = detectLang();
|
||
applyI18n();
|
||
buildLocaleMenu();
|
||
bindEvents();
|
||
updateFileDevModeUI();
|
||
|
||
try {
|
||
await loadStatus();
|
||
} catch (err) {
|
||
showBanner("configBanner", err.message || "Failed to load device status", true);
|
||
}
|
||
|
||
try {
|
||
await loadCapabilities();
|
||
} catch (err) {
|
||
showBanner("configBanner", err.message || t("capabilityLoadError"), true);
|
||
}
|
||
|
||
try {
|
||
await loadLuaModules();
|
||
} catch (err) {
|
||
showBanner("configBanner", err.message || t("luaModuleLoadError"), true);
|
||
}
|
||
|
||
try {
|
||
await loadConfig();
|
||
} catch (err) {
|
||
showBanner("configBanner", err.message || "Failed to load settings", true);
|
||
}
|
||
|
||
try {
|
||
await pollWechatLoginStatus();
|
||
} catch (err) {
|
||
showBanner(
|
||
"wechatLoginBanner",
|
||
err.message || "Failed to load WeChat login status",
|
||
true
|
||
);
|
||
}
|
||
|
||
try {
|
||
await loadFiles();
|
||
} catch (err) {
|
||
showBanner("fileBanner", err.message || "Failed to load file list", true);
|
||
}
|
||
|
||
if (document.querySelector('.tab-btn[data-tab="memory"]')?.classList.contains("active")) {
|
||
try {
|
||
await loadMemory();
|
||
} catch (err) {
|
||
showBanner("memoryBanner", err.message || t("memoryLoadError"), true);
|
||
}
|
||
} else {
|
||
renderMemoryState();
|
||
}
|
||
}
|
||
|
||
bootstrap().catch((err) => {
|
||
showBanner("configBanner", err.message || "Failed to initialize the page", true);
|
||
});
|