/* #!name=极核 ZEEHO 签到面板 V2.16.11 #!desc=极核ZEEHO多账号签到面板 + 网页配置，访问 http://zeeho.box #!author=lucky #!homepage=https://github.com/cluck798/ZEEHO #!version=2.16.11 图标: https://cdn.jsdelivr.net/gh/cluck798/ZEEHO@main/ZEEHO.png [Script] # ========== 极核 ZEEHO ========== # 面板 + 极核API自动捕获appId/appSecret http-request ^https?://(zeeho\.box|.*zeehoev\.com)/.* script-path=https://raw.githubusercontent.com/cluck798/ZEEHO/refs/heads/main/repo/zeeho_box_enhanced.js?v=2.16.11, requires-body=true, timeout=60, tag=极核面板V2.16.11 # 车辆图片替换（v2.16.11：http-response 直改响应体图片 URL，需在面板设置页配置） http-response ^https:\/\/tapi\.zeehoev\.com\/v1\.0\/app\/cfmotoserverapp\/(vehicle\/(list|widgets|details)|vehicleHomePageV2|vehicleInfo|vehicle\/properties) script-path=https://raw.githubusercontent.com/cluck798/ZEEHO/refs/heads/main/repo/zeeho_box_enhanced.js?v=2.16.11, timeout=30, tag=车辆图片改写 # 极核Token自动捕获（打开极核App-我的页面） http-response ^https:\/\/tapi\.zeehoev\.com\/v1\.0\/mine\/cfmotoservermine\/setting script-path=https://raw.githubusercontent.com/cluck798/ZEEHO/refs/heads/main/repo/zeeho.js, requires-body=true, timeout=30, tag=极核抓Token # 极核每日签到（每天7点） cron "0 7 * * *" script-path=https://raw.githubusercontent.com/cluck798/ZEEHO/refs/heads/main/repo/zeeho.js, timeout=120, tag=极核每日签到 [MITM] hostname = tapi.zeehoev.com, h5.zeehoev.com, zeeho.box ==================================== ⚠️【免责声明】 ------------------------------------------ 1、此脚本仅用于学习研究，不保证其合法性、准确性、有效性，请根据情况自行判断，本人对此不承担任何保证责任。 2、由于此脚本仅用于学习研究，您必须在下载后 24 小时内将所有内容从您的计算机或手机或任何存储设备中完全删除，若违反规定引起任何事件本人对此均不负责。 3、请勿将此脚本用于任何商业或非法目的，若违反规定请自行对此负责。 4、此脚本涉及应用与本人无关，本人对因此引起的任何隐私泄漏或其他后果不承担任何责任。 5、本人对任何脚本引发的问题概不负责，包括但不限于由脚本错误引起的任何损失和损害。 6、如果任何单位或个人认为此脚本可能涉嫌侵犯其权利，应及时通知并提供身份证明，所有权证明，我们将在收到认证文件确认后删除此脚本。 7、所有直接或间接使用、查看此脚本的人均应该仔细阅读此声明。本人保留随时更改或补充此声明的权利。一旦您使用或复制了此脚本，即视为您已接受此免责声明。 */ const $ = new Env("极核看板增强版"); // ========== 极核 ZEEHO 签到面板脚本 ========== // 版本: v2.16.11 // 更新日期: 2026-10-17 // 作者: @lucky // 主页: https://github.com/cluck798/ZEEHO // ============================================ const SCRIPT_VERSION = "v2.16.11"; console.log(`🚀 [极核面板] 脚本版本: ${SCRIPT_VERSION} (2026-10-17 v2.16.11 车辆图片替换架构重构：放弃 http-request 转发改写（Loon 下 $httpClient 转发不可靠导致持续无效），改为新增 http-response 规则直改车辆接口响应体图片 URL——不转发、无 MITM 自拦截循环，插件/模块/SG 模块/QX 订阅均已附「车辆图片改写」响应规则，需重新订阅插件生效；v2.16.10 车辆图片替换修复：转发请求加 x-zeeho-bypass 旁路头，防止被自身 MITM 规则再次拦截导致改写静默失效（官方App无变化的根因）；接口覆盖扩至 vehicle/details·vehicleInfo·vehicle/properties；新增 [车辆图片] 已改写/未覆盖接口/转发失败 诊断日志（Loon 日志过滤「车辆图片」可见）；v2.16.9 新增「车辆图片替换」：设置页按车辆选官方车型图（含 AE5i 电轻摩版四色/自定义URL），面板 MITM 转发改写 vehicle/list·widgets·homePageV2 图片字段，官方App照片同步生效；v2.16.8 数据准确性修复：batteryInfo.batteryLevel 恒为100是电池健康标志非电量，soc 取数链改 soc→bmssoc（充电监控/充电剩余时间电量不再假100%）；v2.16.7 签到与盲盒修复：盲盒改走官方 POST /H5/signin/lottery?dateTime=<开盒日>（旧实现误用补签接口 supplementPrize → 40005 无效操作），开盒日以 info.signPrizeDate 为准；签到日历查询加 3 次退避重试（07:00 并发 WAF 瞬断导致误报 签到+0/连签0天）；连签天数以官方 GET /H5/signin 直出值为准；HTML 直连通道签到路径补迁 /H5/ 且 POST 签名含 body；v2.16.6 电池设置每车独立保存（旧数据自动迁移到当前车辆）+ 首页卡片显示充电剩余时间；v2.16.5 充电剩余时间：车辆页新增「电池设置」（容量Ah/满电V），充电中按 容量×(100−电量%)/100÷充电电流 估算剩余时间，并与官方 fullChargeTime 对照显示；新增 /api/battery-state 接口；充电功率 1200 档文案修正为「无限制」（下发值不变）；三端 Release 说明增加北京时间更新时间；v2.16.4 补签路径修复：consume/gain（补签、积分兑换）改走官方新路径 /cfmotoservermine/H5/signInSupplement（旧路径被 WAF 拦为 430/30125 permit error，实测 consume 旧路径 30125 → 新路径业务码）；v2.16.3 补签修复：POST /count 需将 body「{}」纳入签名（此前 430/30121，补签卡数量/补签报错）；抓取脚本 v2.5.2（Token 剥 Bearer、同 userId 只更新不新增、保留 barkKey）；面板账号读写自动归一（去 Bearer + 同 ID 合并自愈）；v2.16.2 版本检测加固：双源（raw+jsDelivr）并发取最高版本号，避免 jsDelivr 最长 12h 缓存导致「检查更新」误判已是最新；v2.16.1 修复「扫描轨迹」：ridetrack_v2 必须带 startTime=YYYY-MM（缺失时服务端恒返回空数组，HAR 实证），支持按历史月份扫描，行程明细增加起终点/服务端急加速/轨迹缩略图；v2.16.0 新增「骑行」页：隐藏骑行数据（极速/急加速/急刹/压弯，轨迹重算算法移植自 Zeeho SpeedHunter）；修复服务端对「带 query 的 GET」收紧导致的 430/30121（胎压/首页骑行/车况/积分明细/社区回查/轨迹扫描统一改 query 入签 + 官方格式随机 UA）；v2.15.6 H5 通道密钥/接口迁移 + 软件版本检测；v2.15.5 面板首屏提速)`); // 面板入口域名：Loon 用虚拟域名 zeeho.box（Loon 可虚拟劫持不存在的域名）， // QX 必须用真实可解析域名（默认 www.example.com，IANA 保留域名保证可解析）。 // 从当前请求自动推断，面板内绝对链接统一用 PANEL_HOST。 let PANEL_HOST = "http://zeeho.box"; // ========== 设备指纹修复（官方 App 被风控拉黑时自救） ========== // 背景：本模块早期版本把请求 UA 固定为同一台"设备"（含固定设备 UUID），该指纹被极核风控标记后， // 服务端对整套指纹返回 430 {"code":"31001","message":"非法的请求"}。若该指纹正好来自你自己的抓包， // 你的官方 App 发出同一指纹也会一起被拒（表现为官方 App 大面积报错）。 // 这里在放行官方 App 请求前检测被拉黑的指纹，命中则把 user-agent / x-app-info 换成一份"仅本机生成一次"的 // 新指纹（请求签名不含 UA，不影响 cfmoto-x-sign）；正常设备不受影响。 const BURNED_DEVICE_MARK = "DC0C4906-A4A8-4866-9432-B31E1E252D53"; // 已被服务端拉黑的固定设备 UUID（历史模板） function repairBurnedDevice(headers) { try { let ua = "", xapp = ""; Object.keys(headers || {}).forEach(function(k) { const lk = String(k).toLowerCase(); if (lk === "user-agent") ua = String(headers[k] || ""); if (lk === "x-app-info") xapp = String(headers[k] || ""); }); if (ua.indexOf(BURNED_DEVICE_MARK) < 0 && xapp.indexOf(BURNED_DEVICE_MARK) < 0) return null; // 修复指纹：生成一次后写入持久化，同一台设备保持一致（避免"每次请求换设备"的会话异常） let fix = null; try { fix = JSON.parse($persistentStore.read("zeeho_fix_device_ua") || "null"); } catch(e) {} if (!fix || !fix.ua) { const models = [["iPhone 15", "1179*2556"], ["iPhone 15 Pro", "1179*2556"], ["iPhone 15 Pro Max", "1290*2796"], ["iPhone 14", "1170*2532"], ["iPhone 14 Pro", "1179*2556"], ["iPhone 13", "1170*2532"], ["iPhone 12", "1170*2532"], ["iPhone 11", "828*1792"]]; const vers = ["17.4.1", "17.5.1", "17.6.1", "18.0", "18.1.1", "18.3.1"]; const m = models[Math.floor(Math.random() * models.length)]; const v = vers[Math.floor(Math.random() * vers.length)]; let hex = ""; const H = "0123456789ABCDEF"; for (let i = 0; i < 32; i++) hex += H[Math.floor(Math.random() * 16)]; const uuid = hex.slice(0, 8) + "-" + hex.slice(8, 12) + "-" + hex.slice(12, 16) + "-" + hex.slice(16, 20) + "-" + hex.slice(20); fix = { ua: "MOBILE|iOS|" + v + "|ZEEHO_APP|3.0.5|iPhone|" + m[0] + "|" + m[1] + "|" + uuid + "|" + (/WiFi/.test(ua) ? "WiFi" : "WWAN") + "|iOS" }; try { $persistentStore.write(JSON.stringify(fix), "zeeho_fix_device_ua"); } catch(e) {} console.log("[极核修复] 命中被拉黑设备指纹，已生成新指纹: " + m[0] + " / iOS " + v); } const out = {}; Object.keys(headers || {}).forEach(function(k) { const lk = String(k).toLowerCase(); out[k] = (lk === "user-agent" || lk === "x-app-info") ? fix.ua : headers[k]; }); return out; } catch(e) { return null; } } // ========== 自动捕获 appId/appSecret ========== // 匹配规则需同时覆盖 zeeho.box 和极核API：^https?://(zeeho\\.box|.*zeehoev\\.com)/.* // 打开极核App时，API请求被拦截 → 自动提取appId保存 → 放行请求（放行前会做设备指纹修复检查） (async function autoCapture() { try { const url = $request.url; // 只处理极核API请求（zeehoev.com），zeeho.box 走面板逻辑 if (!url.includes('zeehoev.com')) return; // v2.16.11 http-response 上下文：直接改写车辆接口响应体里的图片 URL（不转发，从根本消除 MITM 自拦截循环） if (typeof $response !== "undefined" && $response) { try { picRewriteResponse(url); } catch (e) { console.log("[车辆图片] 响应改写异常，放行:", e); $done({}); } return true; } const headers = $request.headers; const param = headers['cfmoto-x-param'] || headers['Cfmoto-X-Param'] || headers['CFMOTO-X-PARAM'] || ''; const match = param.match(/appId=([^&]+)/i); if (match) { const appId = match[1]; const type = url.includes('h5.zeehoev.com') ? 'h5' : 'app'; const typeName = type === 'h5' ? 'H5端' : 'App端'; // 已知的 appSecret（无法从请求自动捕获，需手动配置） // v2.15.6：H5 通道轮换为新 appId（AiTXmBrm）；旧 Sw5F9uJi 已失效（430 permit error） const knownSecrets = { 'AiTXmBrm': '70c2c7458ab88ca9504ad0521f170075bc91f2f7', 'Sw5F9uJi': '46870a8f678a09109468f5b0168818b91c292845', 'S7qPWPU1': 'c5e0da7f4da28df805694ec3dd1fc6792e9df99d' }; const appSecret = knownSecrets[appId] || ''; // 保存到 $persistentStore const idKey = type === 'h5' ? 'zeeho_h5_appId' : 'zeeho_app_appId'; const secretKey = type === 'h5' ? 'zeeho_h5_appSecret' : 'zeeho_app_appSecret'; const savedId = $persistentStore.read(idKey); if (savedId !== appId) { $persistentStore.write(appId, idKey); if (appSecret) $persistentStore.write(appSecret, secretKey); console.log('[极核捕获] ' + typeName + ' appId已保存: ' + appId); } } // 设备指纹修复：官方 App 若携带已被拉黑的指纹（本模块历史模板），换成新的本机指纹后再放行 const fixedHeaders = repairBurnedDevice(headers); if (fixedHeaders) { $done({ headers: fixedHeaders }); return true; // 标记已处理，阻止后续面板逻辑执行 } // ⚠️ 关键：捕获完成后必须放行请求，否则极核App会卡住 $done({}); return true; // 标记已处理，阻止后续面板逻辑执行 } catch(e) { console.log('[极核捕获] 异常:', e); $done({}); return true; } })(); // ========== 存储键名 ========== const CK_CONFIG = "zeeho_config"; const CK_DATA = "zeeho_data"; const CK_LOGS = "zeeho_logs"; // ========== 默认配置 ========== // 看板自动刷新间隔(秒)规范化：最小15秒、最大3600秒，0/非法/缺失一律回退60秒，避免配置成0导致疯狂刷新 function normalizeRefreshSec(v) { const n = Number(v); if (!isFinite(n) || n <= 0) return 60; return Math.max(15, Math.min(3600, Math.round(n))); } const DEFAULT_CONFIG = { app: { appId: "S7qPWPU1", appSecret: "c5e0da7f4da28df805694ec3dd1fc6792e9df99d" }, // v2.15.6：H5 通道密钥轮换（服务端换发，旧值一律 430 permit error） h5: { appId: "AiTXmBrm", appSecret: "70c2c7458ab88ca9504ad0521f170075bc91f2f7" }, community: { enablePost: true, enableLike: true, enableComment: true, enableShare: true, enableDelete: true }, vehicleAesKey: "ce2cd7cb57124c1349dd8543bf6fd31d", // 云端开/关锁AES-256-ECB密钥(32位)。已内置默认密钥，可在配置页修改 vehicleControlRisk: "", // 车控风险确认：需在设置页填写「我自愿承担相关风险」并保存后才能使用车控功能 autoRefreshSec: 60, // 看板首页自动刷新间隔(秒)，配置页可改；规范化见 normalizeRefreshSec pics: {} // v2.16.9 车辆图片替换：{ "": "<图片URL>" }，设置页配置，仅面板 MITM 环境生效 }; // ========== v2.15.6 H5 通道密钥强制迁移 ========== // 服务端换发新 appId/appSecret，旧值（Sw5F9uJi 等）一律 430 permit error。 // 历史配置（CK_CONFIG / persistentStore / 默认值）在首次运行时统一迁移到新密钥； // 迁移后仍可在配置页手动修改（__h5CredVer 标记保证不会被反复覆盖，除非再次升级凭据版本）。 const H5_CRED_VERSION = "2.15.6"; const H5_FIXED_CRED = { appId: "AiTXmBrm", appSecret: "70c2c7458ab88ca9504ad0521f170075bc91f2f7" }; function h5Fix(c, storeH5) { if (c && c.__h5CredVer !== H5_CRED_VERSION) { c.h5 = { appId: H5_FIXED_CRED.appId, appSecret: H5_FIXED_CRED.appSecret }; c.__h5CredVer = H5_CRED_VERSION; try { $.setdata(JSON.stringify(c), CK_CONFIG); } catch(e) {} console.log('[H5密钥迁移] 已强制更换为新 appId: ' + H5_FIXED_CRED.appId); } if (c && c.h5 && c.h5.appId) return { appId: c.h5.appId, appSecret: c.h5.appSecret || H5_FIXED_CRED.appSecret }; // 无看板配置：捕获值已失效，直接用固定新密钥 return { appId: H5_FIXED_CRED.appId, appSecret: H5_FIXED_CRED.appSecret }; } // ========== 版本信息 ========== // ========== 配置读写 ========== function getConfig() { // 从捕获脚本保存的 $persistentStore 读取（zeeho_h5_appId / zeeho_app_appId） let storeApp = { appId: '', appSecret: '' }; let storeH5 = { appId: '', appSecret: '' }; try { storeApp.appId = $persistentStore.read('zeeho_app_appId') || ''; storeApp.appSecret = $persistentStore.read('zeeho_app_appSecret') || ''; storeH5.appId = $persistentStore.read('zeeho_h5_appId') || ''; storeH5.appSecret = $persistentStore.read('zeeho_h5_appSecret') || ''; } catch(e) {} try { const raw = $.getdata(CK_CONFIG); if (raw) { const c = JSON.parse(raw); return { // 优先级：看板配置 > 捕获脚本 > 默认值 app: { appId: c.app?.appId || storeApp.appId || DEFAULT_CONFIG.app.appId, appSecret: c.app?.appSecret || storeApp.appSecret || DEFAULT_CONFIG.app.appSecret }, h5: h5Fix(c, storeH5), community: { enablePost: c.community?.enablePost !== false, enableLike: c.community?.enableLike !== false, enableComment: c.community?.enableComment !== false, enableShare: c.community?.enableShare !== false, enableDelete: c.community?.enableDelete !== false }, vehicleAesKey: ((typeof c.vehicleAesKey === "string" ? c.vehicleAesKey : "").trim() || DEFAULT_CONFIG.vehicleAesKey), vehicleControlRisk: (typeof c.vehicleControlRisk === "string" ? c.vehicleControlRisk : "").trim(), autoRefreshSec: normalizeRefreshSec(c.autoRefreshSec), basicAuth: (typeof c.basicAuth === "string" ? c.basicAuth : "").trim(), vehicleMonitor: c.vehicleMonitor === true, autoSignin: c.autoSignin === true, autoSigninTime: (typeof c.autoSigninTime === "string" && /^\d{1,2}:\d{2}$/.test(c.autoSigninTime) ? c.autoSigninTime : "07:00"), widgetVehicle: (typeof c.widgetVehicle === "string" ? c.widgetVehicle : ""), pics: (c.pics && typeof c.pics === "object") ? c.pics : {} }; } } catch(e) {} // 看板无配置时，使用捕获脚本配置 + 默认值（H5 密钥固定为新值：捕获值已失效） return { app: { appId: storeApp.appId || DEFAULT_CONFIG.app.appId, appSecret: storeApp.appSecret || DEFAULT_CONFIG.app.appSecret }, h5: { appId: H5_FIXED_CRED.appId, appSecret: H5_FIXED_CRED.appSecret }, community: JSON.parse(JSON.stringify(DEFAULT_CONFIG.community)), vehicleAesKey: DEFAULT_CONFIG.vehicleAesKey, vehicleControlRisk: "", autoRefreshSec: 60, basicAuth: "", vehicleMonitor: false, autoSignin: false, autoSigninTime: "07:00", widgetVehicle: "" }; } function saveConfig(cfg) { try { $.setdata(JSON.stringify(cfg), CK_CONFIG); return true; } catch(e) { return false; } } // ========== 账号读写 ========== // v2.16.3 账号归一：①token 统一剥离 Bearer 前缀；②同一 userId 合并为一条。 // 背景：抓取脚本(script/zeeho.js)与面板双写 zeeho_data，历史版本抓取把「Bearer xxx」原样入库， // 且同人条目可能重复；此处在读/写两侧自愈（合并时保留先前的非空 barkKey，token/昵称取较新值）。 function normalizeAccounts(list) { const out = []; const byId = new Map(); for (const a0 of (Array.isArray(list) ? list : [])) { if (!a0 || typeof a0 !== "object") continue; const a = Object.assign({}, a0, { token: cleanToken(a0.token || "") }); const uid = String(a.userId || "").trim(); if (uid && byId.has(uid)) { const old = byId.get(uid); Object.assign(old, a, { barkKey: old.barkKey || a.barkKey || "" }); } else { out.push(a); if (uid) byId.set(uid, a); } } return out; } function getAccounts() { try { const raw = $.getdata(CK_DATA); if (raw) { const arr = JSON.parse(raw); return normalizeAccounts(Array.isArray(arr) ? arr : [arr]); } } catch(e) {} return []; } function saveAccounts(list) { try { $.setdata(JSON.stringify(normalizeAccounts(list)), CK_DATA); return true; } catch(e) { return false; } } // ========== 运行日志 ========== function getLogs() { try { const raw = $.getdata(CK_LOGS); if (raw) { const arr = JSON.parse(raw); return Array.isArray(arr) ? arr : []; } } catch(e) {} return []; } function addLog(entry) { try { const logs = getLogs(); logs.unshift(entry); if (logs.length > 50) logs.length = 50; $.setdata(JSON.stringify(logs), CK_LOGS); return true; } catch(e) { return false; } } function clearLogs() { try { $.setdata("[]", CK_LOGS); return true; } catch(e) { return false; } } // ========== 工具函数 ========== function getUuid() { const p = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx", c = "abcdef0123456789"; let r = ""; for (const ch of p) { if (ch === "x" || ch === "y") { const n = Math.floor(Math.random() * 16); r += (ch === "y" ? (n & 0x3) | 0x8 : n).toString(16); } else r += ch; } return r; } function getRandomChars(n = 16) { const c = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; let r = ""; for (let i = 0; i < n; i++) r += c.charAt(Math.floor(Math.random() * c.length)); return r; } function toQuery(p = {}) { return Object.keys(p).filter(k => p[k] !== undefined && p[k] !== null).sort() .map(k => `${k}=${p[k]}`).join("&"); } function cleanToken(t) { return String(t || "").trim().replace(/^[bB]earer\s+/i, "").replace(/[\s"'`]+/g, ""); } // 清洗 Bark Key：官方完整链接 https://api.day.app/xxx 只保留 xxx；纯Key原样；自建服务器完整地址保留 function cleanBarkKey(k) { let s = String(k || "").trim().replace(/^[bB]ark\s*(key)?\s*[:：]\s*/i, "").replace(/[\s"'`]+/g, "").trim(); s = s.replace(/^https?:\/\/api\.day\.app\//i, ""); return s.replace(/\/+$/, ""); } // 车架号脱敏：保留前3位+后4位，中间打码（默认不展示完整VIN，点击按钮才显示） function maskVin(v) { const s = String(v || ""); if (!s) return ""; if (s.length <= 7) return "****"; return s.substring(0, 3) + "****" + s.substring(s.length - 4); } // ========== md5 / sha1 ========== function md5(t,e){function n(t,e){return t<>>32-e}function r(t,e){var n,r,o,i,a;return o=2147483648&t,i=2147483648&e,a=(1073741823&t)+(1073741823&e),(n=1073741824&t)&(r=1073741824&e)?2147483648^a^o^i:n|r?1073741824&a?3221225472^a^o^i:1073741824^a^o^i:a^o^i}function o(t,e,o,i,a,u,c){return t=r(t,r(r(function(t,e,n){return t&e|~t&n}(e,o,i),a),c)),r(n(t,u),e)}function i(t,e,o,i,a,u,c){return t=r(t,r(r(function(t,e,n){return t&n|e&~n}(e,o,i),a),c)),r(n(t,u),e)}function a(t,e,o,i,a,u,c){return t=r(t,r(r(function(t,e,n){return t^e^n}(e,o,i),a),c)),r(n(t,u),e)}function u(t,e,o,i,a,u,c){return t=r(t,r(r(function(t,e,n){return e^(t|~n)}(e,o,i),a),c)),r(n(t,u),e)}function c(t){var e,n="",r="";for(e=0;e<=3;e++)n+=(r="0"+(t>>>8*e&255).toString(16)).substr(r.length-2,2);return n}var s,l,f,p,d,h,v,y,g,m=Array();for(m=function(t){for(var e,n=t.length,r=n+8,o=16*((r-r%64)/64+1),i=Array(o-1),a=0,u=0;u>>29,i}(t=function(t){t=t.replace(/\r\n/g,"\n");for(var e="",n=0;n127&&r<2048?(e+=String.fromCharCode(r>>6|192),e+=String.fromCharCode(63&r|128)):(e+=String.fromCharCode(r>>12|224),e+=String.fromCharCode(r>>6&63|128),e+=String.fromCharCode(63&r|128))}return e}(t)),h=1732584193,v=4023233417,y=2562383102,g=271733878,s=0;s>>(32-s));return t4};function cvt_hex(val){var str='';var i;var v;for(i=7;i>=0;i--){v=(val>>>(i*4))&0x0f;str+=v.toString(16)}return str};function Utf8Encode(string){string=string.replace(/\r\n/g,'\n');var utftext='';for(var n=0;n127)&&(c<2048)){utftext+=String.fromCharCode((c>>6)|192);utftext+=String.fromCharCode((c&63)|128)}else{utftext+=String.fromCharCode((c>>12)|224);utftext+=String.fromCharCode(((c>>6)&63)|128);utftext+=String.fromCharCode((c&63)|128)}}return utftext};var blockstart;var i,j;var W=new Array(80);var H0=0x67452301;var H1=0xEFCDAB89;var H2=0x98BADCFE;var H3=0x10325476;var H4=0xC3D2E1F0;var A,B,C,D,E;var temp;msg=Utf8Encode(msg);var msg_len=msg.length;var word_array=new Array();for(i=0;i>>29);word_array.push((msg_len<<3)&0x0ffffffff);for(blockstart=0;blockstart|ZEEHO_APP|<版本>|iPhone|<机型>|<分辨率>|<设备UUID>|<网络>|iOS // short 格式（旧版客户端）：MOBILE|iOS|<系统>|ZEEHO_APP|3.0.1|iPhone|<网络>|iOS function randomDeviceUA(short) { const net = Math.random() < 0.7 ? "WWAN" : "WIFI"; if (short) return `MOBILE|iOS|${pickRandomDevice(IOS_VERSIONS)}|ZEEHO_APP|3.0.1|iPhone|${net}|iOS`; const m = pickRandomDevice(DEVICE_MODELS); return `MOBILE|iOS|${pickRandomDevice(IOS_VERSIONS)}|ZEEHO_APP|${ZEEHO_APP_UA_VERSION}|iPhone|${m[0]}|${m[1]}|${randomDeviceUuid()}|${net}|iOS`; } function socialSign(queryStr, bodyStr, cfg) { const c = cfg || getConfig(); const ac = c.app; const timestamp = new Date().getTime(); const nonce = timestamp + getRandomChars(16); const param = `appId=${ac.appId}&nonce=${nonce}×tamp=${timestamp}`; const sign = md5(sha1((queryStr || "") + (bodyStr || "") + param + ac.appSecret), 32).toString(); return { 'cfmoto-x-param': param, 'cfmoto-x-sign': sign, 'cfmoto-x-sign-type': '0', 'timestamp': String(timestamp), 'nonce': nonce, 'signature': sign }; } function socialHeaders(token, userId, queryStr, bodyStr, cfg) { const c = cfg || getConfig(); const ua = randomDeviceUA(); // 每次请求换一套随机设备指纹，避免固定指纹被风控标记后持续 31001 return { "content-type": "application/json", "appid": c.app.appId, "authorization": `Bearer ${token}`, "accept": "*/*", "accept-language": "zh-CN", "user-agent": ua, "interfaceversion": "2", "x-app-info": ua, "cookie": `user_id=${userId}`, ...socialSign(queryStr, bodyStr, cfg) }; } // ========== v2.16.0 「带 query 的 GET」统一新协议（服务端已收紧：UA + query 不入签直接 430/30121） ========== // 实证（2026-10-11，真实账号逐一比对）：带旧短格式 UA（…ZEEHO_APP|3.0.1|iPhone|WWAN|iOS）时， // tire/monitoring、homeRideInfo、myRideInfo、ridetrack_v2、vehicleHomePageV2、 // vehicles/properties/snapshots、integral/detail、mineArticleInfo、myCoupons、activityPrizeRecord、 // ota/list 等「URL 带 query」的 GET 一律要求 md5(sha1(query+param+secret))（query 原文入签）； // 无 query 的接口（vehicle/list、setting、batteryInfo、signin/count 等）不受影响。 // 统一改走官方全格式随机 UA + query 入签（与社交写操作同一套头），最严路径实测全部放行。 function appQueryGetHeaders(acc, queryStr, cfg) { const h = socialHeaders(cleanToken(acc.token), acc.userId, queryStr || "", "", cfg); if (!acc.userId) delete h.cookie; // 无 userId 时不下发空 cookie return h; } // ========== HTTP 请求 ========== // 响应解析：token 失效时网关返回 XML（），明确提示以便用户重新登录 function parseResp(body) { try { return JSON.parse(body); } catch(e) { if (/invalid_token/i.test(String(body))) return { error: "token已失效，请重新登录" }; return { error: "parse error", raw: body }; } } function httpGet(url, headers) { return new Promise((resolve) => { const isQX = typeof $task !== "undefined"; if (isQX) { $task.fetch({ url, headers, method: "GET" }).then( function(resp) { resolve(parseResp(resp.body)); }, function(err) { resolve({ error: String(err && err.error || err || "request failed") }); } ); } else { $httpClient.get({ url, headers }, function(err, resp, body) { if (err) { resolve({ error: String(err) }); return; } resolve(parseResp(body)); }); } }); } // ========== v2.16.11 车辆图片替换：http-response 上下文直改响应体（不转发，杜绝 MITM 自拦截循环） ========== function picRewriteResponse(url) { const short = (String(url).split("cfmotoserverapp/")[1] || String(url)).slice(0, 80); const pics = (getConfig() || {}).pics || {}; if (!Object.keys(pics).length) { $done({}); return; } if (!new RegExp("tapi[.]zeehoev[.]com/v1[.]0/app/cfmotoserverapp/(vehicle/(list|widgets|details)|vehicleHomePageV2|vehicleInfo|vehicle/properties)").test(url)) { $done({}); return; } const st = Number($response.status || $response.statusCode || 0); const body = $response.body; let obj = null; if (st === 200 && typeof body === "string" && body) { try { obj = JSON.parse(body); } catch (e) {} } if (!obj || !obj.data) { console.log("[车辆图片] 响应不可解析 status=" + st + " url=" + short); $done({}); return; } const n = rewritePicUrls(obj, pics); if (n > 0) { console.log("[车辆图片] 响应已改写 " + n + " 字段 url=" + short); const nb = JSON.stringify(obj); if (typeof $task !== "undefined") $done({ body: nb }); else $done({ response: { body: nb } }); } else { console.log("[车辆图片] 命中接口但无配置VIN url=" + short); $done({}); } } // 命中 VIN 配置的替换 vehiclePicUrl / vehicleScalePicUrl，返回改写条数 function rewritePicUrls(obj, pics) { let n = 0; const items = Array.isArray(obj.data) ? obj.data : (obj.data && typeof obj.data === "object" ? [obj.data] : []); for (const it of items) { if (!it || typeof it !== "object") continue; const vin = String(it.vinNo || it.vin || "").trim(); const u = vin ? pics[vin] : ""; if (!u) continue; if (it.vehiclePicUrl !== undefined) { it.vehiclePicUrl = u; n++; } if (it.vehicleScalePicUrl !== undefined) { it.vehicleScalePicUrl = u; n++; } } return n; } // ========== 单账号 Bark 推送（仅该账号签到成功后通知） ========== // barkKey 支持两种填法：①只填 Bark App 内的 Key（走官方 https://api.day.app）；②自建服务器完整地址 https://域名/Key function barkPush(barkKey, title, body) { try { const k = cleanBarkKey(barkKey); if (!k) return Promise.resolve({ skipped: true }); let base = "https://api.day.app"; let key = k; const m = k.match(/^(https?:\/\/[^/]+)\/(.+)$/i); if (m) { base = m[1]; key = m[2]; } // 自建服务器 key = key.replace(/^\/+/, ""); const u = base + "/" + encodeURIComponent(key) + "/" + encodeURIComponent(title) + "/" + encodeURIComponent(body) + "?group=ZEEHO&sound=birdsong"; return httpGet(u, {}); } catch(e) { return Promise.resolve({ error: String(e) }); } } // ========== 统一通知桥（v2.14.9） ========== // 优先原生本地通知 $notification（Loon 自带 / iOS App 与桌面版注入），失败回退全局 Bark function notifyPush(title, body, cfg) { try { if (typeof $notification !== "undefined" && $notification && typeof $notification.post === "function") { $notification.post(String(title), "", String(body || "")); return; } } catch(e) {} try { const c = cfg || getConfig(); if (c.globalBarkKey && String(c.globalBarkKey).trim()) barkPush(c.globalBarkKey, title, body); } catch(e) {} } // ========== Token 状态检测 ========== async function checkToken(acc, cfg) { try { const token = cleanToken(acc.token); const userId = acc.userId || ""; // userId 为空时不检测，直接认为有效（避免误判） if (!userId) { return { valid: true, score: 0, userName: acc.userName }; } const signH = getSign("app", {}, '', cfg); const headers = { "Authorization": `Bearer ${token}`, "Content-Type": "application/json;charset=UTF-8", "interfaceversion": "2", "user_id": userId, ...signH }; const res = await httpGet( `https://tapi.zeehoev.com/v1.0/mine/cfmotoservermine/setting/${userId}`, headers ); if (res.code == "10000" && res.data) { return { valid: true, score: Number(res.data.score) || 0, userName: res.data.nickName || acc.userName }; } if (res.code == "40001" || res.code == 401) { return { valid: false, reason: "token已过期" }; } // 其他错误不判定为失效，避免网络问题误判 return { valid: true, reason: res.message || "请求异常" }; } catch(e) { // 异常不判定为失效 return { valid: true, reason: String(e) }; } } // ========== 手动执行签到（单账号） ========== async function runSigninForAccount(acc, cfg) { const result = { userName: acc.userName || "未知", userId: acc.userId, success: false, signinScore: 0, blindBoxScore: 0, interactScore: 0, totalGain: 0, continueDays: 0, error: null, steps: [] }; try { const token = cleanToken(acc.token); const userId = acc.userId || ""; const baseHeaders = { "Authorization": `Bearer ${token}`, "Content-Type": "application/json;charset=UTF-8", "interfaceversion": "2", "user_id": userId }; const today = new Date().getFullYear() + "-" + String(new Date().getMonth()+1).padStart(2,"0") + "-" + String(new Date().getDate()).padStart(2,"0"); const month = today.slice(0,7); // v2.16.7 info 查询带退避重试（07:00 多账号并发易触发 WAF 瞬断，此前无重试导致误报 +0/连签0） async function getInfoRetry() { let last = null; for (let t = 1; t <= 3; t++) { last = await httpGet(`https://h5.zeehoev.com/cfmotoservermine/H5/signin/info?month=${month}`, { ...baseHeaders, ...getSign("h5", { month }, '', cfg) }); if (last && String(last.code) === "10000") return last; if (t < 3) await new Promise(r => setTimeout(r, t * 1500)); } return last; } // 1. 签到 try { const infoRes = await getInfoRetry(); const todayEntry = (infoRes?.data?.nowSignDetailVos || []).find(x => x.createDate === today); // signStatue: 3/5=已签到, 0=盲盒开启日（已签到+已开盒）, 4=漏签, 2=未来 if (todayEntry && (todayEntry.signStatue == 3 || todayEntry.signStatue == 5 || todayEntry.signStatue == 0)) { result.steps.push("今日已签到"); } else { // 多账号连签易触发“请稍后/操作频繁”限流，退避后最多重试3次 let signRes = null, signMsg = "未知"; for (let at = 1; at <= 3; at++) { signRes = await httpPost(`https://h5.zeehoev.com/cfmotoservermine/H5/signin`, { ...baseHeaders, ...getSign("h5", {}, {}, cfg) }, {}); if (signRes?.code == "10000") break; signMsg = signRes?.message || signRes?.error || "未知"; if (/请稍|稍后|稍候|频繁|繁忙|重试/.test(signMsg) && at < 3) { await new Promise(r => setTimeout(r, (at + 1) * 2000)); continue; } break; } if (signRes?.code == "10000") { const infoRes2 = await httpGet(`https://h5.zeehoev.com/cfmotoservermine/H5/signin/info?month=${month}`, { ...baseHeaders, ...getSign("h5", { month }, '', cfg) }); const te = (infoRes2?.data?.nowSignDetailVos || []).find(x => x.createDate === today); result.signinScore = te ? (Number(te.integralScore) || 0) : 0; result.steps.push(`签到成功 +${result.signinScore}`); } else { // 重试后仍未成功：回查今日是否其实已签上 try { const chk = await httpGet(`https://h5.zeehoev.com/cfmotoservermine/H5/signin/info?month=${month}`, { ...baseHeaders, ...getSign("h5", { month }, '', cfg) }); const ce = (chk?.data?.nowSignDetailVos || []).find(x => x.createDate === today); if (ce && (ce.signStatue == 3 || ce.signStatue == 5 || ce.signStatue == 0)) result.steps.push("今日已签到"); else result.steps.push(`签到失败: ${signMsg}`); } catch(e) { result.steps.push(`签到失败: ${signMsg}`); } } } } catch(e) { result.steps.push(`签到异常: ${e}`); } // 2. 查询连签和盲盒（v2.16.7：盲盒改走官方 POST /H5/signin/lottery?dateTime=<开盒日>， // 开盒日以 info.signPrizeDate===今日 为准；旧实现误用补签接口 supplementPrize → 40005 无效操作） try { const infoRes = await getInfoRetry(); const list = infoRes?.data?.nowSignDetailVos || []; const todayIdx = list.findIndex(x => x.createDate === today); let cont = 0; // 盲盒开启日(st=0)是连签周期边界：今日是盲盒日计入1天；往前的盲盒日说明官方连签已重置，停止计数 for (let i = todayIdx; i >= 0; i--) { const st = list[i]?.signStatue; if (st == 3 || st == 5 || (i === todayIdx && st == 0)) cont++; else break; } result.continueDays = cont; // 官方状态接口直出连签（权威值，日历重算仅作兜底） try { const stRes = await httpGet("https://h5.zeehoev.com/cfmotoservermine/H5/signin", { ...baseHeaders, ...getSign("h5", {}, '', cfg) }); const sc = Number(stRes?.data?.continueDays); if (String(stRes?.code) === "10000" && isFinite(sc) && sc > 0) { cont = sc; result.continueDays = cont; } } catch (e) {} const signCount = Number(infoRes?.data?.signCount) || 0; const prizeDate = String(infoRes?.data?.signPrizeDate || ""); const isBoxDay = prizeDate ? (prizeDate === today) : (signCount >= 30); if (isBoxDay) { const blindRes = await httpPost(`https://h5.zeehoev.com/cfmotoservermine/H5/signin/lottery?dateTime=${encodeURIComponent(today)}`, { ...baseHeaders, ...getSign("h5", { dateTime: today }, '', cfg) }, ""); const bd = (blindRes?.data && blindRes.data.signPrizesVO) || blindRes?.data || {}; result.blindBoxScore = Number(bd.integral || bd.integralScore || bd.score || 0); if (String(blindRes?.code) === "10000") { result.steps.push(`盲盒获得 +${result.blindBoxScore} (${bd.prizesName || bd.prizeName || "积分"})`); } else { result.steps.push(`盲盒未开: ${blindRes?.message || blindRes?.error || ("code=" + blindRes?.code)}`); } } else { result.steps.push(`距盲盒 ${Math.max(0, 30 - (signCount || cont))} 天`); } } catch(e) { result.steps.push(`盲盒异常: ${e}`); } // 3. 社区任务（根据配置开关） // v2.14.11：发帖/点赞/评论走新协议（socialHeaders：appid 头 + 含body签名 + 官方客户端标识头）， // 回查/分享/删除仍走旧通道（baseHeaders + getSign，实证不受收紧影响） const comm = cfg.community || {}; let postId = null; let postedNow = false; if (comm.enablePost !== false) { try { // 新版发帖 body 必须带 postSubInfo/topicid 字段（旧版 {postcontent} 会被拒），key 顺序须与官方一致 const postBody = JSON.stringify({ postSubInfo: { topicList: [] }, topicid: "", postcontent: "lucky" }); const postRes = await httpPost(`https://tapi.zeehoev.com/v1.0/social/cfmotoserversocial/commonArticle`, socialHeaders(token, userId, '', postBody, cfg), postBody); if (postRes?.code == "10000") { postId = getPostIdFromData(postRes.data); postedNow = true; result.interactScore += 1; result.steps.push("发帖成功 +1"); } else { result.steps.push(`发帖失败: ${postRes?.code || "?"} ${postRes?.message || postRes?.error || "未知"}`); } } catch(e) { result.steps.push(`发帖异常: ${e}`); } } if (!postId) { try { const qMine = `userId=${userId}&page=1&pageSize=10`; const listRes = await httpGet(`https://tapi.zeehoev.com/v1.0/social/cfmotoserversocial/community/mineArticleInfo?${qMine}`, appQueryGetHeaders(acc, qMine, cfg)); const rawList = Array.isArray(listRes?.data) ? listRes.data : (listRes?.data?.records || listRes?.data?.list || []); const list = Array.isArray(rawList) ? rawList : []; // mineArticleInfo 只返回本人动态，优先按 userId 命中本人，杜绝误取他人帖导致“不可删除” const mine = list.find(it => String(it.userId || it.createBy || it.uid || "") === String(userId)); postId = getPostIdFromData(mine || list[0] || listRes?.data); } catch(e) {} } if (postId) { if (comm.enableLike !== false) { try { const likeBody = JSON.stringify({ postId: String(postId), kindFlag: "0" }); const likeRes = await httpPost(`https://tapi.zeehoev.com/v1.0/social/cfmotoserversocial/socialCommu/likeFavoriteInfo`, socialHeaders(token, userId, '', likeBody, cfg), likeBody); if (likeRes?.code == "10000") { result.interactScore += 1; result.steps.push("点赞成功 +1"); } else result.steps.push(`点赞失败: ${likeRes?.code || "?"} ${likeRes?.message || likeRes?.error || "未知"}`); } catch(e) { result.steps.push(`点赞异常: ${e}`); } } if (comm.enableComment !== false) { try { const cmtBody = JSON.stringify({ postid: String(postId), userId: String(userId), comments: "今日已签到", sendTos: "[\n\n]" }); const cmtRes = await httpPost(`https://tapi.zeehoev.com/v1.0/social/cfmotoserversocial/commentInfo`, socialHeaders(token, userId, '', cmtBody, cfg), cmtBody); if (cmtRes?.code == "10000") result.steps.push("评论完成"); else result.steps.push(`评论失败: ${cmtRes?.code || "?"} ${cmtRes?.message || cmtRes?.error || "未知"}`); } catch(e) { result.steps.push(`评论异常: ${e}`); } } if (comm.enableShare !== false) { try { const shareRes = await httpPut(`https://tapi.zeehoev.com/v1.0/social/cfmotoserversocial/article/share/${postId}`, { ...baseHeaders, ...getSign("app", {}, '', cfg) }); if (shareRes?.code == "10000") { result.interactScore += 1; result.steps.push("分享成功 +1"); } else result.steps.push(`分享失败: ${shareRes?.code || "?"} ${shareRes?.message || shareRes?.error || "未知"}`); await httpGet(`https://tapi.zeehoev.com/v1.0/mine/cfmotoservermine/integral/adjustByShare`, { ...baseHeaders, ...getSign("app", {}, '', cfg) }); } catch(e) { result.steps.push(`分享异常: ${e}`); } } // 仅删除本次脚本新发的帖（postedNow），避免发帖失败时误删用户旧帖 // DELETE 同样被收紧：需新协议头 + query 入签（实证旧式头返回 30121） if (comm.enableDelete !== false && postedNow) { try { const delQuery = `articleId=${postId}&postType=1`; const delRes = await httpDelete(`https://tapi.zeehoev.com/v1.0/social/cfmotoserversocial/commonArticle/deleteArticle?${delQuery}`, socialHeaders(token, userId, delQuery, '', cfg)); if (delRes?.code == "10000") result.steps.push("动态已删除"); else result.steps.push(`删除失败: ${delRes?.code || "?"} ${delRes?.message || delRes?.error || "未知"}`); } catch(e) { result.steps.push(`删除异常: ${e}`); } } } result.totalGain = result.signinScore + result.blindBoxScore + result.interactScore; result.success = true; } catch(e) { result.error = String(e); result.steps.push(`执行异常: ${e}`); } return result; } // ========== 辅助：HTTP POST/PUT/DELETE ========== function httpPost(url, headers, body, timeoutMs) { return new Promise((resolve) => { const isQX = typeof $task !== "undefined"; const opts = { url, headers, method: "POST", body: typeof body === "string" ? body : JSON.stringify(body) }; // 单次请求超时：QX($task.fetch)单位为毫秒，Loon/Surge($httpClient)单位为秒，分别换算 if (timeoutMs && timeoutMs > 0) opts.timeout = isQX ? timeoutMs : Math.max(1, Math.round(timeoutMs / 1000)); if (isQX) { $task.fetch(opts).then( function(resp) { resolve(parseResp(resp.body)); }, function(err) { resolve({ error: String(err && err.error || err || "request failed") }); } ); } else { $httpClient.post(opts, function(err, resp, body) { if (err) { resolve({ error: String(err) }); return; } resolve(parseResp(body)); }); } }); } function httpPut(url, headers, body) { return new Promise((resolve) => { const isQX = typeof $task !== "undefined"; const opts = { url, headers, method: "PUT" }; // 支持 PUT 携带请求体（开坐垫等接口需要） if (body !== undefined && body !== null) opts.body = typeof body === "string" ? body : JSON.stringify(body); if (isQX) { $task.fetch(opts).then( function(resp) { resolve(parseResp(resp.body)); }, function(err) { resolve({ error: String(err && err.error || err || "request failed") }); } ); } else { $httpClient.put(opts, function(err, resp, body) { if (err) { resolve({ error: String(err) }); return; } resolve(parseResp(body)); }); } }); } function httpDelete(url, headers) { return new Promise((resolve) => { const isQX = typeof $task !== "undefined"; const opts = { url, headers, method: "DELETE" }; if (isQX) { $task.fetch(opts).then( function(resp) { resolve(parseResp(resp.body)); }, function(err) { resolve({ error: String(err && err.error || err || "request failed") }); } ); } else { $httpClient.delete(opts, function(err, resp, body) { if (err) { resolve({ error: String(err) }); return; } resolve(parseResp(body)); }); } }); } function getPostIdFromData(data) { if (!data) return null; if (typeof data === "string" || typeof data === "number") return String(data); if (Array.isArray(data)) return getPostIdFromData(data[0]); const direct = data.uuid || data.tuuid || data.postId || data.postid || data.articleId || data.articleID || data.id || data.dataId || data.tid; if (direct) return String(direct); for (const key of ["records", "list", "rows", "data", "result"]) { const v = data[key]; const pid = getPostIdFromData(v); if (pid) return pid; } return null; } // ========== 纯JS AES-256-ECB + PKCS7（云端开关锁需要；Loon JS环境无原生AES，已与标准库逐向量比对验证） ========== const AES_SBOX = new Uint8Array([ 0x63,0x7c,0x77,0x7b,0xf2,0x6b,0x6f,0xc5,0x30,0x01,0x67,0x2b,0xfe,0xd7,0xab,0x76, 0xca,0x82,0xc9,0x7d,0xfa,0x59,0x47,0xf0,0xad,0xd4,0xa2,0xaf,0x9c,0xa4,0x72,0xc0, 0xb7,0xfd,0x93,0x26,0x36,0x3f,0xf7,0xcc,0x34,0xa5,0xe5,0xf1,0x71,0xd8,0x31,0x15, 0x04,0xc7,0x23,0xc3,0x18,0x96,0x05,0x9a,0x07,0x12,0x80,0xe2,0xeb,0x27,0xb2,0x75, 0x09,0x83,0x2c,0x1a,0x1b,0x6e,0x5a,0xa0,0x52,0x3b,0xd6,0xb3,0x29,0xe3,0x2f,0x84, 0x53,0xd1,0x00,0xed,0x20,0xfc,0xb1,0x5b,0x6a,0xcb,0xbe,0x39,0x4a,0x4c,0x58,0xcf, 0xd0,0xef,0xaa,0xfb,0x43,0x4d,0x33,0x85,0x45,0xf9,0x02,0x7f,0x50,0x3c,0x9f,0xa8, 0x51,0xa3,0x40,0x8f,0x92,0x9d,0x38,0xf5,0xbc,0xb6,0xda,0x21,0x10,0xff,0xf3,0xd2, 0xcd,0x0c,0x13,0xec,0x5f,0x97,0x44,0x17,0xc4,0xa7,0x7e,0x3d,0x64,0x5d,0x19,0x73, 0x60,0x81,0x4f,0xdc,0x22,0x2a,0x90,0x88,0x46,0xee,0xb8,0x14,0xde,0x5e,0x0b,0xdb, 0xe0,0x32,0x3a,0x0a,0x49,0x06,0x24,0x5c,0xc2,0xd3,0xac,0x62,0x91,0x95,0xe4,0x79, 0xe7,0xc8,0x37,0x6d,0x8d,0xd5,0x4e,0xa9,0x6c,0x56,0xf4,0xea,0x65,0x7a,0xae,0x08, 0xba,0x78,0x25,0x2e,0x1c,0xa6,0xb4,0xc6,0xe8,0xdd,0x74,0x1f,0x4b,0xbd,0x8b,0x8a, 0x70,0x3e,0xb5,0x66,0x48,0x03,0xf6,0x0e,0x61,0x35,0x57,0xb9,0x86,0xc1,0x1d,0x9e, 0xe1,0xf8,0x98,0x11,0x69,0xd9,0x8e,0x94,0x9b,0x1e,0x87,0xe9,0xce,0x55,0x28,0xdf, 0x8c,0xa1,0x89,0x0d,0xbf,0xe6,0x42,0x68,0x41,0x99,0x2d,0x0f,0xb0,0x54,0xbb,0x16 ]); const AES_RCON = new Uint8Array([0x00,0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80,0x1b,0x36,0x6c,0xd8,0xab,0x4d]); function aesGMul(a, b) { let p = 0; for (let i = 0; i < 8; i++) { if (b & 1) p ^= a; const hi = a & 0x80; a = (a << 1) & 0xff; if (hi) a ^= 0x1b; b >>= 1; } return p; } // AES-256 密钥扩展（Nk=8, Nr=14，输出240字节） function aesKeyExpansion256(key) { const Nk = 8, Nb = 4, Nr = 14; const w = new Uint8Array(4 * Nb * (Nr + 1)); for (let i = 0; i < Nk * 4; i++) w[i] = key[i]; for (let i = Nk; i < Nb * (Nr + 1); i++) { let t0 = w[4*(i-1)], t1 = w[4*(i-1)+1], t2 = w[4*(i-1)+2], t3 = w[4*(i-1)+3]; if (i % Nk === 0) { const tmp = t0; t0 = AES_SBOX[t1] ^ AES_RCON[i/Nk]; t1 = AES_SBOX[t2]; t2 = AES_SBOX[t3]; t3 = AES_SBOX[tmp]; } else if (i % Nk === 4) { t0 = AES_SBOX[t0]; t1 = AES_SBOX[t1]; t2 = AES_SBOX[t2]; t3 = AES_SBOX[t3]; } w[4*i] = w[4*(i-Nk)] ^ t0; w[4*i+1] = w[4*(i-Nk)+1] ^ t1; w[4*i+2] = w[4*(i-Nk)+2] ^ t2; w[4*i+3] = w[4*(i-Nk)+3] ^ t3; } return w; } // 加密单个16字节块 function aesEncryptBlock(input, w) { const Nb = 4, Nr = 14; const s = new Uint8Array(16); for (let i = 0; i < 16; i++) s[i] = input[i]; for (let i = 0; i < 16; i++) s[i] ^= w[i]; for (let round = 1; round <= Nr; round++) { for (let i = 0; i < 16; i++) s[i] = AES_SBOX[s[i]]; let t = s[1]; s[1]=s[5]; s[5]=s[9]; s[9]=s[13]; s[13]=t; t=s[2]; s[2]=s[10]; s[10]=t; t=s[6]; s[6]=s[14]; s[14]=t; t=s[3]; s[3]=s[15]; s[15]=s[11]; s[11]=s[7]; s[7]=t; if (round !== Nr) { for (let c = 0; c < 4; c++) { const i = 4*c; const a0=s[i],a1=s[i+1],a2=s[i+2],a3=s[i+3]; s[i] = aesGMul(a0,2)^aesGMul(a1,3)^a2^a3; s[i+1] = a0^aesGMul(a1,2)^aesGMul(a2,3)^a3; s[i+2] = a0^a1^aesGMul(a2,2)^aesGMul(a3,3); s[i+3] = aesGMul(a0,3)^a1^a2^aesGMul(a3,2); } } const off = round*16; for (let i = 0; i < 16; i++) s[i] ^= w[off+i]; } return s; } function aesUtf8Bytes(str) { const out = []; for (let i = 0; i < str.length; i++) { let c = str.charCodeAt(i); if (c < 0x80) out.push(c); else if (c < 0x800) out.push(0xc0|(c>>6), 0x80|(c&0x3f)); else if (c >= 0xd800 && c <= 0xdbff) { const c2 = str.charCodeAt(++i); c = 0x10000 + ((c-0xd800)<<10) + (c2-0xdc00); out.push(0xf0|(c>>18), 0x80|((c>>12)&0x3f), 0x80|((c>>6)&0x3f), 0x80|(c&0x3f)); } else out.push(0xe0|(c>>12), 0x80|((c>>6)&0x3f), 0x80|(c&0x3f)); } return new Uint8Array(out); } function aesBytesToBase64(bytes) { const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; let result = "", i = 0; for (; i + 2 < bytes.length; i += 3) { const n = (bytes[i]<<16)|(bytes[i+1]<<8)|bytes[i+2]; result += chars[(n>>18)&63]+chars[(n>>12)&63]+chars[(n>>6)&63]+chars[n&63]; } const rem = bytes.length - i; if (rem === 1) { const n = bytes[i]<<16; result += chars[(n>>18)&63]+chars[(n>>12)&63]+"=="; } else if (rem === 2) { const n = (bytes[i]<<16)|(bytes[i+1]<<8); result += chars[(n>>18)&63]+chars[(n>>12)&63]+chars[(n>>6)&63]+"="; } return result; } // 对外：AES-256-ECB + PKCS7，key为32字节ASCII字符串，返回Base64 function aes256EcbEncryptBase64(plaintext, keyStr) { const key = aesUtf8Bytes(keyStr); if (key.length !== 32) throw new Error("AES-256需要32字节密钥，当前" + key.length); const w = aesKeyExpansion256(key); const data = aesUtf8Bytes(plaintext); const padLen = 16 - (data.length % 16); const padded = new Uint8Array(data.length + padLen); padded.set(data); for (let i = data.length; i < padded.length; i++) padded[i] = padLen; const out = new Uint8Array(padded.length); for (let off = 0; off < padded.length; off += 16) { out.set(aesEncryptBlock(padded.slice(off, off+16), w), off); } return aesBytesToBase64(out); } // ========== 车辆远程控制（寻车/鸣笛闪灯/开坐垫/云端开关锁，均会真实操作车辆） ========== // 车控风险确认：首次使用车控功能时前端弹窗告知风险，用户点「我同意风险并使用」保存（cfg.vehicleControlRisk）后才放行，否则所有控车指令均被拦截。 // 云端开/关锁 AES-256-ECB 密钥：已内置默认密钥 ce2cd7cb57124c1349dd8543bf6fd31d（可在配置页修改）。 // 算法：AES-256-ECB/PKCS7（32位密钥按ASCII），明文为带空格换行JSON、lockFlag为字符串"1"/"0"，密文Base64放进 body{"secret":...} const VEHICLE_ACTION_TEXT = { find: "短按寻车", loudFind: "鸣笛闪灯", cushion: "打开坐垫", unlock: "云端开锁", lock: "云端关锁" }; // v2.14.21 车控风险确认检查：首次使用车控时前端弹窗，用户点「我同意风险并使用」后保存，未同意前禁止一切车控指令 function vehicleRiskOk(cfg) { const risk = String((cfg || {}).vehicleControlRisk || "").trim(); return risk === "我同意风险并使用" || risk === "我自愿承担相关风险"; } function vehicleBaseHeaders(acc, cfg) { // 与官方App真实请求头对齐：UA / x-app-info / Accept；user_id 同时走独立头与 Cookie（官方放在 Cookie 里） // UA 未在账号里自定义时，每次请求随机生成设备指纹（避免固定指纹被风控拉黑） const ua = acc.userAgent || randomDeviceUA(true); const h = { "Authorization": `Bearer ${cleanToken(acc.token)}`, "Content-Type": "application/json;charset=UTF-8", "interfaceversion": "2", "Accept-Language": "zh-CN", "Accept": "*/*", "User-Agent": ua, "x-app-info": ua }; if (acc.userId) { h["user_id"] = String(acc.userId); h["Cookie"] = `user_id=${acc.userId}`; } return h; } function vehicleCheckRes(res, okMsg) { if (res && !res.error && (res.code == "10000" || res.code === 10000)) return { ok: true, message: okMsg }; // 控车指令经4G云端下发到车，响应常慢于客户端默认超时时长；超时时车辆往往已实际执行，按“已下发”提示，避免明明成功却弹红叉 const errText = String((res && (res.error || res.message || res.msg)) || "").toLowerCase(); if (res && res.error && /timeout|timed out|time out|请求超时|reuqest/.test(errText)) { return { ok: true, message: okMsg + "（响应超时但车辆通常已执行，可下拉刷新车辆状态确认）" }; } return { ok: false, message: (res && (res.message || res.msg)) || (res && res.error) || "指令下发失败", code: res && res.code }; } async function vehicleControl(acc, action, cfg, customVin) { try { const c = cfg || getConfig(); // 0) 车控风险确认：未填写「我自愿承担相关风险」前，拦截一切车控指令 if (!vehicleRiskOk(c)) return { ok: false, message: "未完成车控风险确认：首次使用车控功能时会弹窗告知风险，点击「我同意风险并使用」后才能启用" }; // 1) 取 VIN：优先使用传入的 customVin（切换车辆后前端传过来的），其次账号已保存，否则实时查车辆列表取第一台 let vin = customVin || acc.vinNo || ""; if (!vin) { const list = await fetchVehicleList(acc, c); if (!list || !list.length) return { ok: false, message: "未获取到绑定车辆(VIN)，请确认账号已绑定车辆" }; vin = list[0].vinNo; } const base = vehicleBaseHeaders(acc, c); // 2026-09-20 新增：控车请求失败自动重试一次（切换车辆后偶尔 HTTPClient request failed 是网络瞬时问题） const retry = async (fn, okMsg) => { for (let attempt = 1; attempt <= 2; attempt++) { const res = await fn(); const check = vehicleCheckRes(res, okMsg); if (check.ok) return check; // 网络错误才重试，业务错误（如未配置密钥）不重试 const isNetErr = res && res.error && /HTTPClient request failed|timeout|timed out|ETIMEDOUT|ECONNRESET|网络/.test(String(res.error)); if (!isNetErr || attempt >= 2) return check; await new Promise(r => setTimeout(r, 1200)); } }; // 2) 按动作下发 if (action === "find") { // 短按寻车：PUT control/{vin}，空body const h = { ...base, ...getSign("app", {}, "", c) }; return await retry(() => httpPut(`https://tapi.zeehoev.com/v1.0/app/cfmotoserverapp/vehicleInfo/control/${vin}`, h), "寻车指令已下发，车辆应闪灯提示"); } if (action === "loudFind") { // 高声寻车（鸣笛+闪灯）：POST controlV2，body {"param":"4","vin":vin} const bodyStr = JSON.stringify({ param: "4", vin: vin }); const h = { ...base, ...getSign("app", {}, bodyStr, c) }; return await retry(() => httpPost(`https://tapi.zeehoev.com/v1.0/app/cfmotoserverapp/vehicleInfo/controlV2`, h, bodyStr), "鸣笛闪灯指令已下发"); } if (action === "cushion") { // 开坐垫：PUT propertyTwo/one，commond=28 const bodyStr = JSON.stringify({ commond: "28", commondParam: "1", vcu: vin, version: "v2" }); const h = { ...base, ...getSign("app", {}, bodyStr, c) }; return await retry(() => httpPut(`https://tapi.zeehoev.com/v1.0/app/cfmotoserverapp/vehicleSet/propertyTwo/one`, h, bodyStr), "开坐垫指令已下发，坐垫应弹起"); } if (action === "unlock" || action === "lock") { // 云端开关锁(App 3.0.1)：POST vehicleSet/network/unlock，lockFlag "1"=开锁 / "0"=关锁（同一接口靠 lockFlag 区分，值为字符串而非数字）。 // 密钥来自配置 cfg.vehicleAesKey（v2.14.20 起已内置默认密钥，可在设置页「签名密钥配置」修改）。 const vKey = (c.vehicleAesKey || "").trim(); if (!vKey) return { ok: false, message: "尚未配置云端控车密钥：请到「设置 → 签名密钥配置」填写云端控车AES密钥并保存后，再使用开/关锁" }; if (!/^[0-9a-fA-F]{32}$/.test(vKey)) return { ok: false, message: "云端控车密钥格式错误（应为32位十六进制），请到配置页核对后保存" }; // 明文必须与官方 NSJSONSerialization 输出逐字节一致（冒号后带空格、键值间为 ",\n "）： // {\n "lockFlag" : "1",\n "vinNo" : "VIN"\n} → AES-256-ECB/PKCS7(密钥32字节ASCII) → Base64； // 实际发送 body={"secret":Base64密文}；注意【签名签的是明文 plain，不是 secret】（密钥/明文格式已用4条官方真实密文逐字节复现验证）。 const lockFlag = action === "unlock" ? "1" : "0"; const plain = `{\n "lockFlag" : "${lockFlag}",\n "vinNo" : "${vin}"\n}`; const secret = aes256EcbEncryptBase64(plain, vKey); const sendBody = JSON.stringify({ secret: secret }); const h = { ...base, ...getSign("app", {}, plain, c) }; console.log(`[车辆控制] ${action} 明文=${JSON.stringify(plain)} secret=${secret.slice(0,24)}...`); // 车辆唤醒+云端下发较慢，给25秒单次超时，避免在默认超时时长内误报（即便最终仍超时也会按“已下发”容错） const res = await httpPost(`https://tapi.zeehoev.com/v1.0/app/cfmotoserverapp/vehicleSet/network/unlock`, h, sendBody, 25000); try { console.log(`[车辆控制] ${action} 服务器返回=${JSON.stringify(res).slice(0,300)}`); } catch(e) {} return vehicleCheckRes(res, action === "unlock" ? "云端开锁指令已下发" : "云端关锁指令已下发"); } return { ok: false, message: "未知操作类型: " + action }; } catch(e) { return { ok: false, message: "控制异常: " + String(e) }; } } // ========== 车辆信息获取 ========== async function fetchServiceRechargeDetail(acc, cfg, vinNo) { try { const token = cleanToken(acc.token); const signH = getSign("h5", { vinNo: vinNo }, '', cfg); const headers = { "Authorization": `Bearer ${token}`, "Content-Type": "application/json;charset=UTF-8", "interfaceversion": "2", ...signH }; if (acc.userId) headers["user_id"] = String(acc.userId); const res = await httpGet(`https://h5.zeehoev.com/cfmotoserverapp/app/service/recharge/vehicle/detail?vinNo=${encodeURIComponent(vinNo)}`, headers); if (res.code == "10000" && res.data) { return { rechargeEndDate: String(res.data.rechargeEndDate || ""), lastUseDate: Number(res.data.lastUseDate) || 0, serviceRechargeStatus: String(res.data.serviceRechargeStatus || ""), vehicleName: String(res.data.vehicleName || "") }; } return null; } catch(e) { return null; } } async function fetchVehicleList(acc, cfg) { try { const token = cleanToken(acc.token); const signH = getSign("app", {}, '', cfg); const headers = { "Authorization": `Bearer ${token}`, "Content-Type": "application/json;charset=UTF-8", "interfaceversion": "2", ...signH }; if (acc.userId) headers["user_id"] = String(acc.userId); const res = await httpGet("https://tapi.zeehoev.com/v1.0/app/cfmotoserverapp/vehicle/list", headers); // 兼容多种响应格式：data 可能是数组，也可能是 { list: [...] } 或 { records: [...] } let list = []; if (res.code == "10000" || res.code === 10000) { if (Array.isArray(res.data)) list = res.data; else if (res.data && Array.isArray(res.data.list)) list = res.data.list; else if (res.data && Array.isArray(res.data.records)) list = res.data.records; else if (res.data && Array.isArray(res.data.rows)) list = res.data.rows; } return list.map(v => ({ vinNo: String(v.vinNo || v.frameNo || v.vin || "").trim(), name: String(v.vehicleName || v.vehicleType || v.deviceName || v.name || "车辆").trim() || "车辆", pic: String(v.vehiclePicUrl || v.pic || v.imageUrl || "").trim(), vehicleType: String(v.vehicleType || v.type || "").trim(), licensePlate: v.licensePlate || null })).filter(v => v.vinNo); } catch(e) { return []; } } async function fetchVehicleWidgets(acc, cfg, vinNo) { try { const token = cleanToken(acc.token); const signH = getSign("app", {}, '', cfg); const res = await httpGet(`https://tapi.zeehoev.com/v1.0/app/cfmotoserverapp/vehicle/widgets/${encodeURIComponent(vinNo)}`, { "Authorization": `Bearer ${token}`, "Content-Type": "application/json;charset=UTF-8", "interfaceversion": "2", "user_id": acc.userId || "", ...signH }); if ((res.code == "10000" || res.code === 10000) && res.data) { const d = res.data; const soc = Number(d.bmssoc || d.batteryLevel || 0); const range = Number(d.hmiRidableMile || d.vehicleRidableMile || d.ridableMileage || 0); const voltage = Number(d.voltage || d.batteryVoltage || d.bmsVoltage || d.totalVoltage || d.batteryTotalVoltage || 0); // GPS 经纬度：V2结构层级不固定，用 deepPick 在整棵树兜底找常见字段名；经度 lng/lon、纬度 lat const lngStr = deepPick(d, ["longitude","lng","lon","gpsX","longitudeValue","coordX","x"]); const latStr = deepPick(d, ["latitude","lat","gpsY","latitudeValue","coordY","y"]); const longitude = Number(lngStr); const latitude = Number(latStr); return { batteryPercent: Math.max(0, Math.min(100, isFinite(soc) ? soc : 0)), residualRangeKm: isFinite(range) ? range : 0, voltage: isFinite(voltage) && voltage > 0 ? voltage : 0, address: String(d.address || "").trim(), locationTime: String(d.location?.locationTime || "").trim(), vehicleName: String(d.vehicleName || "").trim(), vehicleImageUrl: String(d.vehicleScalePicUrl || d.vehiclePicUrl || "").trim(), headLockState: String(d.headLockState || "").trim(), batteryPullOut: String(d.batteryPullOutFlag || "") === "1", // 在线状态（4G/TBOX 是否在线）：尝试常见字段名 online: String(d.onlineStatus || d.online || d.netStatus || d.tboxStatus || d.deviceOnline || "").trim(), // 坐垫/座桶锁状态：字段名各版本不一致，deepPick 兜底；取不到为空串，前端不显示，绝不编造 cushionState: deepPick(d, ["cushionState","cushionStatus","cushionLockState","seatState","seatStatus","seatLockState","saddleState","saddleStatus","saddleLockState"]), // GPS 坐标（数值非法时置空，前端据此置灰地图按钮） longitude: (isFinite(longitude) && Math.abs(longitude) <= 180 && longitude !== 0) ? longitude : "", latitude: (isFinite(latitude) && Math.abs(latitude) <= 90 && latitude !== 0) ? latitude : "", // 电源/ACC状态（开关机）：尝试多种可能字段名 powerStatus: String(d.accStatus || d.powerStatus || d.vehicleStatus || d.ignitionStatus || d.powerMode || d.accState || d.powerState || d.vehicleState || d.engineStatus || d.isPowerOn || d.powerOn || "").trim(), // 车锁状态：开锁=上电(开机)，锁车=下电(关机)；headLockState龙头锁为实时字段，优先取 lockState: String(d.headLockState || d.lockState || d.lockStatus || d.vehicleLockState || d.carLockState || d.doorLockState || d.lockFlag || d.isLocked || d.locked || d.centralLockingStatus || "").trim() }; } return null; } catch(e) { return null; } } // 基于账号生成稳定的16位hex设备标识（uniqueIdentify/phoneDeviceName 参数用，服务端仅埋点不校验） function getDeviceIdentify(acc) { const seed = String(acc.userId || acc.vinNo || "zeeho-device"); let h = 0; for (let i = 0; i < seed.length; i++) { h = ((h << 5) - h + seed.charCodeAt(i)) | 0; } return (Math.abs(h).toString(16) + "0000000000000000").slice(0, 16); } // 深度优先在嵌套对象里找第一个匹配 keys 的非空值（V2返回结构层级不确定） function deepPick(obj, keys, depth) { if (!obj || typeof obj !== "object" || (depth || 0) > 5) return ""; for (const k of keys) { if (obj[k] !== undefined && obj[k] !== null && obj[k] !== "") return String(obj[k]); } for (const k in obj) { if (obj[k] && typeof obj[k] === "object") { const r = deepPick(obj[k], keys, (depth || 0) + 1); if (r) return r; } } return ""; } // 从 iotProperties 数组里按 identify 提取上报值（如 VehicleLock_S 整车锁定状态、HeadLockState 龙头锁） function pickIotProp(d, identify) { const arr = d && d.iotProperties; if (Array.isArray(arr)) { const key = String(identify).toLowerCase(); for (const it of arr) { if (it && String(it.identify || "").toLowerCase() === key && it.value !== null && it.value !== undefined && it.value !== "") { return String(it.value); } } } return ""; } // 车辆首页综合数据 vehicleHomePageV2（极核App 3.x首页接口，GET，VIN在路径，含开关机/ACC/车锁/在线状态） async function fetchVehicleHomePage(acc, cfg, vinNo) { try { const deviceId = getDeviceIdentify(acc); const query = `uniqueIdentify=${deviceId}&phoneDeviceName=ios_${deviceId}`; const url = `https://tapi.zeehoev.com/v1.0/app/cfmotoserverapp/vehicleHomePageV2/${encodeURIComponent(vinNo)}?${query}`; const res = await httpGet(url, appQueryGetHeaders(acc, query, cfg)); if (res && (res.code == "10000" || res.code === 10000) && res.data) { const d = res.data; // 整车锁定状态 VehicleLock_S：0=未锁(解锁即上电=开机)，1=锁定(锁车即下电=关机)；其次用顶层龙头锁 headLockState const vehicleLock = pickIotProp(d, "VehicleLock_S"); const headLockIot = pickIotProp(d, "HeadLockState"); // 顶层 headLockState 实时更新优先，其次iot龙头锁，最后整车锁VehicleLock_S(可能上报陈旧) const topLock = String(d.headLockState || d.lockState || d.lockStatus || d.vehicleLockState || headLockIot || vehicleLock || "").trim(); const lngStr = deepPick(d, ["longitude","lng","lon","gpsX","longitudeValue","coordX","x"]); const latStr = deepPick(d, ["latitude","lat","gpsY","latitudeValue","coordY","y"]); const longitude = Number(lngStr); const latitude = Number(latStr); return { powerStatus: deepPick(d, ["accStatus","powerStatus","vehicleStatus","ignitionStatus","powerMode","accState","powerState","vehicleState","engineStatus","isPowerOn","powerOn","acc"]).trim(), lockState: topLock, online: String(d.onlineStatus || d.rideState || d.online || d.netStatus || d.tboxStatus || "").trim(), rideState: String(d.rideState || "").trim(), cushionState: deepPick(d, ["cushionState","cushionStatus","cushionLockState","seatState","seatStatus","seatLockState","saddleState","saddleStatus","saddleLockState"]), longitude: (isFinite(longitude) && Math.abs(longitude) <= 180 && longitude !== 0) ? longitude : "", latitude: (isFinite(latitude) && Math.abs(latitude) <= 90 && latitude !== 0) ? latitude : "" }; } return null; } catch(e) { return null; } } async function fetchTirePressure(acc, cfg, vinNo) { try { const query = `vinNo=${encodeURIComponent(vinNo)}&timePeriodType=1`; const res = await httpGet(`https://tapi.zeehoev.com/v1.0/app/cfmotoserverapp/app/vehicle/tire/monitoring?${query}`, appQueryGetHeaders(acc, query, cfg)); if ((res.code == "10000" || res.code === 10000) && res.data) { const list = Array.isArray(res.data.realTimeData) ? res.data.realTimeData : (Array.isArray(res.data) ? res.data : []); const byPos = {}; for (const it of list) { const pos = Number(it?.sensorPosition); if (pos) byPos[pos] = it; } const fmt = (it) => { const warn = Number(it?.warningType ?? 0); const v = String(it?.tirePressure ?? "").trim(); const n = parseFloat(v); if (warn !== 0 || !v || !isFinite(n) || n <= 0) return "未绑定"; return v + "bar"; }; const fmtTemp = (it) => { const warn = Number(it?.warningType ?? 0); const v = it?.tireTemp; if (warn !== 0 || v == null) return ""; const s = String(v).trim(); const n = parseFloat(s); if (!s || s.toLowerCase() === "null" || !isFinite(n) || n <= 0) return ""; return s + "°C"; }; const front = byPos[1] || list[0]; const rear = byPos[2] || list[1]; return { frontPressure: front ? fmt(front) : "未绑定", rearPressure: rear ? fmt(rear) : "未绑定", frontTemp: front ? fmtTemp(front) : "", rearTemp: rear ? fmtTemp(rear) : "" }; } return null; } catch(e) { return null; } } async function fetchRideInfo(acc, cfg, vinNo) { try { const month = new Date().getFullYear() + "." + String(new Date().getMonth()+1).padStart(2,"0"); // v2.16.0 修复 30121：homeRideInfo/myRideInfo 需 query 入签（旧签名+旧UA 已被服务端拒） const qHome = `vinNo=${encodeURIComponent(vinNo)}`; const qMy = `vinNo=${encodeURIComponent(vinNo)}&month=${month}`; const [homeRes, myRes] = await Promise.all([ httpGet(`https://tapi.zeehoev.com/v1.0/app/cfmotoserverapp/homeRideInfo?${qHome}`, appQueryGetHeaders(acc, qHome, cfg)), httpGet(`https://tapi.zeehoev.com/v1.0/app/cfmotoserverapp/myRideInfo?${qMy}`, appQueryGetHeaders(acc, qMy, cfg)) ]); const h = homeRes?.data || homeRes || {}; const d = myRes?.data || myRes || {}; const list = Array.isArray(d.rideRecordList) ? d.rideRecordList : []; const todayKey = new Date().getFullYear() + "." + String(new Date().getMonth()+1).padStart(2,"0") + "." + String(new Date().getDate()).padStart(2,"0"); const day = list.find(x => String(x?.date || "") === todayKey) || list[list.length - 1] || {}; // 昨天里程：从当月骑行记录取昨天（homeRideInfo 无昨天数据，只有 lastRideMileage） const yest = new Date(Date.now() - 86400000); const yestKey = yest.getFullYear() + "." + String(yest.getMonth()+1).padStart(2,"0") + "." + String(yest.getDate()).padStart(2,"0"); const yd = list.find(x => String(x?.date || "") === yestKey) || {}; return { todayDistance: Number(day.rideMileage ?? h.rideMileageDay ?? 0), todayDuration: Number(day.ridingTimeDayUnitMinute ?? h.lastRidingTimeUnitMinute ?? 0), todayMaxSpeed: Number(day.maxSpeed ?? 0), totalMileage: Number(d.rideMileageTotal ?? 0), yesterdayDistance: Number(yd.rideMileage ?? 0), lastRideMileage: Number(h.lastRideMileage ?? 0), lastRideDuration: Number(h.lastRidingTimeUnitMinute ?? 0) }; } catch(e) { return null; } } // v2.16.0 隐藏骑行数据：月度汇总（myRideInfo，含服务端极速/急加速/急刹/压弯日字段，原样透传 data） async function fetchRideMonth(acc, cfg, month, vin) { try { let vinNo = String(vin || "").trim(); let vehicleName = ""; if (!vinNo) { const list = await fetchVehicleList(acc, cfg); const vehicles = list.filter(x => !/模拟/.test(String(x.name || "") + " " + String(x.vehicleType || ""))); if (vehicles.length === 0) return { ok: false, error: "账号未绑定车辆" }; vinNo = vehicles[0].vinNo; vehicleName = vehicles[0].name; } const m = month || (new Date().getFullYear() + "." + String(new Date().getMonth()+1).padStart(2,"0")); const query = `vinNo=${encodeURIComponent(vinNo)}&month=${encodeURIComponent(m)}`; const res = await httpGet(`https://tapi.zeehoev.com/v1.0/app/cfmotoserverapp/myRideInfo?${query}`, appQueryGetHeaders(acc, query, cfg)); if (res && String(res.code) === "10000") return { ok: true, month: m, vinNo: vinNo, vehicleName: vehicleName, data: res.data || {} }; return { ok: false, error: (res && (res.message || res.code)) || "接口无响应", vinNo: vinNo }; } catch(e) { return { ok: false, error: String(e) }; } } // v2.16.0 隐藏骑行数据：轨迹分页（ridetrack_v2 —— 唯一带 trajectory 的接口；服务端把 pageSize 钳在 20） // v2.16.1 修复：必须带 startTime=YYYY-MM（月份），否则服务端恒返回空数组（HAR 实证：缺失时 days=0） async function fetchRideTrackPage(acc, cfg, page, pageSize, vin, month) { try { let vinNo = String(vin || "").trim(); if (!vinNo) { const list = await fetchVehicleList(acc, cfg); const vehicles = list.filter(x => !/模拟/.test(String(x.name || "") + " " + String(x.vehicleType || ""))); if (vehicles.length === 0) return { ok: false, error: "账号未绑定车辆" }; vinNo = vehicles[0].vinNo; } const pg = Math.max(1, Number(page) || 1); const ps = Math.max(1, Math.min(200, Number(pageSize) || 20)); const st = String(month || "").replace(".", "-") || (new Date().getFullYear() + "-" + String(new Date().getMonth()+1).padStart(2,"0")); const query = `vinNo=${encodeURIComponent(vinNo)}&page=${pg}&pageSize=${ps}&startTime=${encodeURIComponent(st)}`; const res = await httpGet(`https://tapi.zeehoev.com/v1.0/app/cfmotoserverapp/ridetrack_v2?${query}`, appQueryGetHeaders(acc, query, cfg)); if (res && String(res.code) === "10000") { let days = []; if (Array.isArray(res.data)) days = res.data; else if (res.data && Array.isArray(res.data.list)) days = res.data.list; else if (res.data && Array.isArray(res.data.dayList)) days = res.data.dayList; return { ok: true, page: pg, vinNo: vinNo, days: days }; } return { ok: false, error: (res && (res.message || res.code)) || "接口无响应", page: pg, vinNo: vinNo }; } catch(e) { return { ok: false, error: String(e) }; } } async function fetchBatteryChargeState(acc, cfg, vinNo) { try { const token = cleanToken(acc.token); const signH = getSign("app", {}, '', cfg); const headers = { "Authorization": `Bearer ${token}`, "Content-Type": "application/json;charset=UTF-8", "interfaceversion": "2", "appid": cfg.app.appId, "user_id": acc.userId || "", ...signH }; const res = await httpGet(`https://tapi.zeehoev.com/v1.0/app/cfmotoserverapp/batteryInfo/${encodeURIComponent(vinNo)}`, headers); if (res.code == "10000" && res.data) { const d = res.data; // 尝试提取电压（多种可能字段名） const voltage = Number(d.voltage || d.batteryVoltage || d.bmsVoltage || d.totalVoltage || d.batteryTotalVoltage || d.vol || d.batVoltage || d.batteryVol || 0); // 尝试提取电流 const current = Number(d.current || d.batteryCurrent || d.bmsCurrent || d.cur || d.batteryCur || 0); // 尝试提取电池温度 const batteryTemp = Number(d.batteryTemp || d.batTemp || d.temp || d.temperature || d.bmsTemp || d.batteryTemperature || 0); const range = Number(d.hmiRidableMile || d.vehicleRidableMile || d.ridableMileage || d.residualRange || 0); // 耗电统计（官方直接给累计值，单位 kWh） const powerUseToday = Number(d.powerUseToday || 0); const powerUseMonth = Number(d.powerUseMonth || 0); const powerChargeMonth = Number(d.powerChargeMonth || 0); const chargeCount = Number(d.chargeCount || 0); return { chargeState: String(d.chargeStateStr || d.chargeState || "未充电"), voltage: isFinite(voltage) && voltage > 0 ? voltage : 0, current: isFinite(current) ? current : 0, batteryTemp: isFinite(batteryTemp) ? batteryTemp : 0, // v2.16.8 修正：batteryLevel 恒为 "100"（电池健康/在位标志，非电量），真值 soc→bmssoc soc: Number(d.soc || d.bmssoc || 0), residualRangeKm: isFinite(range) ? range : 0, powerUseToday: isFinite(powerUseToday) ? powerUseToday : 0, powerUseMonth: isFinite(powerUseMonth) ? powerUseMonth : 0, powerChargeMonth: isFinite(powerChargeMonth) ? powerChargeMonth : 0, chargeCount: isFinite(chargeCount) ? chargeCount : 0, // v2.16.5 官方充电时长字段（充电中非0；供与本地估算对照） fullChargeTime: Number(d.fullChargeTime || 0), fullChargeTimeSecond: Number(d.fullChargeTimeSecond || 0) }; } return { chargeState: "未充电", voltage: 0, current: 0, batteryTemp: 0, soc: 0, residualRangeKm: 0, powerUseToday: 0, powerUseMonth: 0, powerChargeMonth: 0, chargeCount: 0, fullChargeTime: 0, fullChargeTimeSecond: 0 }; } catch(e) { return { chargeState: "未充电", voltage: 0, current: 0, batteryTemp: 0, soc: 0, residualRangeKm: 0, powerUseToday: 0, powerUseMonth: 0, powerChargeMonth: 0, chargeCount: 0, fullChargeTime: 0, fullChargeTimeSecond: 0 }; } } async function fetchVehicleInfo(acc, cfg, vinNo) { const result = { hasVehicle: false, vehicleName: "", vinNo: "", voltage: 0, current: 0, batteryTemp: 0, batteryPercent: 0, residualRangeKm: 0, rangeEstimated: false, address: "", locationTime: "", chargeState: "未充电", frontPressure: "", rearPressure: "", frontTemp: "", rearTemp: "", todayDistance: 0, todayDuration: 0, todayMaxSpeed: 0, lastRideMileage: 0, totalMileage: 0, yesterdayDistance: 0, vehicleImageUrl: "", serviceEndDate: "", serviceRemainDays: 0, serviceStatus: "", powerStatus: "", lockState: "", online: "", rideState: "", cushionState: "", longitude: "", latitude: "", powerUseToday: 0, powerUseMonth: 0, powerChargeMonth: 0, chargeCount: 0 }; try { const allVehicles = await fetchVehicleList(acc, cfg); // 名下的模拟车不参与展示（首页不显示模拟车） const vehicles = allVehicles.filter(x => !/模拟/.test(String(x.name || "") + " " + String(x.vehicleType || ""))); if (vehicles.length === 0) return result; const v = vinNo ? (vehicles.find(x => x.vinNo === vinNo) || vehicles[0]) : vehicles[0]; result.vehicles = vehicles.map(x => ({ name: x.name, vinNo: x.vinNo })); result.currentVin = v.vinNo; result.hasVehicle = true; result.vehicleName = v.name; result.vinNo = v.vinNo; result.vehicleImageUrl = v.pic; const [widgets, tire, ride, battery, service, homePage] = await Promise.all([ fetchVehicleWidgets(acc, cfg, v.vinNo).catch(() => null), fetchTirePressure(acc, cfg, v.vinNo).catch(() => null), fetchRideInfo(acc, cfg, v.vinNo).catch(() => null), fetchBatteryChargeState(acc, cfg, v.vinNo).catch(() => ({ chargeState: "未充电", voltage: 0, current: 0, batteryTemp: 0, soc: 0, powerUseToday: 0, powerUseMonth: 0, powerChargeMonth: 0, chargeCount: 0 })), fetchServiceRechargeDetail(acc, cfg, v.vinNo).catch(() => null), fetchVehicleHomePage(acc, cfg, v.vinNo).catch(() => null) ]); if (widgets) { result.batteryPercent = widgets.batteryPercent; result.residualRangeKm = widgets.residualRangeKm; result.voltage = widgets.voltage; result.address = widgets.address; result.locationTime = widgets.locationTime; result.powerStatus = widgets.powerStatus || ""; result.lockState = widgets.lockState || ""; if (widgets.vehicleName) result.vehicleName = widgets.vehicleName; if (widgets.vehicleImageUrl) result.vehicleImageUrl = widgets.vehicleImageUrl; if (widgets.online) result.online = widgets.online; if (widgets.cushionState) result.cushionState = widgets.cushionState; // 坐标：widgets 先取到就用 if (widgets.longitude !== "" && widgets.longitude !== undefined) result.longitude = widgets.longitude; if (widgets.latitude !== "" && widgets.latitude !== undefined) result.latitude = widgets.latitude; } // homePage 优先（可能包含更准确的开关机/车锁状态） if (homePage) { if (homePage.powerStatus) result.powerStatus = homePage.powerStatus; if (homePage.lockState) result.lockState = homePage.lockState; if (homePage.online) result.online = homePage.online; if (homePage.rideState) result.rideState = homePage.rideState; if (homePage.cushionState) result.cushionState = homePage.cushionState; // 坐标兜底：widgets 没取到时用首页综合接口的 if ((result.longitude === "" || result.longitude === undefined) && homePage.longitude !== "" && homePage.longitude !== undefined) result.longitude = homePage.longitude; if ((result.latitude === "" || result.latitude === undefined) && homePage.latitude !== "" && homePage.latitude !== undefined) result.latitude = homePage.latitude; } if (tire) { result.frontPressure = tire.frontPressure; result.rearPressure = tire.rearPressure; result.frontTemp = tire.frontTemp; result.rearTemp = tire.rearTemp; } if (ride) { result.todayDistance = ride.todayDistance; result.todayDuration = ride.todayDuration; result.todayMaxSpeed = ride.todayMaxSpeed; result.lastRideMileage = ride.lastRideMileage; result.totalMileage = ride.totalMileage || 0; result.yesterdayDistance = ride.yesterdayDistance || 0; } result.chargeState = battery.chargeState || "未充电"; if (battery.voltage) result.voltage = battery.voltage; if (battery.current) result.current = battery.current; if (battery.batteryTemp) result.batteryTemp = battery.batteryTemp; // 耗电统计（官方接口累计值，0 也保留——可能确实没骑/没充） if (typeof battery.powerUseToday === "number") result.powerUseToday = battery.powerUseToday; if (typeof battery.powerUseMonth === "number") result.powerUseMonth = battery.powerUseMonth; if (typeof battery.powerChargeMonth === "number") result.powerChargeMonth = battery.powerChargeMonth; if (typeof battery.chargeCount === "number") result.chargeCount = battery.chargeCount; // 续航兜底：充电时 widgets/batteryInfo 都可能返回0，先尝试 batteryInfo，再基于电量估算 if ((!result.residualRangeKm || result.residualRangeKm === 0) && battery.residualRangeKm) { result.residualRangeKm = battery.residualRangeKm; } if ((!result.residualRangeKm || result.residualRangeKm === 0) && result.batteryPercent > 0) { // 基于电量百分比估算续航（满电按150km估算） result.residualRangeKm = Math.round(result.batteryPercent * 1.5); result.rangeEstimated = true; } if (service) { result.serviceEndDate = service.rechargeEndDate || ""; result.serviceStatus = service.serviceRechargeStatus || ""; result.serviceRemainDays = service.lastUseDate || 0; if (service.vehicleName) result.vehicleName = service.vehicleName; } } catch(e) {} return result; } // ========== 获取单账号实时数据 ========== async function fetchAccountData(acc, cfg, vinNo) { const token = cleanToken(acc.token); let userId = acc.userId || ""; const month = new Date().getFullYear() + "-" + (new Date().getMonth() + 1); const now = new Date(); const today = now.getFullYear() + "-" + String(now.getMonth() + 1).padStart(2, "0") + "-" + String(now.getDate()).padStart(2, "0"); const result = { userName: acc.userName || "未知用户", userId: userId, score: 0, signedToday: false, continueDays: 0, todayScore: 0, signCount: 0, last7: [], error: null, vehicle: { hasVehicle: false } }; // userId 为空时，尝试自动获取（兜底，主要靠配置页手动输入） if (!userId) { try { const signH = getSign("app", {}, '', cfg); // 尝试从 vehicle/list 响应中提取 userId const vehicleRes = await httpGet("https://tapi.zeehoev.com/v1.0/app/cfmotoserverapp/vehicle/list", { "Authorization": `Bearer ${token}`, "Content-Type": "application/json;charset=UTF-8", "interfaceversion": "2", ...signH }); if (vehicleRes.code == "10000" && vehicleRes.data) { const autoUid = String(vehicleRes.data.userId || vehicleRes.data.uid || vehicleRes.data.id || ""); if (autoUid) { userId = autoUid; result.userId = userId; // 自动保存获取到的 userId try { const accounts = getAccounts(); const idx = accounts.findIndex(a => cleanToken(a.token) === token); if (idx >= 0 && !accounts[idx].userId) { accounts[idx].userId = userId; saveAccounts(accounts); } } catch(e) {} } } } catch(e) {} } // 0/1/2 三段互相独立：并行发出（原顺序等待 4~5 个网络往返，是首屏慢的主因） // - 车辆信息（内部 vehicle/list + 6 个并行子请求） // - 积分（setting 接口，响应顺带完成 Token 状态判定，省掉 checkToken 的重复请求） // - 签到状态（见下方，与上面两段同时进行） const pVehicle = (async () => { try { result.vehicle = await fetchVehicleInfo(acc, cfg, vinNo); } catch(e) { result.vehicle = { hasVehicle: false }; } })(); const pScore = (async () => { try { if (!userId) { result.error = "请在配置页填写用户ID"; result.tokenValid = true; result.tokenReason = null; return; } const signH = getSign("app", {}, '', cfg); const infoUrl = `https://tapi.zeehoev.com/v1.0/mine/cfmotoservermine/setting/${userId}`; const infoRes = await httpGet(infoUrl, { "Authorization": `Bearer ${token}`, "Content-Type": "application/json;charset=UTF-8", "interfaceversion": "2", "user_id": userId, ...signH }); if (infoRes.code == "10000" && infoRes.data) { // 尝试多种积分字段名 result.score = Number(infoRes.data.score || infoRes.data.integral || infoRes.data.point || infoRes.data.points || infoRes.data.totalScore || infoRes.data.totalIntegral || 0); // 昵称始终用配置中保存的，不用API返回的nickName覆盖（配置为空时才回填） result.tokenValid = true; result.tokenReason = null; const nick = String(infoRes.data.nickName || ""); if (nick && (!result.userName || result.userName === "未知用户")) result.userName = nick; } else if (infoRes.code == "40001" || infoRes.code == 401) { result.error = "Token已过期"; result.tokenValid = false; result.tokenReason = "token已过期"; } else { result.error = "积分获取失败: " + (infoRes.message || infoRes.code || "未知错误"); result.tokenValid = true; result.tokenReason = infoRes.message || "请求异常"; } } catch(e) { result.error = "积分获取异常: " + String(e); result.tokenValid = true; result.tokenReason = String(e); } })(); // 2. 签到状态（跨月：并行请求当月+上月，合并计算连签，避免1号重置） try { const now = new Date(); const curMonth = now.getFullYear() + "-" + (now.getMonth() + 1); const lastDate = new Date(now.getFullYear(), now.getMonth() - 1, 1); const lastMonth = lastDate.getFullYear() + "-" + (lastDate.getMonth() + 1); const baseHeaders = { "Authorization": `Bearer ${token}`, "Content-Type": "application/json;charset=UTF-8", "interfaceversion": "2", "user_id": userId }; const [curRes, lastRes] = await Promise.all([ httpGet(`https://h5.zeehoev.com/cfmotoservermine/H5/signin/info?month=${curMonth}`, { ...baseHeaders, ...getSign("h5", { month: curMonth }, '', cfg) }), httpGet(`https://h5.zeehoev.com/cfmotoservermine/H5/signin/info?month=${lastMonth}`, { ...baseHeaders, ...getSign("h5", { month: lastMonth }, '', cfg) }) ]); const lastList = (lastRes.code == "10000" && lastRes.data) ? (lastRes.data.nowSignDetailVos || []) : []; const curList = (curRes.code == "10000" && curRes.data) ? (curRes.data.nowSignDetailVos || []) : []; const list = [...lastList, ...curList]; if (curRes.code == "10000" && curRes.data) { result.signCount = Number(curRes.data.signCount) || 0; } const todayEntry = curList.find(x => x.createDate === today); result.signedToday = !!(todayEntry && (todayEntry.signStatue == 3 || todayEntry.signStatue == 5 || todayEntry.signStatue == 0)); result.todayScore = todayEntry ? (Number(todayEntry.integralScore) || 0) : 0; // 优先用今日签到运行日志里的准确总得分（签到+盲盒+互动），没有运行记录则回退到签到分 try { const _todayLogs = (getLogs() || []).filter(l => l && l.date === today && String(l.userId || "") === String(userId) && l.success); if (_todayLogs.length > 0) { const _tl = _todayLogs[0]; result.todayScore = Number(_tl.totalGain) || result.todayScore; result.todayDetail = { signinScore: Number(_tl.signinScore) || 0, blindBoxScore: Number(_tl.blindBoxScore) || 0, interactScore: Number(_tl.interactScore) || 0 }; } } catch(e) {} // 跨月连签：从今天往前数，遇到断签停止（不按月重置） const todayIdx = list.findIndex(x => x.createDate === today); let cont = 0; if (todayIdx >= 0) { for (let i = todayIdx; i >= 0; i--) { const st = list[i]?.signStatue; if (st == 3 || st == 5 || (i === todayIdx && st == 0)) cont++; else break; } } result.continueDays = cont; for (let i = 6; i >= 0; i--) { const d = new Date(); d.setDate(d.getDate() - i); const ds = d.getFullYear() + "-" + String(d.getMonth() + 1).padStart(2, "0") + "-" + String(d.getDate()).padStart(2, "0"); const entry = list.find(x => x.createDate === ds); result.last7.push({ date: ds.slice(5), signed: !!(entry && (entry.signStatue == 3 || entry.signStatue == 5 || entry.signStatue == 0)), isToday: i === 0 }); } } catch(e) { if (!result.error) result.error = "签到状态获取失败"; } // 等待车辆信息 + 积分（Token 状态已在积分响应里判定，不再单独请求 checkToken） await Promise.all([pVehicle, pScore]); return result; } // ========== 并发拉取全部账号数据 ========== // 默认并发3路，兼顾看板流畅度与极核服务端限流风险；返回顺序与账号列表一致 async function fetchAllAccounts(accounts, cfg, limit = 3) { const out = new Array(accounts.length); let i = 0; async function worker() { while (i < accounts.length) { const idx = i++; try { out[idx] = await fetchAccountData(accounts[idx], cfg); } catch(e) { out[idx] = { userName: accounts[idx].userName || "未知", userId: accounts[idx].userId, success: false, error: String(e) }; } } } const n = Math.max(1, Math.min(limit, accounts.length)); await Promise.all(Array.from({ length: n }, worker)); return out; } // ========== 解析请求 body ========== function parseBody(req) { try { if (!req.body) return {}; if (typeof req.body === "object") return req.body; return JSON.parse(req.body); } catch(e) { return {}; } } // ========== HTML: 看板页 ========== // 根据电源状态/车锁状态判断开关机显示（优先电源字段，其次用车锁推断：开锁=上电/开机，锁车=下电/关机） function getPowerDisplay(powerStatus, lockState) { const p = String(powerStatus || "").toLowerCase().trim(); const l = String(lockState || "").toLowerCase().trim(); const onVals = ["1", "on", "true", "开机", "open", "激活", "acc_on", "acc on", "power_on", "power on", "已开机", "已上电"]; const offVals = ["0", "off", "false", "关机", "closed", "待机", "acc_off", "acc off", "power_off", "power off", "已关机", "已下电"]; if (p) { if (onVals.includes(p)) return { text: "已开机", cls: "power-on" }; if (offVals.includes(p)) return { text: "已关机", cls: "power-off" }; } if (l) { const lockOnVals = ["0", "未锁", "开锁", "unlocked", "false", "open", "已开锁", "未锁车"]; const lockOffVals = ["1", "已锁", "锁车", "locked", "true", "closed", "已锁车"]; if (lockOnVals.includes(l)) return { text: "已开机", cls: "power-on" }; if (lockOffVals.includes(l)) return { text: "已关机", cls: "power-off" }; } return { text: "状态未知", cls: "power-unknown" }; } // 在线状态（4G/TBOX）：1/online/true/在线=在线，0/offline/false/离线=离线，取不到返回空串不显示 function getOnlineDisplay(online) { const s = String(online || "").toLowerCase().trim(); if (!s) return { text: "", cls: "" }; const onVals = ["1", "on", "online", "true", "在线", "已在线", "connected", "normal"]; const offVals = ["0", "off", "offline", "false", "离线", "未在线", "已离线", "disconnect", "disconnected", "sleep", "休眠"]; if (onVals.includes(s)) return { text: "在线", cls: "online-on" }; if (offVals.includes(s)) return { text: "离线", cls: "online-off" }; // 其它非标准值原样展示（如 rideState 文本），用中性色 return { text: String(online), cls: "online-unk" }; } // 车锁状态：返回 {text,cls}，取不到返回空串 function getLockDisplay(lockState) { const s = String(lockState || "").toLowerCase().trim(); if (!s) return { text: "", cls: "" }; const unlocked = ["0", "未锁", "开锁", "unlocked", "false", "open", "已开锁", "未锁车"]; const locked = ["1", "已锁", "锁车", "locked", "true", "closed", "已锁车"]; if (unlocked.includes(s)) return { text: "未锁车", cls: "lock-unlocked" }; if (locked.includes(s)) return { text: "已锁车", cls: "lock-locked" }; return { text: String(lockState), cls: "lock-unk" }; } // 坐垫状态：字段语义不确定，仅在有值时原样展示，不做开/合的武断映射 function getCushionDisplay(cushionState) { const s = String(cushionState || "").trim(); if (!s) return ""; const openVals = ["1", "open", "opened", "on", "true", "开", "已开", "打开", "弹开"]; const closedVals = ["0", "close", "closed", "off", "false", "关", "已关", "闭合", "关闭"]; if (openVals.includes(s.toLowerCase())) return "坐垫已开"; if (closedVals.includes(s.toLowerCase())) return "坐垫已合"; return "坐垫·" + s; } // 坐标是否有效（经纬度都是非空有限数、在合法区间、且不是 0,0） function hasValidCoord(lat, lng) { if (lat === "" || lat === null || lat === undefined || lng === "" || lng === null || lng === undefined) return false; const la = Number(lat), ln = Number(lng); return isFinite(la) && isFinite(ln) && Math.abs(la) <= 90 && Math.abs(ln) <= 180 && !(la === 0 && ln === 0); } function renderDashboard(accounts, data, cfg, updateTime) { const totalScore = data.reduce((s, a) => s + (a.score || 0), 0); const signedCount = data.filter(a => a.signedToday).length; const cards = data.map((a, idx) => { // 盲盒30天一轮，满30第二天重置为第1天 const blindDay = a.continueDays === 0 ? 0 : ((a.continueDays - 1) % 30) + 1; const blindRound = a.continueDays === 0 ? 0 : Math.ceil(a.continueDays / 30); const blindPct = Math.round((blindDay / 30) * 100); const blindRemain = 30 - blindDay; const last7 = a.last7.map(d => `
${d.date.slice(3)} ${d.signed ? '✓' : '—'}
`).join(''); // 充电状态判断和预计充满时间 const v = a.vehicle || {}; const isCharging = v.chargeState && v.chargeState !== "未充电"; let chargeEta = ""; if (isCharging && v.voltage && v.current && v.current > 0 && v.batteryPercent < 100) { const batteryCap = 1440; // 估算72V20Ah const remainWh = (100 - v.batteryPercent) / 100 * batteryCap; const powerW = v.voltage * v.current; const hours = remainWh / powerW; if (hours >= 1) chargeEta = "约" + hours.toFixed(1) + "小时充满"; else chargeEta = "约" + Math.round(hours * 60) + "分钟充满"; } // 开关机状态（优先电源字段，其次用车锁推断） const powerDisplay = getPowerDisplay(v.powerStatus, v.lockState); // 实时状态：在线 / 车锁 / 坐垫（取不到则对应为空，不渲染） const onlineDisplay = getOnlineDisplay(v.online || v.rideState); const lockDisplay = getLockDisplay(v.lockState); const cushionText = getCushionDisplay(v.cushionState); const coordOk = hasValidCoord(v.latitude, v.longitude); return `
${(a.userName || '?').charAt(0).toUpperCase()}
${a.userName}
${a.signedToday ? '已签到' : '未签到'}
${a.tokenValid === false ? '⚠️失效' : '✓正常'}
${a.error ? `
${a.error}
` : ''}
${a.score.toLocaleString()}
总积分
+${a.todayScore}
今日积分
${a.continueDays}
连签天数
${blindRemain}
距盲盒
盲盒进度（第${blindRound}轮）${blindDay}/30 · ${blindPct}%
近 7 天签到
${last7}
${a.vehicle && !a.vehicle.hasVehicle ? `
🚗 该账号未绑定车辆
` : ''} ${a.vehicle && a.vehicle.hasVehicle ? `
🚗 ${a.vehicle.vehicleName || "车辆"} ${a.vehicle.vinNo ? `${maskVin(a.vehicle.vinNo)}` : ""} ${onlineDisplay.text ? `${onlineDisplay.text}` : ""} ${a.vehicle.chargeState || "未充电"} ${powerDisplay.text}
${(lockDisplay.text || cushionText) ? `
${lockDisplay.text ? `🔒 ${lockDisplay.text}` : ""} ${cushionText ? `💺 ${cushionText}` : ""}
` : ""} ${isCharging ? `
⚡ 充电中 ${a.vehicle.batteryPercent}% ${a.vehicle.batteryPercent >= 100 ? `已充满` : (chargeEta ? `${chargeEta}` : "")}
` : ""}
${a.vehicle.batteryPercent}%
电量SOC
${a.vehicle.rangeEstimated ? "约" + a.vehicle.residualRangeKm : a.vehicle.residualRangeKm}
续航km
${a.vehicle.todayDistance ? a.vehicle.todayDistance.toFixed(1) : "0"}
今日km
${a.vehicle.todayDuration || 0}
骑行min
${(a.vehicle.frontPressure || a.vehicle.rearPressure) ? `
🛞前 ${a.vehicle.frontPressure || "-"} ${a.vehicle.frontTemp ? `${a.vehicle.frontTemp}` : ""}
🛞后 ${a.vehicle.rearPressure || "-"} ${a.vehicle.rearTemp ? `${a.vehicle.rearTemp}` : ""}
` : ""} ${(a.vehicle.voltage || (isCharging && a.vehicle.current) || a.vehicle.batteryTemp || a.vehicle.powerUseToday > 0 || a.vehicle.powerUseMonth > 0 || a.vehicle.powerChargeMonth > 0 || a.vehicle.chargeCount > 0) ? `
${a.vehicle.voltage ? `
⚡电压 ${a.vehicle.voltage.toFixed(1)}V
` : ""} ${isCharging && a.vehicle.current ? `
🔌电流 ${a.vehicle.current.toFixed(1)}A
` : ""} ${a.vehicle.batteryTemp ? `
🌡️电池温度 ${a.vehicle.batteryTemp.toFixed(0)}°C
` : ""} ${a.vehicle.powerUseToday > 0 ? `
📉今日耗电 ${a.vehicle.powerUseToday.toFixed(2)}kWh
` : ""} ${a.vehicle.powerUseMonth > 0 ? `
📊本月耗电 ${a.vehicle.powerUseMonth.toFixed(2)}kWh
` : ""} ${a.vehicle.powerChargeMonth > 0 ? `
🔋本月充电 ${a.vehicle.powerChargeMonth.toFixed(2)}kWh
` : ""} ${a.vehicle.chargeCount > 0 ? `
🔁充电次数 ${a.vehicle.chargeCount}
` : ""}
` : ""} ${a.vehicle.serviceEndDate ? `
📅 服务到期 ${a.vehicle.serviceEndDate}
` : ""} ${(a.vehicle.address || coordOk) ? `
📍 ${a.vehicle.address || "已获取GPS定位"}${a.vehicle.locationTime ? ` · ${a.vehicle.locationTime}` : ""}
` : ""}
` : ""}
`; }).join(''); return ` 极核 ZEEHO 签到面板
Z

极核 ZEEHO 签到面板

${data.length} 个账号 · 实时数据

${signedCount}/${data.length} 已签到
配置
${data.length === 0 ? `

未找到极核账号

请先在「配置」页面添加账号（Authorization Bearer token），或运行签到脚本抓 Cookie

去添加账号
` : `
账号总积分
${totalScore.toLocaleString()}
${data.length} 个账号合计
今日签到
${signedCount} / ${data.length}
${data.length - signedCount > 0 ? (data.length - signedCount) + ' 个未签到' : '全部已签到'}
数据更新时间
${updateTime}
来自代理工具实时 API
${cards}
App端 appId: ${cfg.app.appId} · H5端 appId: ${cfg.h5.appId} · 可在「配置」页修改
`}
极核 ZEEHO 签到看板 · 作者 lucky · 数据来自代理工具实时 API
脚本版本 ${SCRIPT_VERSION}
`; } // ========== HTML: 配置页 ========== function renderConfig(accounts, cfg) { const accRows = accounts.map((a, idx) => `
账号 ${idx + 1}
`).join(''); return ` 极核 ZEEHO · 配置
Z

极核 ZEEHO · 配置

签名密钥 & 账号管理

签名密钥配置
无需在此填写：首次使用车控功能（寻车/鸣笛/坐垫/开关锁）时会弹窗告知风险，点击「我同意风险并使用」后自动启用。
修改后点击「保存配置」生效。App/H5 密钥用于极核 API 签名计算（md5(sha1(param+secret))）；云端控车密钥已内置默认值，可在此修改；车控风险确认在首次使用车控功能时弹窗完成。
社区任务开关
关闭对应开关后，签到脚本将跳过该任务。修改后点击下方「保存配置」生效。
手机号登录（免抓包）
用手机号 + 短信验证码登录，自动获取 Token 与用户ID并加入账号列表，全程无需抓包。登录成功后会自动写入并刷新页面。
· 建议使用小号登录，因为极核是单会话模式（手机号登录情况下只能一台设备）。
已修复（v2.14.4）：发码与登录统一走 App 网关（同一验证码池），登录签名按官方 App 抓包结果修正（POST 请求按 GET 风格入签），不再误报「验证码有误或已过期」。
提示：验证码 5 分钟内有效，重复获取会使上一个验证码失效，请使用最新收到的那条。
账号管理（${accounts.length} 个）
${accRows || '
暂无账号，点击上方「添加账号」
'}
Token 格式：直接粘贴抓包得到的 Authorization 值即可，即使带了 Bearer 前缀，保存时也会自动去掉、只保留后面的 Token。
每账号可单独填 Bark Key：该账号签到成功后推送一条通知（标题含昵称、内容含得分明细），留空则该账号不推送；支持官方 Key 或自建服务器地址。
用户ID获取：打开极核App-我的，抓包 /setting/{userId} 接口，响应体 data.id 即为用户ID。
脚本版本 ${SCRIPT_VERSION} · 极核 ZEEHO
`; } // ========== 响应辅助（兼容 QX / Loon / Surge） ========== function sendResp(status, headers, body) { // Loon 专用：$done 使用 response 包装 // 强制 no-cache：面板 HTML 每次访问都拉取最新版本，避免浏览器缓存旧界面导致新功能不生效 const h = Object.assign({}, headers || {}, { "Cache-Control": "no-store, no-cache, must-revalidate, max-age=0", "Pragma": "no-cache", "Expires": "0" }); $done({ response: { status: status, headers: h, body: body } }); } // ========== 主入口：重写路由 ========== // ========== 整合版：极核 ZEEHO LITE 轻应用界面（base64 内嵌） ========== const __APP_HTML_B64 = "<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no, viewport-fit=cover">
<meta name="apple-mobile-web-app-capable" content="yes">
<meta name="mobile-web-app-capable" content="yes">
<meta name="apple-mobile-web-app-status-bar-style" content="black-translucent">
<meta name="apple-mobile-web-app-title" content="极核面板">
<meta name="theme-color" content="#0A0F1E">
<link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 64 64'%3E%3Crect width='64' height='64' rx='16' fill='%230A0F1E'/%3E%3Cpath d='M14 38c0-10 8-18 18-18s18 8 18 18' fill='none' stroke='%232BD4F2' stroke-width='6' stroke-linecap='round'/%3E%3Cpath d='M32 36l16 13' stroke='%230E8FB2' stroke-width='6' stroke-linecap='round'/%3E%3Ccircle cx='21' cy='44' r='5' fill='%232BD4F2'/%3E%3Ccircle cx='44' cy='48' r='5' fill='%230E8FB2'/%3E%3C/svg%3E">
<link rel="apple-touch-icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAALQAAAC0CAIAAACyr5FlAAAEb0lEQVR4nO3dwXHVMBSFYYfJig0dMMOeDmgpRbwi0hIdsKeRLFiISUzyjrEtWTr36v/WzKBn/b7WOOHx8PnL1wW459PoBcAXcUAiDkjEAYk4IBEHJOKARByQiAMScUAiDkjEAYk4IBEHJOKARByQiAMScUAiDkjEAYk4IBEHJOKARByQiAMScUAiDkjEAYk4ID2OXsAw337+2v+Hf//4ft1KbD3M8xUMh2rYNkkr+eNo2MRHuStJG8elTXyUspKEcXTOYi1ZIqniGJjFWppEksRhksVagkTCx2GYxVroRGK/BDMvY4mwwg1RJ0e4ix5xhIScHOHKWGKuOV4cEa9yEW7lkR4r4S6uEuURE2ZypCljifNZYsQR5WruF+ITBYgjxHU8wf9zucfhfwVrmH866wNph2v337OhwxpGmfE3wQ5txvoPm9/ozflOjuY70fAGdV5bQ6ZxRPmVvijrPMfxQBroijtPo3ppzxzdbsTyFxlubT27ydHkKvcf0U3+RrfCvM4c9Vdn+JM7wUd4ZTc5ajhcVoc1tGIUR+U957MrlSvxebgYxVHDp4zCbT3nuMRRc7t47kTNqkyGh0scp3mWUTivbQ+LOExuFCsO18QijtP8b03/FW4YH8fpWyTKdT+9zuHDY3wcsBU1jihjo4i12leD4zg3OSNe63NrHvtkiTo50AFxQBoZxzzPlCLck4XJAYk4IAWLI+4zpYi1/mBxoKdhcQx/NxzIqGvF5IAUKY5YD2wl0KeIFAc6Iw5IxAGJOCARBySvfw4JK0wOSMQBiTggEQck4oBEHJCIAxJxQCIOSMQBiTggEQck4oBEHFseb8+jlzAScUiljJn7II771k1M2wdx7PJ4e54wEeK4Q3UwWx/E8d52AVP1QRz/2LP38/RBHG/27/okffDb53+d2++X21PzlfhgclTJPUKIY1nq9jhxH8TRYHez9jF7HK32NWUfHEgb72umI+rsk2NpvZ2ZRgiT403Dfc0xP5gcbxruaI75EWxyvPvSxSu+fI358SpMHBvfxdk8EY6oRYzHyva3tDb/DleOqEWAybFz73nENOc+OfZPhSu+A3ryI6p7HMO17SNWItZxHB0GF32B/LRHEOs4fMzZB3Hs9XJ7mu0IQhzHTNUHcRw2zxHVOo6jry66/VcmkxxBrONwNkMfvCGtlfgtaoDJsWfXB/7fWImPqAEmR9Hzp7InpPxBbpg4ig6/z3Favj6CxeEv0xEkwJkjlkxHEOJoL00fPFaukuAIwuS4SoK3ZEyOy8U9ojI5wuj/ZCGOGDhz5FS/r6NeeBAHJOLooebWH/ielDg6ObfHY9+gE0c/R3d6+M9WeM8xwJ43H8PLWIhjuLuhOJSx8FgZru0/h2mLOCys+/BphThclCZ8ylg4c2ADkwMScUAiDkjEAYk4IBEHJOKARByQiAMScUAiDkjEAYk4IBEHJOKARByQiAMScUAiDkjEAYk4IBEHJOKARByQiAMScUAiDkjEAYk4IBEHJOKARByQ/gCSkVdi5BBxhgAAAABJRU5ErkJggg==">
<title>极核 ZEEHO 面板</title>
<style>
/* ============ reset & tokens ============ */
*{margin:0;padding:0;box-sizing:border-box;-webkit-tap-highlight-color:transparent}
:root{
  --bg:#0A0F1E; --bg2:#0C1324;
  --card:rgba(146,170,205,.055); --card2:#111A2E; --card3:#0E1628;
  --line:rgba(146,170,205,.13); --line2:rgba(146,170,205,.22);
  --txt:#EAF1FB; --txt2:#93A0B8; --txt3:#5E6E88;
  --brand:#2BD4F2; --brand2:#0E8FB2; --brandSoft:rgba(43,212,242,.13);
  --ok:#3DDC97; --okSoft:rgba(61,220,151,.14);
  --warn:#F7B955; --warnSoft:rgba(247,185,85,.14);
  --err:#F9706A; --errSoft:rgba(249,112,106,.14);
  --vio:#B7A6FB; --vioSoft:rgba(183,166,251,.14);
  --grad:linear-gradient(135deg,#2BD4F2,#0E8FB2);
  --grad-vio:linear-gradient(135deg,#B7A6FB,#7C6BF0);
  --r-lg:22px; --r-md:16px; --r-sm:12px;
  --spring:cubic-bezier(.32,1.4,.44,1);
  --ease:cubic-bezier(.4,0,.2,1);
  --safe-t:env(safe-area-inset-top,0px);
  --safe-b:env(safe-area-inset-bottom,0px);
}

.veh-switch{display:flex;flex-wrap:wrap;gap:6px;align-items:center;margin:12px 0 4px}.veh-sw-label{font-size:11px;color:var(--txt3);margin-right:2px}.veh-chip{border:1px solid var(--line2);background:var(--card3);color:var(--txt2);border-radius:20px;padding:5px 11px;font-size:12px;cursor:pointer}.veh-chip.on{background:var(--brandSoft);border-color:var(--brand);color:var(--brand)}
.signin-fab{position:fixed;right:16px;bottom:calc(78px + var(--safe-b));z-index:998;display:flex;align-items:center;gap:6px;padding:12px 18px;border-radius:999px;background:var(--grad);color:#fff;font-size:13px;font-weight:800;letter-spacing:.5px;box-shadow:0 8px 24px rgba(14,143,178,.45),inset 0 1px 0 rgba(255,255,255,.25);cursor:pointer;transition:transform .16s var(--spring),opacity .2s;-webkit-tap-highlight-color:transparent}
.signin-fab:active{transform:scale(.92)}
.signin-fab.busy{opacity:.6;pointer-events:none}
.signin-fab svg{width:15px;height:15px}

html,body{height:100%}
body{
  font-family:-apple-system,BlinkMacSystemFont,"PingFang SC","Helvetica Neue","Segoe UI",sans-serif;
  background:var(--bg); color:var(--txt); font-size:15px; line-height:1.5;
  -webkit-font-smoothing:antialiased; overscroll-behavior-y:none;
  -webkit-text-size-adjust:100%;
}
.num{font-variant-numeric:tabular-nums;font-feature-settings:"tnum"}
button{font-family:inherit;color:inherit;background:none;border:none;cursor:pointer;touch-action:manipulation;user-select:none;-webkit-user-select:none}
input,select,textarea{font-family:inherit;color:var(--txt);background:var(--card3);border:1px solid var(--line);border-radius:12px;padding:11px 13px;font-size:15px;width:100%;outline:none;transition:border-color .2s,box-shadow .2s;-webkit-appearance:none;appearance:none}
input:focus,select:focus,textarea:focus{border-color:var(--brand);box-shadow:0 0 0 3px var(--brandSoft)}
input::placeholder,textarea::placeholder{color:var(--txt3)}
svg{display:block}
::selection{background:var(--brandSoft)}
::-webkit-scrollbar{width:0;height:0}

/* ============ app shell ============ */
#app{min-height:100%;display:flex;flex-direction:column}
.bg-glow{position:fixed;inset:0;pointer-events:none;z-index:0;
  background:
    radial-gradient(52% 38% at 12% -6%, rgba(43,212,242,.14), transparent 62%),
    radial-gradient(46% 34% at 92% 6%, rgba(14,143,178,.12), transparent 62%),
    radial-gradient(60% 40% at 50% 110%, rgba(124,107,240,.08), transparent 65%);
}
header.app-header{
  position:sticky;top:0;z-index:60;
  padding:calc(12px + var(--safe-t)) 18px 12px;
  background:rgba(10,15,30,.78);-webkit-backdrop-filter:blur(22px) saturate(1.5);backdrop-filter:blur(22px) saturate(1.5);
  border-bottom:1px solid rgba(146,170,205,.09);
  display:flex;align-items:center;gap:12px;
}
.brand-mark{width:38px;height:38px;border-radius:12px;flex-shrink:0;overflow:hidden;box-shadow:0 6px 18px rgba(14,143,178,.28)}
.brand-mark img{width:100%;height:100%;display:block;object-fit:cover}
.brand-txt{flex:1;min-width:0}
.brand-txt h1{font-size:16px;font-weight:800;letter-spacing:.2px;display:flex;align-items:center;gap:7px}
.brand-txt p{font-size:11px;color:var(--txt3);margin-top:1px}

.head-actions{display:flex;align-items:center;gap:8px;flex-shrink:0}
.icon-btn{width:36px;height:36px;border-radius:11px;background:var(--card);border:1px solid var(--line);display:flex;align-items:center;justify-content:center;color:var(--txt2);transition:transform .18s var(--spring),background .2s,color .2s}
.icon-btn:active{transform:scale(.9)}
.icon-btn svg{width:17px;height:17px}
.icon-btn.primary{background:var(--grad);color:#04121C;border:none}
.count-chip{display:flex;align-items:center;gap:6px;height:36px;padding:0 12px;border-radius:11px;background:var(--card);border:1px solid var(--line);font-size:12px;font-weight:700;color:var(--txt2);min-width:96px;justify-content:center;transition:border-color .2s}
.count-chip.on{border-color:rgba(43,212,242,.4);color:var(--brand);background:var(--brandSoft)}
.count-ring{width:14px;height:14px;position:relative;flex-shrink:0}
.count-ring svg{transform:rotate(-90deg);width:14px;height:14px}
.count-ring .track{stroke:rgba(146,170,205,.18);fill:none;stroke-width:2}
.count-ring .arc{stroke:var(--brand);fill:none;stroke-width:2;stroke-linecap:round;transition:stroke-dashoffset .5s linear}

main{flex:1;position:relative;z-index:1;padding:14px 16px calc(150px + var(--safe-b))}

/* ============ pull to refresh ============ */
.ptr-wrap{position:relative;overflow:hidden}
.ptr-indicator{height:0;display:flex;align-items:center;justify-content:center;overflow:hidden;transition:height .3s var(--ease);color:var(--txt3);font-size:12px;font-weight:600}
.ptr-indicator .spinner{width:20px;height:20px;margin-right:8px;border:2px solid var(--line2);border-top-color:var(--brand);border-radius:50%;animation:spin .8s linear infinite}
.ptr-indicator.pulling .spinner{animation:none;border-top-color:var(--brand)}
@keyframes spin{to{transform:rotate(360deg)}}

/* ============ hero summary ============ */
.hero{
  position:relative;border-radius:var(--r-lg);padding:18px 18px 16px;margin-bottom:16px;overflow:hidden;
  background:linear-gradient(160deg,rgba(43,212,242,.14),rgba(14,143,178,.05) 55%,transparent),var(--card);
  border:1px solid rgba(43,212,242,.16);
}
.hero::after{content:'';position:absolute;right:-60px;top:-70px;width:220px;height:220px;border-radius:50%;background:radial-gradient(circle,rgba(43,212,242,.16),transparent 65%);pointer-events:none}
.hero-top{display:flex;align-items:flex-end;justify-content:space-between;gap:12px}
.hero-score .lbl{font-size:11px;color:var(--txt3);font-weight:600;letter-spacing:1px}
.hero-score .val{font-size:38px;font-weight:900;line-height:1.15;letter-spacing:-.5px;background:var(--grad);-webkit-background-clip:text;background-clip:text;color:transparent;font-feature-settings:"tnum"}
.hero-score .val small{font-size:14px;font-weight:700}
.hero-right{text-align:right;flex-shrink:0}
.hero-right .big{font-size:22px;font-weight:900;color:var(--ok)}
.hero-right .big span{font-size:12px;color:var(--txt3);font-weight:600}
.hero-right .sub{font-size:11px;color:var(--txt3);margin-top:2px}
.hero-stats{display:flex;gap:10px;margin-top:14px}
.hstat{flex:1;background:rgba(10,15,30,.5);border:1px solid var(--line);border-radius:14px;padding:9px 12px}
.hstat .v{font-size:17px;font-weight:800;font-feature-settings:"tnum"}
.hstat .l{font-size:10px;color:var(--txt3);margin-top:1px;font-weight:600}
.hstat.amber .v{color:var(--warn)} .hstat.cyan .v{color:var(--brand)} .hstat.green .v{color:var(--ok)}

/* ============ buttons & chips ============ */
.fab{
  position:fixed;right:16px;bottom:calc(100px + var(--safe-b));z-index:50;
  display:flex;align-items:center;gap:7px;height:46px;padding:0 16px;border-radius:23px;
  background:var(--grad);color:#04121C;font-size:14px;font-weight:800;letter-spacing:.3px;
  box-shadow:0 10px 28px rgba(14,143,178,.45),inset 0 1px 0 rgba(255,255,255,.3);
  transition:transform .2s var(--spring),box-shadow .2s;animation:fab-in .5s var(--spring) both;
}
.fab:active{transform:scale(.94)}
.fab svg{width:17px;height:17px}
@keyframes fab-in{from{transform:translateY(24px);opacity:0}to{transform:translateY(0);opacity:1}}
.btn{
  display:inline-flex;align-items:center;justify-content:center;gap:6px;height:40px;padding:0 18px;border-radius:13px;
  font-size:14px;font-weight:700;border:1px solid var(--line);background:var(--card);color:var(--txt);
  transition:transform .16s var(--spring),background .2s,border-color .2s;
}
.btn:active{transform:scale(.96)}
.btn.primary{background:var(--grad);color:#04121C;border:none}
.btn.ghost{background:transparent;color:var(--txt2)}
.btn.danger{background:var(--errSoft);color:var(--err);border-color:rgba(249,112,106,.28)}
.btn.sm{height:32px;padding:0 12px;font-size:12px;border-radius:10px}
.btn:disabled{opacity:.5;pointer-events:none}
.chip{display:inline-flex;align-items:center;gap:5px;height:30px;padding:0 12px;border-radius:15px;font-size:12px;font-weight:700;background:var(--card);border:1px solid var(--line);color:var(--txt2);transition:transform .16s var(--spring)}
.chip:active{transform:scale(.94)}
.chip.on{background:var(--brandSoft);border-color:rgba(43,212,242,.35);color:var(--brand)}
.chip .dot{width:6px;height:6px;border-radius:50%;background:currentColor}
.pill{display:inline-flex;align-items:center;gap:5px;height:24px;padding:0 10px;border-radius:12px;font-size:11px;font-weight:700;flex-shrink:0}
.pill.ok{background:var(--okSoft);color:var(--ok)}
.pill.miss{background:var(--errSoft);color:var(--err)}
.pill.cyan{background:var(--brandSoft);color:var(--brand)}
.pill.gray{background:rgba(146,170,205,.12);color:var(--txt2)}
.pill.vio{background:var(--vioSoft);color:var(--vio)}
.pill.amber{background:var(--warnSoft);color:var(--warn)}

/* ============ account cards ============ */
.section-title{display:flex;align-items:center;gap:8px;font-size:13px;font-weight:800;color:var(--txt2);margin:4px 2px 12px;letter-spacing:.5px}
.section-title svg{width:15px;height:15px;color:var(--brand)}
.acc-card{
  position:relative;border-radius:var(--r-lg);padding:16px;margin-bottom:14px;overflow:hidden;
  background:linear-gradient(180deg,rgba(146,170,205,.06),rgba(146,170,205,.03)),var(--card);
  border:1px solid var(--line);
  transition:transform .2s var(--ease);
}
/* 入场动画只在首次渲染播放，避免自动刷新重建卡片时整屏重闪 */
.acc-card.anim-in{animation:card-in .45s var(--ease) both}
.acc-card.error{border-color:rgba(249,112,106,.4);background:linear-gradient(180deg,rgba(249,112,106,.07),transparent),var(--card)}
@keyframes card-in{from{opacity:0;transform:translateY(14px)}to{opacity:1;transform:translateY(0)}}
/* ============ v2.14.14 首页卡片（图3风格） ============ */
.home-card{padding:16px 16px 14px}
.hc-upd{position:absolute;top:12px;right:14px;font-size:10.5px;color:var(--txt3)}
.hc-top{display:flex;align-items:center;gap:8px;margin-bottom:2px}
.hc-name{font-size:19px;font-weight:800;letter-spacing:.3px}
.hc-badge{font-size:10.5px;font-weight:700;padding:3px 9px;border-radius:8px;background:var(--card3);border:1px solid var(--line);color:var(--txt2)}
.hc-badge.on{background:var(--okSoft);border-color:transparent;color:var(--ok)}
.hc-badge.err{background:var(--errSoft);border-color:transparent;color:var(--err)}
.hc-badge.chg{background:var(--brandSoft);border-color:transparent;color:var(--brand)}
.hc-model{font-size:11.5px;color:var(--txt2);margin-bottom:10px}
.hc-mid{display:flex;gap:12px;align-items:center;margin:6px 0 10px}
.hc-left{flex:1;min-width:0}
.hc-big{font-size:38px;font-weight:900;line-height:1.1;letter-spacing:-1px;display:flex;align-items:baseline;gap:8px;flex-wrap:wrap}
.hc-km{font-size:19px;font-weight:800;color:var(--txt)}
.hc-v{font-size:19px;font-weight:800;color:var(--txt2)}
.hc-bar{height:9px;border-radius:6px;background:rgba(146,170,205,.16);overflow:hidden;margin:8px 0 10px}
.hc-fill{height:100%;border-radius:6px;transition:width .7s var(--ease)}
.hc-rows{display:flex;flex-direction:column;gap:3px}
.hc-row{font-size:12px;color:var(--txt2);font-weight:600}
.hc-img{width:118px;height:96px;flex-shrink:0;display:flex;align-items:center;justify-content:center;color:var(--txt3)}
.hc-img img{max-width:100%;max-height:100%;object-fit:contain;filter:drop-shadow(0 6px 14px rgba(0,0,0,.35))}
.hc-img img+svg{display:none}
.hc-img svg{width:72px;height:72px}
.hc-bottom{border-top:1px dashed var(--line2);padding-top:10px;display:flex;flex-direction:column;gap:6px}
.hc-score{display:flex;gap:12px;align-items:baseline;font-size:12px;color:var(--txt2);font-weight:700;flex-wrap:wrap}
.hc-score .signed{color:var(--ok)}
/* 充电中：整张卡片流光（卡面低透明度渐变流动 + 边缘描边流光） */
.home-card.charging{position:relative;z-index:0;border-color:rgba(43,212,242,.28)}
.home-card.charging::before{content:'';position:absolute;inset:0;z-index:-1;border-radius:inherit;pointer-events:none;background:linear-gradient(115deg,rgba(43,212,242,0) 0%,rgba(43,212,242,.10) 22%,rgba(61,220,151,.20) 42%,rgba(43,212,242,.10) 62%,rgba(43,212,242,0) 100%);background-size:220% 220%;animation:hc-flow 3.4s linear infinite}
.home-card.charging::after{content:'';position:absolute;inset:0;border-radius:inherit;padding:1px;pointer-events:none;background:linear-gradient(90deg,rgba(43,212,242,0),#2BD4F2,#3DDC97,rgba(43,212,242,0));background-size:300% 100%;-webkit-mask:linear-gradient(#000 0 0) content-box,linear-gradient(#000 0 0);-webkit-mask-composite:xor;mask:linear-gradient(#000 0 0) content-box,linear-gradient(#000 0 0);mask-composite:exclude;animation:hc-run 2.4s linear infinite}
@keyframes hc-flow{from{background-position:0% 0}to{background-position:220% 0}}
@keyframes hc-run{from{background-position:0% 0}to{background-position:300% 0}}
.hc-score b{color:var(--txt);font-size:13px}
.hc-score .plus{color:var(--brand)}
.hc-score .streak{color:var(--err)}
.acc-head{display:flex;align-items:center;gap:11px;margin-bottom:14px}
.avatar{width:42px;height:42px;border-radius:13px;background:var(--grad);display:flex;align-items:center;justify-content:center;font-weight:900;font-size:17px;color:#04121C;flex-shrink:0;box-shadow:0 4px 14px rgba(14,143,178,.3)}
.avatar.vio{background:var(--grad-vio);color:#140F2E;box-shadow:0 4px 14px rgba(124,107,240,.3)}
.acc-info{flex:1;min-width:0}
.acc-name{font-size:15px;font-weight:800;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
.acc-sub{font-size:11px;color:var(--txt3);margin-top:1px;font-family:ui-monospace,SFMono-Regular,Menlo,monospace}
.acc-actions{display:flex;align-items:center;gap:7px;flex-shrink:0}
.acc-err{font-size:12px;color:var(--err);background:var(--errSoft);border-radius:10px;padding:8px 11px;margin-bottom:12px;font-weight:600}
.kpi-grid{display:grid;grid-template-columns:repeat(4,1fr);gap:8px;margin-bottom:14px}
.kpi{background:rgba(10,15,30,.45);border:1px solid var(--line);border-radius:14px;padding:9px 2px;text-align:center}
.kpi .v{font-size:17px;font-weight:900;font-feature-settings:"tnum";line-height:1.2}
.kpi .l{font-size:9.5px;color:var(--txt3);font-weight:600;margin-top:2px}
.kpi.c1 .v{color:var(--txt)} .kpi.c2 .v{color:var(--ok)} .kpi.c3 .v{color:var(--brand)} .kpi.c4 .v{color:var(--vio)}
.blind{margin-bottom:14px}
.blind-top{display:flex;justify-content:space-between;align-items:center;font-size:11px;color:var(--txt2);font-weight:700;margin-bottom:6px}
.blind-top .r{color:var(--vio);font-feature-settings:"tnum"}
.blind-bar{height:14px;border-radius:8px;background:rgba(146,170,205,.1);overflow:hidden;border:1px solid var(--line)}
.blind-fill{height:100%;border-radius:8px;background:var(--grad-vio);transition:width .7s var(--ease);box-shadow:0 0 12px rgba(124,107,240,.5)}
.week{margin-bottom:4px}
.week-top{display:flex;justify-content:space-between;align-items:center;font-size:11px;color:var(--txt2);font-weight:700;margin-bottom:7px}
.week-grid{display:grid;grid-template-columns:repeat(7,1fr);gap:5px}
.day{aspect-ratio:1;border-radius:9px;display:flex;flex-direction:column;align-items:center;justify-content:center;gap:1px;background:rgba(10,15,30,.5);border:1px solid var(--line)}
.day .d{font-size:9px;color:var(--txt3);font-weight:700;line-height:1}
.day .m{font-size:8px;line-height:1}
.day.ok{background:var(--brandSoft);border-color:rgba(43,212,242,.35)}
.day.ok .d{color:var(--brand)}
.day.today{background:var(--grad);border:none;box-shadow:0 4px 12px rgba(14,143,178,.4)}
.day.today .d{color:#04121C}
.day.today .m{color:rgba(4,18,28,.7)}

/* ============ vehicle section ============ */
.vehicle{
  margin-top:14px;padding-top:14px;border-top:1px dashed var(--line2);cursor:pointer;
}
.vehicle-top{display:flex;align-items:center;gap:12px;margin-bottom:13px}
.vehicle-ring{position:relative;width:74px;height:74px;flex-shrink:0}
.vehicle-ring svg{width:74px;height:74px;transform:rotate(-90deg)}
.vehicle-ring .track{stroke:rgba(146,170,205,.14);fill:none;stroke-width:5}
.vehicle-ring .arc{fill:none;stroke-width:5;stroke-linecap:round;transition:stroke-dashoffset .8s var(--ease),stroke .5s}
.vehicle-ring .pct{position:absolute;inset:0;display:flex;align-items:center;justify-content:center;font-size:17px;font-weight:900;font-feature-settings:"tnum"}
.vehicle-meta{flex:1;min-width:0}
.vehicle-name{font-size:14px;font-weight:800;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
.vehicle-vin{font-size:10px;color:var(--txt3);margin-top:2px;font-family:ui-monospace,SFMono-Regular,Menlo,monospace}
.vin-show{font-size:10px;font-weight:700;color:var(--brand);margin-left:4px;padding:1px 6px;border-radius:5px;background:var(--brandSoft)}
.vehicle-badges{display:flex;gap:5px;margin-top:7px;flex-wrap:wrap}
.vstat-row{display:flex;gap:6px;flex-wrap:wrap;margin-bottom:12px}
.vstat{display:inline-flex;align-items:center;gap:5px;height:26px;padding:0 11px;border-radius:13px;font-size:11px;font-weight:700}
.vstat svg{width:12px;height:12px}
.vstat.on{background:var(--okSoft);color:var(--ok)}
.vstat.off{background:rgba(146,170,205,.1);color:var(--txt2)}
.vstat.locked{background:var(--errSoft);color:var(--err)}
.vstat.unlocked{background:var(--okSoft);color:var(--ok)}
.vstat.seat{background:var(--vioSoft);color:var(--vio)}
.charge-banner{display:flex;align-items:center;gap:9px;background:var(--okSoft);border:1px solid rgba(61,220,151,.25);border-radius:12px;padding:9px 12px;margin-bottom:12px}
.charge-banner svg{width:15px;height:15px;color:var(--ok);flex-shrink:0}
.charge-banner .ct{font-size:13px;font-weight:800;color:var(--ok)}
.charge-banner .ce{font-size:11px;color:var(--ok);opacity:.85;margin-left:auto;background:rgba(61,220,151,.15);padding:2px 9px;border-radius:10px}
.vkpi-grid{display:grid;grid-template-columns:repeat(4,1fr);gap:7px;margin-bottom:12px}
.vkpi{background:rgba(10,15,30,.45);border:1px solid var(--line);border-radius:12px;padding:8px 2px;text-align:center}
.vkpi .v{font-size:14px;font-weight:900;font-feature-settings:"tnum"}
.vkpi .l{font-size:9px;color:var(--txt3);font-weight:600;margin-top:2px}
.batt-track{height:9px;border-radius:5px;background:rgba(146,170,205,.1);overflow:hidden;margin-bottom:12px;border:1px solid var(--line)}
.batt-fill{height:100%;border-radius:5px;transition:width .8s var(--ease),background .5s;box-shadow:0 0 10px currentColor}
.meta-row{display:flex;gap:8px;flex-wrap:wrap;margin-bottom:6px}
.meta-item{display:inline-flex;align-items:center;gap:6px;font-size:11px;color:var(--txt2);background:rgba(10,15,30,.45);border:1px solid var(--line);border-radius:9px;padding:5px 9px;font-weight:600}
.meta-item svg{width:12px;height:12px;color:var(--brand)}
.meta-item b{color:var(--txt)}
.vehicle-addr{display:flex;align-items:center;gap:8px;margin-top:4px;margin-bottom:10px;font-size:11px;color:var(--txt3)}
.vehicle-addr .at{flex:1;min-width:0;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
.vehicle-addr svg{width:13px;height:13px;color:var(--warn);flex-shrink:0}
.map-btn{height:26px;padding:0 11px;border-radius:13px;font-size:11px;font-weight:700;background:var(--brandSoft);color:var(--brand);border:1px solid rgba(43,212,242,.3);flex-shrink:0;transition:transform .16s var(--spring)}
.map-btn:active{transform:scale(.94)}
.map-btn:disabled{opacity:.45;pointer-events:none}
.ctrl-grid{display:grid;grid-template-columns:repeat(5,1fr);gap:6px;border-top:1px dashed var(--line2);padding-top:12px}
.ctrl-btn{display:flex;flex-direction:column;align-items:center;gap:5px;padding:10px 2px;border-radius:13px;background:rgba(10,15,30,.5);border:1px solid var(--line);font-size:10.5px;font-weight:700;color:var(--txt2);transition:transform .16s var(--spring),background .2s,border-color .2s,color .2s}
.ctrl-btn svg{width:17px;height:17px;color:var(--txt2);transition:color .2s}
.ctrl-btn:active{transform:scale(.92)}
.ctrl-btn.unlock{border-color:rgba(61,220,151,.3);color:var(--ok)}
.ctrl-btn.unlock svg{color:var(--ok)}
.ctrl-btn.lock{border-color:rgba(249,112,106,.3);color:var(--err)}
.ctrl-btn.lock svg{color:var(--err)}
.ctrl-btn:disabled{opacity:.5;pointer-events:none}
.ctrl-btn.busy svg{animation:spin .8s linear infinite}
.no-vehicle{padding:14px;border-radius:14px;background:var(--warnSoft);border:1px solid rgba(247,185,85,.25);color:var(--warn);font-size:12px;font-weight:600;text-align:center}

/* ============ empty & skeleton ============ */
.empty{padding:70px 26px;text-align:center;animation:card-in .4s var(--ease) both}
.empty .e-icon{width:74px;height:74px;margin:0 auto 18px;border-radius:24px;background:var(--card);border:1px solid var(--line);display:flex;align-items:center;justify-content:center;color:var(--txt3)}
.empty .e-icon svg{width:34px;height:34px}
.empty h3{font-size:17px;font-weight:800;margin-bottom:6px}
.empty p{font-size:13px;color:var(--txt2);line-height:1.7;max-width:300px;margin:0 auto 20px}
.sk{background:linear-gradient(100deg,rgba(146,170,205,.06) 40%,rgba(146,170,205,.12) 50%,rgba(146,170,205,.06) 60%);background-size:200% 100%;animation:sk 1.2s linear infinite;border-radius:10px}
@keyframes sk{to{background-position:-200% 0}}
.sk-card{border-radius:var(--r-lg);border:1px solid var(--line);padding:16px;margin-bottom:14px;background:var(--card)}
.sk-line{height:13px;margin-bottom:10px}.sk-line.w40{width:40%}.sk-line.w60{width:60%}.sk-line.w80{width:80%}
.sk-row{display:grid;grid-template-columns:repeat(4,1fr);gap:8px;margin:14px 0}
.sk-cell{height:52px;border-radius:12px}
.sk-bar{height:14px;border-radius:8px;margin-top:12px}

/* ============ logs ============ */
.log-panel{background:var(--card);border:1px solid var(--line);border-radius:var(--r-lg);overflow:hidden;animation:card-in .4s var(--ease) both}
.log-head{display:flex;align-items:center;justify-content:space-between;gap:10px;padding:14px 16px;border-bottom:1px solid var(--line)}
.log-head h3{font-size:14px;font-weight:800;display:flex;align-items:center;gap:8px}
.log-head h3 svg{width:16px;height:16px;color:var(--vio)}
.log-filters{display:flex;gap:6px}
.log-list{max-height:calc(100vh - 260px);overflow-y:auto;-webkit-overflow-scrolling:touch}
.log-item{padding:12px 16px;border-bottom:1px solid rgba(146,170,205,.07);animation:card-in .3s var(--ease) both}
.log-item:last-child{border-bottom:none}
.log-time{font-size:10px;color:var(--txt3);margin-bottom:3px;font-feature-settings:"tnum"}
.log-main{display:flex;align-items:center;gap:8px;flex-wrap:wrap;font-size:13px}
.log-user{font-weight:800}
.log-res{font-weight:800;color:var(--ok)}
.log-res.err{color:var(--err)}
.log-steps{margin-top:6px;font-size:11.5px;color:var(--txt2);line-height:1.7;padding-left:2px}
.log-steps i{font-style:normal;color:var(--brand);margin-right:5px}
.log-empty{padding:50px 20px;text-align:center;color:var(--txt3);font-size:13px}

/* ============ config ============ */
.cfg-panel{background:var(--card);border:1px solid var(--line);border-radius:var(--r-lg);margin-bottom:16px;overflow:hidden;animation:card-in .4s var(--ease) both}
.cfg-head{display:flex;align-items:center;justify-content:space-between;gap:10px;padding:15px 16px;border-bottom:1px solid var(--line)}
.cfg-head h3{font-size:14px;font-weight:800;display:flex;align-items:center;gap:8px}
.cfg-head h3 svg{width:16px;height:16px}
.cfg-head .bar{width:3px;height:15px;border-radius:2px;background:var(--brand);flex-shrink:0}
.cfg-head .bar.amber{background:var(--warn)} .cfg-head .bar.green{background:var(--ok)} .cfg-head .bar.vio{background:var(--vio)}
.cfg-body{padding:16px}
.form-grid{display:grid;grid-template-columns:1fr 1fr;gap:12px}
.f-item{min-width:0}
.f-item.full{grid-column:1/-1}
.f-item label{display:block;font-size:11px;color:var(--txt2);font-weight:700;margin-bottom:6px}
.f-item .hint{font-size:10.5px;color:var(--txt3);margin-top:5px;line-height:1.6}
.f-item .hint code{background:rgba(146,170,205,.12);padding:1px 5px;border-radius:5px;font-size:10px;font-family:ui-monospace,Menlo,monospace}
.switch{display:flex;align-items:center;gap:10px;padding:10px 12px;background:rgba(10,15,30,.45);border:1px solid var(--line);border-radius:12px;cursor:pointer;transition:border-color .2s}
.switch:active{transform:scale(.98)}
.switch .lbl{font-size:12.5px;font-weight:600;flex:1}
.switch .sc{font-size:10px;color:var(--txt3)}
.sw{position:relative;width:44px;height:26px;border-radius:13px;background:rgba(146,170,205,.2);transition:background .25s var(--ease);flex-shrink:0}
.sw::after{content:'';position:absolute;top:2px;left:2px;width:22px;height:22px;border-radius:50%;background:#fff;transition:transform .25s var(--spring);box-shadow:0 2px 6px rgba(0,0,0,.35)}
.switch input{display:none}
.switch input:checked+.sw{background:var(--grad)}
.switch input:checked+.sw::after{transform:translateX(18px)}
.acc-edit{background:rgba(10,15,30,.4);border:1px solid var(--line);border-radius:16px;padding:14px;margin-bottom:12px}
.acc-edit-head{display:flex;justify-content:space-between;align-items:center;margin-bottom:12px}
.acc-edit-title{font-size:13px;font-weight:800;display:flex;align-items:center;gap:8px}
.acc-edit-title .n{width:24px;height:24px;border-radius:8px;background:var(--brandSoft);color:var(--brand);display:flex;align-items:center;justify-content:center;font-size:11px;font-weight:900}
.acc-edit-head .acts{display:flex;gap:6px}
.btn-row{display:flex;gap:10px;margin-top:16px;flex-wrap:wrap}
.btn-row .btn{flex:1;min-width:120px}
.cfg-note{font-size:10.5px;color:var(--txt3);line-height:1.7;padding:12px 14px;background:rgba(247,185,85,.07);border:1px solid rgba(247,185,85,.18);border-radius:12px;margin-top:12px}
.cfg-note b{color:var(--warn)}

/* ============ tabbar ============ */
nav.tabbar{
  position:fixed;left:0;right:0;bottom:0;z-index:60;
  display:flex;padding:8px 10px calc(8px + var(--safe-b));
  background:rgba(10,15,30,.82);-webkit-backdrop-filter:blur(24px) saturate(1.6);backdrop-filter:blur(24px) saturate(1.6);
  border-top:1px solid rgba(146,170,205,.1);
}
.tab{flex:1;display:flex;flex-direction:column;align-items:center;gap:3px;padding:6px 0;border-radius:14px;color:var(--txt3);font-size:10px;font-weight:700;transition:color .2s,transform .16s var(--spring)}
.tab svg{width:22px;height:22px}
.tab:active{transform:scale(.9)}
.tab.on{color:var(--brand)}
.tab .t-ind{width:14px;height:3px;border-radius:2px;background:transparent;transition:background .25s}
.tab.on .t-ind{background:var(--brand)}

/* ============ sheets & toast ============ */
.sheet-backdrop{position:fixed;inset:0;z-index:100;background:rgba(4,8,18,.55);-webkit-backdrop-filter:blur(6px);backdrop-filter:blur(6px);opacity:0;pointer-events:none;transition:opacity .3s var(--ease)}
.sheet-backdrop.show{opacity:1;pointer-events:auto}
.sheet{position:fixed;left:0;right:0;bottom:0;z-index:101;max-height:86vh;display:flex;flex-direction:column;
  background:linear-gradient(180deg,var(--card2),var(--bg2));border:1px solid var(--line2);border-bottom:none;
  border-radius:26px 26px 0 0;transform:translateY(104%);transition:transform .38s var(--spring);
  box-shadow:0 -18px 50px rgba(0,0,0,.5)}
.sheet.show{transform:translateY(0)}
.sheet-grab{width:38px;height:4px;border-radius:2px;background:rgba(146,170,205,.3);margin:10px auto 4px;flex-shrink:0}
.sheet-head{display:flex;align-items:center;justify-content:space-between;padding:6px 20px 12px}
.sheet-head h3{font-size:16px;font-weight:800;display:flex;align-items:center;gap:9px}
.sheet-head h3 svg{width:18px;height:18px}
.sheet-close{width:32px;height:32px;border-radius:10px;background:var(--card);border:1px solid var(--line);display:flex;align-items:center;justify-content:center;color:var(--txt2)}
.sheet-close svg{width:16px;height:16px}
.sheet-close:active{transform:scale(.9)}
.sheet-body{padding:4px 20px 24px;overflow-y:auto;-webkit-overflow-scrolling:touch}
.sr-item{display:flex;justify-content:space-between;align-items:center;gap:12px;padding:11px 0;border-bottom:1px solid rgba(146,170,205,.08);font-size:13px}
.sr-item:last-child{border-bottom:none}
.sr-item .k{color:var(--txt2);font-weight:600;flex-shrink:0}
.sr-item .v{text-align:right;font-weight:800}
.sr-item .v.mono{font-family:ui-monospace,Menlo,monospace;font-size:12px}
.sig-result{max-height:52vh;overflow-y:auto;-webkit-overflow-scrolling:touch}
.sig-card{border-radius:16px;padding:13px 14px;margin-bottom:10px;border:1px solid var(--line)}
.sig-card.ok{background:var(--okSoft);border-color:rgba(61,220,151,.25)}
.sig-card.fail{background:var(--errSoft);border-color:rgba(249,112,106,.28)}
.sig-card .h{display:flex;justify-content:space-between;align-items:center;font-size:14px;font-weight:800;margin-bottom:6px}
.sig-card .h .r{font-size:12px}
.sig-card.ok .h .r{color:var(--ok)} .sig-card.fail .h .r{color:var(--err)}
.sig-card .steps{font-size:12px;color:var(--txt2);line-height:1.8}
.sig-card .steps i{font-style:normal;color:var(--brand);margin-right:5px}
.sig-card .steps .err{color:var(--err)}
#toast{position:fixed;left:50%;top:calc(18px + var(--safe-t));transform:translateX(-50%) translateY(-16px);z-index:200;
  display:flex;align-items:center;gap:8px;max-width:86vw;padding:11px 18px;border-radius:14px;font-size:13px;font-weight:700;
  background:rgba(17,26,46,.92);border:1px solid var(--line2);box-shadow:0 10px 34px rgba(0,0,0,.45);
  opacity:0;pointer-events:none;transition:opacity .25s,transform .3s var(--spring)}
#toast.show{opacity:1;transform:translateX(-50%) translateY(0)}
#toast svg{width:16px;height:16px;flex-shrink:0}
#toast.ok{color:var(--ok)} #toast.err{color:var(--err)} #toast.info{color:var(--brand)}
#toast.ok svg{color:var(--ok)} #toast.err svg{color:var(--err)} #toast.info svg{color:var(--brand)}
.confirm-layer{position:fixed;inset:0;z-index:150;display:flex;align-items:center;justify-content:center;padding:30px}
.confirm{width:min(340px,90vw);background:var(--card2);border:1px solid var(--line2);border-radius:20px;padding:22px 20px 18px;text-align:center;box-shadow:0 24px 60px rgba(0,0,0,.55);animation:card-in .3s var(--spring) both}
.confirm .ct{font-size:15px;font-weight:800;margin-bottom:6px}
.confirm .cd{font-size:12.5px;color:var(--txt2);line-height:1.7;margin-bottom:18px}
.confirm .cb{display:flex;gap:10px}
.confirm .cb button{flex:1;height:42px;border-radius:13px;font-size:14px;font-weight:700}
.confirm .cb .no{background:var(--card);border:1px solid var(--line);color:var(--txt2)}
.confirm .cb .yes{background:var(--grad);color:#04121C}

/* ============ misc ============ */
.foot{text-align:center;padding:10px 0 4px;font-size:10.5px;color:var(--txt3);line-height:1.8}
.foot .link{color:var(--brand);text-decoration:none;font-weight:700}
.hidden{display:none!important}
@keyframes pulse{0%,100%{opacity:1}50%{opacity:.45}}
.pulse{animation:pulse 1.6s ease-in-out infinite}
@media (prefers-reduced-motion:reduce){
  *{animation-duration:.01ms!important;transition-duration:.01ms!important}
}
@media (min-width:700px){
  main{max-width:680px;margin:0 auto}
}
@media (max-width:699px){
  input[type=text],input[type=password],input[type=number],textarea{font-size:16px!important}
}

/* ============ v2.14.9 积分 / 车辆页组件 ============ */
.acc-chips{display:flex;gap:7px;overflow-x:auto;padding:2px 0 12px;-webkit-overflow-scrolling:touch}
.acc-chips::-webkit-scrollbar{display:none}
.acc-chip{flex-shrink:0;padding:7px 15px;border-radius:999px;background:var(--card);border:1px solid var(--line);font-size:12px;font-weight:700;color:var(--txt2)}
.acc-chip.on{background:var(--grad);color:#fff;border-color:transparent;box-shadow:0 4px 14px var(--brandSoft)}
.pt-grid{display:grid;grid-template-columns:1fr 1fr;gap:10px;margin-bottom:14px}
.pt-cell{background:var(--card);border:1px solid var(--line);border-radius:var(--r-md);padding:13px 14px;animation:card-in .4s var(--ease) both}
.pt-cell .lb{font-size:11px;color:var(--txt3);font-weight:600;margin-bottom:5px}
.pt-cell .vl{font-size:22px;font-weight:800;line-height:1.15}
.pt-cell .sub{font-size:10px;color:var(--txt3);margin-top:3px}
.panel-card{background:var(--card);border:1px solid var(--line);border-radius:var(--r-lg);padding:15px;margin-bottom:14px;animation:card-in .4s var(--ease) both}
.panel-card .pc-head{display:flex;align-items:center;justify-content:space-between;margin-bottom:11px}
.panel-card .pc-head h4{font-size:14px;font-weight:800;display:flex;align-items:center;gap:7px}
.panel-card .pc-head h4 svg{width:16px;height:16px;color:var(--brand)}
.cal-grid{display:grid;grid-template-columns:repeat(7,1fr);gap:5px}
.cal-wd{font-size:10px;color:var(--txt3);text-align:center;font-weight:700;padding-bottom:3px}
.cal-d{aspect-ratio:1;border-radius:9px;display:flex;flex-direction:column;align-items:center;justify-content:center;font-size:11px;font-weight:700;background:var(--card3);color:var(--txt2);border:1.5px solid transparent}
.cal-d.signed{background:var(--okSoft);color:var(--ok)}
.cal-d.miss{background:var(--errSoft);color:var(--err)}
.cal-d.today{border-color:var(--brand)}
.cal-d.future{opacity:.38}
.cal-d.blank{background:transparent}
.cal-d .dot{font-size:8px;line-height:1;margin-top:1px}
.vc-grid{display:grid;grid-template-columns:repeat(3,1fr);gap:9px}
.vc-btn{background:var(--card3);border:1px solid var(--line);border-radius:var(--r-md);padding:13px 6px;display:flex;flex-direction:column;align-items:center;gap:7px;font-size:12px;font-weight:700;color:var(--txt)}
.vc-btn svg{width:21px;height:21px;color:var(--brand)}
.vc-btn:active{transform:scale(.94)}
.opt-row{display:flex;flex-wrap:wrap;gap:8px;margin:9px 0}
.opt-chip{padding:8px 14px;border-radius:10px;background:var(--card3);border:1px solid var(--line);font-size:12px;font-weight:700;color:var(--txt2)}
.opt-chip.on{background:var(--brandSoft);border-color:var(--brand);color:var(--brand)}
.flow-item{display:flex;justify-content:space-between;align-items:center;padding:11px 2px;border-bottom:1px solid var(--line)}
.flow-item:last-child{border-bottom:none}
.flow-item .nm{font-size:13px;font-weight:600}
.flow-item .tm{font-size:10px;color:var(--txt3);margin-top:2px}
.flow-item .sc{font-size:14px;font-weight:800}
.flow-item .sc.plus{color:var(--ok)}
.flow-item .sc.minus{color:var(--err)}
.mon-row{display:flex;justify-content:space-between;align-items:center;padding:9px 2px;border-bottom:1px solid var(--line);font-size:13px}
.mon-row:last-child{border-bottom:none}
.mon-row .k{color:var(--txt3);font-weight:600}
.mon-row .v{font-weight:700}
/* ============ v2.16.0 骑行页组件 ============ */
.rt-grid{display:grid;grid-template-columns:repeat(3,1fr);gap:8px;margin-bottom:8px}
.rt-grid3{display:grid;grid-template-columns:repeat(3,1fr);gap:8px}
.rt-cell{background:var(--card3);border:1px solid var(--line);border-radius:var(--r-md);padding:10px 11px}
.rt-cell .lb{font-size:10.5px;color:var(--txt3);font-weight:600;margin-bottom:4px}
.rt-cell .vl{font-size:19px;font-weight:800;line-height:1.1}
.rt-cell .vl .u{font-size:10px;color:var(--txt3);font-weight:700;margin-left:2px}
.rt-cell .vl.brand{color:var(--brand)}
.rt-day{background:var(--card3);border:1px solid var(--line);border-radius:var(--r-md);padding:10px 12px;margin-bottom:8px}
.rt-day:last-child{margin-bottom:0}
.rt-top{display:flex;align-items:baseline;justify-content:space-between;gap:8px}
.rt-date{font-size:13px;font-weight:800}
.rt-date .wd{font-size:10px;color:var(--txt3);font-weight:600;margin-left:5px}
.rt-km{font-size:11.5px;color:var(--txt2);font-weight:700}
.rt-chips{display:flex;flex-wrap:wrap;gap:6px;margin-top:7px}
.rt-chip{font-size:10.5px;font-weight:700;color:var(--txt2);background:var(--card);border:1px solid var(--line);border-radius:8px;padding:3px 8px}
.rt-chip b{color:var(--brand);font-weight:800;margin-left:2px}
.rt-chip.cal b{color:var(--ok)}
.rt-chip.link{cursor:pointer;color:var(--brand);border-color:var(--brandSoft)}
/* ============ 入场闪屏：首帧即显示，数据就绪后淡出 ============ */
#splash{position:fixed;inset:0;z-index:999;display:flex;flex-direction:column;align-items:center;justify-content:center;background:radial-gradient(120% 60% at 50% 0%,rgba(14,143,178,.16),transparent 60%),var(--bg);transition:opacity .4s var(--ease),transform .4s var(--ease)}
#splash.out{opacity:0;transform:scale(1.04);pointer-events:none}
.sp-mark{width:84px;height:84px;border-radius:24px;background:var(--grad);display:flex;align-items:center;justify-content:center;box-shadow:0 14px 40px rgba(14,143,178,.4);animation:sp-in .5s var(--spring) both}
.sp-mark svg{width:46px;height:46px}
.sp-title{margin-top:20px;font-size:21px;font-weight:900;letter-spacing:1px;animation:sp-up .4s .05s var(--ease) both}
.sp-sub{margin-top:7px;font-size:12px;color:var(--txt3);letter-spacing:3px;animation:sp-up .4s .1s var(--ease) both}
.sp-load{margin-top:34px;display:flex;align-items:center;gap:9px;font-size:12px;color:var(--txt2);animation:sp-up .4s .15s var(--ease) both}
.sp-load .spinner{width:16px;height:16px;border:2px solid var(--line2);border-top-color:var(--brand);border-radius:50%;animation:spin .7s linear infinite}
@keyframes sp-in{from{opacity:0;transform:scale(.6) translateY(10px)}to{opacity:1;transform:scale(1) translateY(0)}}
@keyframes sp-up{from{opacity:0;transform:translateY(12px)}to{opacity:1;transform:translateY(0)}}
</style>
</head>
<body>
<div class="bg-glow"></div>
<div id="splash">
  <div class="sp-mark"><svg viewBox="0 0 24 24" fill="none"><path d="M4 13.5C4 9.08 7.58 5.5 12 5.5s8 3.58 8 8" stroke="#04121C" stroke-width="2.4" stroke-linecap="round"/><path d="M12 13l7.5 5.5" stroke="#04121C" stroke-width="2.4" stroke-linecap="round"/><circle cx="7.5" cy="16.5" r="2.2" fill="#04121C"/><circle cx="17" cy="19" r="2.2" fill="#04121C"/></svg></div>
  <div class="sp-title">极核 ZEEHO</div>
  <div class="sp-sub">签到 · 车辆 · 控车</div>
  <div class="sp-load"><span class="spinner"></span>正在加载数据…</div>
</div>
<div id="app">
  <header class="app-header">
    <div class="brand-mark"><img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAJAAAACQCAYAAADnRuK4AAAAAXNSR0IArs4c6QAAAFBlWElmTU0AKgAAAAgAAgESAAMAAAABAAEAAIdpAAQAAAABAAAAJgAAAAAAA6ABAAMAAAABAAEAAKACAAQAAAABAAAAkKADAAQAAAABAAAAkAAAAAAt4iSWAAABWWlUWHRYTUw6Y29tLmFkb2JlLnhtcAAAAAAAPHg6eG1wbWV0YSB4bWxuczp4PSJhZG9iZTpuczptZXRhLyIgeDp4bXB0az0iWE1QIENvcmUgNi4wLjAiPgogICA8cmRmOlJERiB4bWxuczpyZGY9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyMiPgogICAgICA8cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0iIgogICAgICAgICAgICB4bWxuczp0aWZmPSJodHRwOi8vbnMuYWRvYmUuY29tL3RpZmYvMS4wLyI+CiAgICAgICAgIDx0aWZmOk9yaWVudGF0aW9uPjE8L3RpZmY6T3JpZW50YXRpb24+CiAgICAgIDwvcmRmOkRlc2NyaXB0aW9uPgogICA8L3JkZjpSREY+CjwveDp4bXBtZXRhPgoZXuEHAAANCElEQVR4Ae1dW0wVSRouRIKiYkhEomIwizhR4o1VJzqrUXgwWTXe0KhxJEZdvCWjkMyriY9Gxls0EV+cjMYb3jPRlxGdHRPd0Yk87EZWUNdRE0RFERFEYP+v7T6ec7rOpft0w6nT/5/89Om6ddVXX6qqu/76SRI9JN3d3f3oUbmko0lHkWbpmknXdNKBpINI00hTSVN0TaYrtA9pkp/Sz4STbmqRoV30u1PXDrpC20lbSd+RtpA2kzaSNuj6mK51pPVJSUltdHVd0CGuCBFmHBVcRDpV16/o6trzqGyWLwiAhLWkv+v6CxHqP1+infvlaIcSaQqoav8gnUea7Vw1uSQHEHhKZfxMWklk+sOB8rQiYiYQkQZlFJN+R/qNVir/iXcEblIF95FWEZkwWtmWmAhE5PkbPfkHUkxTLOohgCmujEj0m92q2yIQESeDHniQdKXdB3O+uELgBNVmCxGpyWqtLBOIyDOLHnKMdKTVh3H6uEbgT6rdaiLRr1ZqiVfjqIXIU06Jq0mZPFGjpkxC9Gm13sdRVzqqEYgKRboK0u1Rl8wJVUZgD1W+PJoFdkQC6eT5kQr8VmVEuO6WEfiJcpREIlE0UxhGHiaPZfyVz4A+R9+HlbAE0udDnrbCQpjQkdsjrYlCTmGUEW9bWDCHJVlCw8eNAwLYk5sT6u1MSiAiD77z1JBiZc7CCOAVfyKRyPSdKNTogo+ETB4mjoEAuABOmMQ0AtHog+2Jf5pScgAjIMRMGoUCtj0CCETkwf1tUt7bYrrIEMDe2ddEIt8GbPAUhl11Jo8MOg4DAuAGOOKTYALBJIOFEQiHQABHfFMYTV8wBrsbLifHMQI6An+laUwzSvMfgUoZHkYgSgRgdaqJ/wiEd302Q9WB4UtYBJ7SCKR95tFGIJq+8pk8YQHjyEAEsokzODTh26YoDIznO0YgIgJFSGGsgaZFTM4JGIFABDTOGATibz+B4PBdZAQ0ziTRXIYTozjt6FtQR87LKRgB7QRtGkagXFImDzPCKgLgTC4IlGc1J6dnBHQE8kCgHIaDEbCJQA4IBC8ZLIyAHQSymEB2YOM8BgIagTKNO74yAhYRyMQIBOdOLIyAHQTSQSB4BmNhBOwgMBAEGmQnJ+dhBMAdEAg+CVkYATsIaF+i4dCShRGwg0AqRiB4Q2VhBOwgkMIEsgMb5zEQ0AiUbNzxlRGwiEAyRiAmkEXUOLkPAY1AIBELI2AHgT4gD9sC2YGO8wCBJCYQEyEWBJL6gkWxlBApb1VVlWhowP8CYQECnZ2dYtmyZWLYsGFSQO7evStu3boljbMaOHr0aDF37lyr2aykTxJkE+2qTJgwAZ4cWHUMSktLu1tbW6WYE3G6MzMzHcNq4cKF0uc4GYgRyFXp37+/q+WrVDiRRxw6dEj00ZaegTWvqakRS5cuFY2NjYERMdylprq/ycBvYDF0kJWsa9asEQcOHJCSp7a2VixevFg8e/bMSpFxkZYJ1APdUFxcLA4fPixSUsy7Ro8ePRKLFi0SuKooTCCXe23evHni6NGjol8/HL8LFIw4S5YsEffv3w+MUOiOCeRiZ82ZM0ccP35cDBgwwPQUrHUwMt27d88Up1IAE8il3po+fbo4ffq0GDx4sOkJb968EcuXL3fsdd30gB4MYAK5APbkyZMFvn8NGTLEVHpLS4tYtWqVuH79uilOxQAmkMO9NnbsWHHu3DkxfPhwU8ltbW2ipKREXLlyxRSnagATyMGey83NFRcuXBCjRo0yldrR0SE2bNigkcsUqXAAE8ihzsvOzhbnz58XY8aMMZXY1dUltm7dKo4dwz96TCxhAjnQn0OHDhVnz54V48ePl5ZWXl4uKisrpXGqBzKBYuzBjIwMcebMGTFtmtnJ28ePH0VZWZnYu3dvjE+J3+yu74U50fT09HQxe/ZsQZ5BnSjOsTKwp7V582Yxaxb+M5ZZ7ty5I+rq6gRtapojw4S0t7eLa9euCRAw3kUJAuXk5IiLFy/GO5am+s2YMUNcunTJFB4pAN+J8vLyxMuXLyMl7fV4JaYwMj8QeIvximAEQptVECUIpAKQXq2jMgRKTvbO4RGZvVC8ElSJNRDMQF+8eCE1h+gJYDGd4FsOWQuGXMg3Nzc7Ns2+evVKmSlMCQI9ePBAkGlsyM5zk0QGeXbs2KF9DJQ9C/ta69atE9jnckJAViykVRAlCPTp0ydHTT2tdsy2bdvEli1bpASGATx21p00RbVav95Mr8waqLdA2rRpk6ioqJCaosKWx2k75t5qp93nMoHCIIed8/3790vJAytCWBM+f/48TAmJH8UECtHHOLsFO+a+fc2z/MOHD5W2Yw7RZFvBTCAJbPPnz9fsmGXHYgw7ZpykYPny754YCx2BoqIizewiLc3s+Q+fErDmwRkuls8I8AjkxwTsXZ08eVJqx9zU1KS9bd2+fdsvB/9kAukcKCgoiGjHfOPGDWZMEAJMIAIkPz9fMzWVOTyAHTNOlV69ejUIOr4FAp4nEDxYwBQVJiPBAguA9evXa/HBcXz/GQFPE2jkyJHayAPbm2DBdgK+PuNgIEtoBDxLoKysLI08MjtmkAfbF0eOHAmNHMdoCJi/ksUhMDBllX3Qs1tVHPjDqdEpU6aYisDO/86dO8XBgwd7bfcflVLFgE4JAmGdglMPTpAIu+s4bjxixAgTeYwAbI6uWLHCuO3xK8w5FixYoMSOvBIEgmcL2VTjRs/CcA1vZb0pr1+/FqoY0CmxBsKoocqQ7gTxVGqrEgRyolO4DHcQUIJAsBGWefdyB5LeLxX7cPF2Bi4UKkqsgWBzg9dqK+sCwxQVZ9KxCJdJdXW1uHz5ctx11vv37wVUBVGCQDhgt2/fPst44lgxPhbKBHbMcGz59u1bWTSHRYmAEgSKsi0ByeDQYPfu3QFhxo1hx8zkMRCxf1ViDWS1eRs3bhS7du2SZoMdM3wTetUIXgpKDIEJRyDYMYfyx2zYMavojzmGPnY1a0IRyPDHLPtiDT/MWPOo6o/ZVRbEUHjCEMjwxxzKjhnkUdkfcwx97GrWhCBQYWFhWH/MbMfsHoeUJxD8MZ86dUpqx2z4Y2Y7ZiaQFAH4Y8YufSh/zCtXrkwYf8xSAOIgUNkRaNy4cWHtmPE2xnbM7jNMSQLBHzPsmL3kj9l9Kth7gnIEgj9meIL3mj9me93rfi7XCfThwwfHWgF/zCAPfAUFC56DL9CJ6o85uL3R3MPXotvi+l7Y2rVrxZMnTxxpBxweTJ06VVpWfX29wL/XxK69KqYQ0oY4GDhp0iQHS5MXlURmD10UFV8OmOV15dD4Q6AbU5ga/mTjDzyuEXGHCcQ0iAUBjUCYwlgYATsIdGEE6rSTk/MwAuAOE4h5EAsCGoG8808oYoGK88oQ6MAIxASSQcNh0SCgEcj9z5XRVIXTqIhAO0agVhVrznWOCwRaQaB3cVEVroSKCLwDgZz5DyEqNp/rHCsCLSBQc6ylcH7PItAMAjV6tvnc8FgRaASBGmIthfN7FoEGJpBn+96RhmsEeuxIUVyIFxF4jBGozost5zY7gkAdLBL7UVH4mMhWiY5g6plCYIiY1ofsh9vox38902xuqFMI1II7mMIgv3++8F9GIGoENM4YBPpX1Nk4ISPwGYEAAv3CqDACFhHQOONbONNi+k8qINtiIZzcmwg8pfWP5r3UmMIAw8/exIJbbQMBH1f8CVRpoyDO4k0EfFzxEYiGpD8Ii5vexINbbQGBmzpXtCw+AukFWPfmbeHJnDQhEAjgiG8RjabRQhr3+L/Wcg8GSMTiZQTw6v41jUC+4/ABI5AeUeZlhLjtYREo8ycPUgYQCAGU4De6nMBvFkbAD4ETOjf8gkJsoNJUlkGpaki1d/2AHHzjRQTwjXAiEagpuPGmEQgJ9ISr6Sc7XghGzHv34MBqGXkAhZRAiKAMv9Lle/xm8TQC3+tckIIQ8BYmS0HT2Q8Uvl0Wx2EJj8AeIk/Yl6poCIQ0P5J+m/BwcQP9EfiJbkqIQL5Xdv9I43fIKcxIoBdQQvd7jDC+JjwC6OuI5AEKEUcgf6hoOiune/wnt4jE88/Hv5VBAAtmrHkqoq2xJQKhUCLRLLocI+VXfACSOIJXdbxt4eUparE8kugPmEhP4I+NUcMc9wnRl/jOY4k8aJVlAiETPaiJdBX9nEnK9tQARU1B381EX6JP7TTB8hQW/BCa0lBGMel3pN8Ex/N9XCIAsx3sqlcRccK+ZUWqfcwE8n8AkamA7ktJ/07K5rH+4PT+76dUBVgSVhJpYPvliDhKIP8aEZny6b6QdBopzEPGkLr2PCqb5QsCGFVw1g9TFE7cXCPS/JuujkuPdSgRqj/V/i+keaQ5pFm6ZtI1nXQg6SDSNNJU0hRdk+kKxXoN9TWUfiacoOMNxSt1p65whAqFP0ucIoZXOTgGg2+nRlJ4WIH+j/QBaT0RBgdGXZf/A7Y1d/5IJZddAAAAAElFTkSuQmCC" alt="ZEEHO"></div>
    <div class="brand-txt">
      <h1>极核 ZEEHO</h1>
      <p>签到 · 车辆 · 控车</p>
    </div>
    <div class="head-actions">
      <div class="count-chip hidden" id="countChip" onclick="toggleAutoRefresh()">
        <span class="count-ring"><svg viewBox="0 0 14 14"><circle class="track" cx="7" cy="7" r="5.6"/><circle class="arc" id="countArc" cx="7" cy="7" r="5.6" stroke-dasharray="35.2" stroke-dashoffset="35.2"/></svg></span>
        <span id="countTxt">60s</span>
      </div>
      
    </div>
  </header>

  <main id="main">
    <div class="ptr-wrap" id="ptrWrap">
      <div class="ptr-indicator" id="ptrInd"><span class="spinner" id="ptrSpin"></span><span id="ptrTxt">下拉刷新</span></div>
      <div id="pageHome"></div>
    </div>
    <div id="pagePoints" class="hidden"></div>
    <div id="pageVehicle" class="hidden"></div>
    <div id="pageRide" class="hidden"></div>
    <div id="pageLogs" class="hidden"></div>
    <div id="pageCfg" class="hidden"></div>
  </main>

  <nav class="tabbar">
    <button class="tab on" data-tab="home" onclick="switchTab('home')">
      <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M3 10.5 12 3l9 7.5"/><path d="M5 9.5V21h14V9.5"/></svg>
      首页<span class="t-ind"></span>
    </button>
    <button class="tab" data-tab="points" onclick="switchTab('points')">
      <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="8.6"/><path d="M9 8.5l3 4 3-4M12 12.5V17M9.6 13.4h4.8M9.6 15.4h4.8"/></svg>
      积分<span class="t-ind"></span>
    </button>
    <button class="tab" data-tab="vehicle" onclick="switchTab('vehicle')">
      <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M4 13l1.7-4.6A2 2 0 0 1 7.6 7h8.8a2 2 0 0 1 1.9 1.4L20 13"/><path d="M3.5 13h17a1 1 0 0 1 1 1v3.5h-2.6M2.5 17.5V14a1 1 0 0 1 1-1"/><path d="M5.1 17.5H2.5"/><circle cx="7.3" cy="17.3" r="1.9"/><circle cx="16.7" cy="17.3" r="1.9"/><path d="M9.2 17.3h5.6"/></svg>
      车辆<span class="t-ind"></span>
    </button>
    <button class="tab" data-tab="ride" onclick="switchTab('ride')">
      <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M3 16.5c2.5 0 3.5-9 8-9s4.5 9 10 9"/><circle cx="12" cy="19" r="1.3" fill="currentColor"/></svg>
      骑行<span class="t-ind"></span>
    </button>
    <button class="tab" data-tab="logs" onclick="switchTab('logs')">
      <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M8 6h13M8 12h13M8 18h13"/><path d="M3 6h.01M3 12h.01M3 18h.01"/></svg>
      日志<span class="t-ind"></span>
    </button>
    <button class="tab" data-tab="cfg" onclick="switchTab('cfg')">
      <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="3"/><path d="M19.4 15a1.65 1.65 0 0 0 .33 1.82l.06.06a2 2 0 1 1-2.83 2.83l-.06-.06a1.65 1.65 0 0 0-1.82-.33 1.65 1.65 0 0 0-1 1.51V21a2 2 0 1 1-4 0v-.09a1.65 1.65 0 0 0-1-1.51 1.65 1.65 0 0 0-1.82.33l-.06.06a2 2 0 1 1-2.83-2.83l.06-.06a1.65 1.65 0 0 0 .33-1.82 1.65 1.65 0 0 0-1.51-1H3a2 2 0 1 1 0-4h.09a1.65 1.65 0 0 0 1.51-1 1.65 1.65 0 0 0-.33-1.82l-.06-.06a2 2 0 1 1 2.83-2.83l.06.06a1.65 1.65 0 0 0 1.82.33h.01a1.65 1.65 0 0 0 1-1.51V3a2 2 0 1 1 4 0v.09a1.65 1.65 0 0 0 1 1.51h.01a1.65 1.65 0 0 0 1.82-.33l.06-.06a2 2 0 1 1 2.83 2.83l-.06.06a1.65 1.65 0 0 0-.33 1.82v.01a1.65 1.65 0 0 0 1.51 1H21a2 2 0 1 1 0 4h-.09a1.65 1.65 0 0 0-1.51 1z"/></svg>
      设置<span class="t-ind"></span>
    </button>
  </nav>

  <div class="sheet-backdrop" id="sheetBackdrop" onclick="closeSheet()"></div>
  <div class="sheet" id="sheet">
    <div class="sheet-grab"></div>
    <div class="sheet-head">
      <h3 id="sheetTitle"></h3>
      <button class="sheet-close" onclick="closeSheet()"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.4" stroke-linecap="round"><path d="M18 6 6 18M6 6l12 12"/></svg></button>
    </div>
    <div class="sheet-body" id="sheetBody"></div>
  </div>

  <div id="toast" role="status"></div>
  <div class="confirm-layer hidden" id="confirmLayer"></div>
</div>
<script>
"use strict";
/* ================= 常量 ================= */
const APP_VERSION = "v2.16.11";
const KEYS = { cfg:"zeeho_cfg", accounts:"zeeho_accounts", logs:"zeeho_logs" };

/* ================= 工具函数 ================= */
function getUuid(){const p="xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx",c="abcdef0123456789";let r="";for(const ch of p){if(ch==="x"||ch==="y"){const n=Math.floor(Math.random()*16);r+=(ch==="y"?(n&0x3)|0x8:n).toString(16)}else r+=ch}return r}
function getRandomChars(n=16){const c="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";let r="";for(let i=0;i<n;i++)r+=c.charAt(Math.floor(Math.random()*c.length));return r}
function toQuery(p={}){return Object.keys(p).filter(k=>p[k]!==undefined&&p[k]!==null).sort().map(k=>k+"="+p[k]).join("&")}
function cleanToken(t){return String(t||"").trim().replace(/^[bB]earer\s+/i,"").replace(/[\s"'`]+/g,"")}
function cleanBarkKey(b){let s=String(b||"").trim().replace(/^[bB]ark\s*(key)?\s*[:：]\s*/i,"").replace(/[\s"'`]+/g,"").trim();return s.replace(/\/+$/,"")}
function maskVin(v){const s=String(v||"");if(!s)return"";if(s.length<=7)return"****";return s.substring(0,3)+"****"+s.substring(s.length-4)}
function deepPick(obj,keys,depth){if(!obj||typeof obj!=="object"||(depth||0)>5)return"";for(const k of keys){if(obj[k]!==undefined&&obj[k]!==null&&obj[k]!=="")return String(obj[k])}for(const k in obj){if(obj[k]&&typeof obj[k]==="object"){const r=deepPick(obj[k],keys,(depth||0)+1);if(r)return r}}return""}
function pickIotProp(d,identify){const arr=d&&d.iotProperties;if(Array.isArray(arr)){const key=String(identify).toLowerCase();for(const it of arr){if(it&&String(it.identify||"").toLowerCase()===key&&it.value!==null&&it.value!==undefined&&it.value!=="")return String(it.value)}}return""}
function getDeviceIdentify(acc){const seed=String(acc.userId||acc.vinNo||"zeeho-device");let h=0;for(let i=0;i<seed.length;i++){h=((h<<5)-h+seed.charCodeAt(i))|0}return(Math.abs(h).toString(16)+"0000000000000000").slice(0,16)}
function hasValidCoord(lat,lng){if(lat===""||lat===null||lat===undefined||lng===""||lng===null||lng===undefined)return false;const la=Number(lat),ln=Number(lng);return isFinite(la)&&isFinite(ln)&&Math.abs(la)<=90&&Math.abs(ln)<=180&&!(la===0&&ln===0)}
function normalizeRefreshSec(v){const n=Number(v);if(!isFinite(n)||n<=0)return 60;return Math.max(15,Math.min(3600,Math.round(n)))}
function esc(s){return String(s==null?"":s).replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;")}

/* ================= MD5 ================= */
function md5(t,e){function n(t,e){return t<<e|t>>>32-e}function r(t,e){var n,r,o,i,a;return o=2147483648&t,i=2147483648&e,a=(1073741823&t)+(1073741823&e),(n=1073741824&t)&(r=1073741824&e)?2147483648^a^o^i:n|r?1073741824&a?3221225472^a^o^i:1073741824^a^o^i:a^o^i}function o(t,e,o,i,a,u,c){return t=r(t,r(r(function(t,e,n){return t&e|~t&n}(e,o,i),a),c)),r(n(t,u),e)}function i(t,e,o,i,a,u,c){return t=r(t,r(r(function(t,e,n){return t&n|e&~n}(e,o,i),a),c)),r(n(t,u),e)}function a(t,e,o,i,a,u,c){return t=r(t,r(r(function(t,e,n){return t^e^n}(e,o,i),a),c)),r(n(t,u),e)}function u(t,e,o,i,a,u,c){return t=r(t,r(r(function(t,e,n){return e^(t|~n)}(e,o,i),a),c)),r(n(t,u),e)}function c(t){var e,n="",r="";for(e=0;e<=3;e++)n+=(r="0"+(t>>>8*e&255).toString(16)).substr(r.length-2,2);return n}var s,l,f,p,d,h,v,y,g,m=Array();for(m=function(t){for(var e,n=t.length,r=n+8,o=16*((r-r%64)/64+1),i=Array(o-1),a=0,u=0;u<n;)a=u%4*8,i[e=(u-u%4)/4]=i[e]|t.charCodeAt(u)<<a,u++;return a=u%4*8,i[e=(u-u%4)/4]=i[e]|128<<a,i[o-2]=n<<3,i[o-1]=n>>>29,i}(t=function(t){t=t.replace(/\r\n/g,"\n");for(var e="",n=0;n<t.length;n++){var r=t.charCodeAt(n);r<128?e+=String.fromCharCode(r):r>127&&r<2048?(e+=String.fromCharCode(r>>6|192),e+=String.fromCharCode(63&r|128)):(e+=String.fromCharCode(r>>12|224),e+=String.fromCharCode(r>>6&63|128),e+=String.fromCharCode(63&r|128))}return e}(t)),h=1732584193,v=4023233417,y=2562383102,g=271733878,s=0;s<m.length;s+=16)l=h,f=v,p=y,d=g,h=o(h,v,y,g,m[s+0],7,3614090360),g=o(g,h,v,y,m[s+1],12,3905402710),y=o(y,g,h,v,m[s+2],17,606105819),v=o(v,y,g,h,m[s+3],22,3250441966),h=o(h,v,y,g,m[s+4],7,4118548399),g=o(g,h,v,y,m[s+5],12,1200080426),y=o(y,g,h,v,m[s+6],17,2821735955),v=o(v,y,g,h,m[s+7],22,4249261313),h=o(h,v,y,g,m[s+8],7,1770035416),g=o(g,h,v,y,m[s+9],12,2336552879),y=o(y,g,h,v,m[s+10],17,4294925233),v=o(v,y,g,h,m[s+11],22,2304563134),h=o(h,v,y,g,m[s+12],7,1804603682),g=o(g,h,v,y,m[s+13],12,4254626195),y=o(y,g,h,v,m[s+14],17,2792965006),h=i(h,v=o(v,y,g,h,m[s+15],22,1236535329),y,g,m[s+1],5,4129170786),g=i(g,h,v,y,m[s+6],9,3225465664),y=i(y,g,h,v,m[s+11],14,643717713),v=i(v,y,g,h,m[s+0],20,3921069994),h=i(h,v,y,g,m[s+5],5,3593408605),g=i(g,h,v,y,m[s+10],9,38016083),y=i(y,g,h,v,m[s+15],14,3634488961),v=i(v,y,g,h,m[s+4],20,3889429448),h=i(h,v,y,g,m[s+9],5,568446438),g=i(g,h,v,y,m[s+14],9,3275163606),y=i(y,g,h,v,m[s+3],14,4107603335),v=i(v,y,g,h,m[s+8],20,1163531501),h=i(h,v,y,g,m[s+13],5,2850285829),g=i(g,h,v,y,m[s+2],9,4243563512),y=i(y,g,h,v,m[s+7],14,1735328473),h=a(h,v=i(v,y,g,h,m[s+12],20,2368359562),y,g,m[s+5],4,4294588738),g=a(g,h,v,y,m[s+8],11,2272392833),y=a(y,g,h,v,m[s+11],16,1839030562),v=a(v,y,g,h,m[s+14],23,4259657740),h=a(h,v,y,g,m[s+1],4,2763975236),g=a(g,h,v,y,m[s+4],11,1272893353),y=a(y,g,h,v,m[s+7],16,4139469664),v=a(v,y,g,h,m[s+10],23,3200236656),h=a(h,v,y,g,m[s+13],4,681279174),g=a(g,h,v,y,m[s+0],11,3936430074),y=a(y,g,h,v,m[s+3],16,3572445317),v=a(v,y,g,h,m[s+6],23,76029189),h=a(h,v,y,g,m[s+9],4,3654602809),g=a(g,h,v,y,m[s+12],11,3873151461),y=a(y,g,h,v,m[s+15],16,530742520),h=u(h,v=a(v,y,g,h,m[s+2],23,3299628645),y,g,m[s+0],6,4096336452),g=u(g,h,v,y,m[s+7],10,1126891415),y=u(y,g,h,v,m[s+14],15,2878612391),v=u(v,y,g,h,m[s+5],21,4237533241),h=u(h,v,y,g,m[s+12],6,1700485571),g=u(g,h,v,y,m[s+3],10,2399980690),y=u(y,g,h,v,m[s+10],15,4293915773),v=u(v,y,g,h,m[s+1],21,2240044497),h=u(h,v,y,g,m[s+8],6,1873313359),g=u(g,h,v,y,m[s+15],10,4264355552),y=u(y,g,h,v,m[s+6],15,2734768916),v=u(v,y,g,h,m[s+13],21,1309151649),h=u(h,v,y,g,m[s+4],6,4149444226),g=u(g,h,v,y,m[s+11],10,3174756917),y=u(y,g,h,v,m[s+2],15,718787259),v=u(v,y,g,h,m[s+9],21,3951481745),h=r(h,l),v=r(v,f),y=r(y,p),g=r(g,d);return 32==e?(c(h)+c(v)+c(y)+c(g)).toLowerCase():(c(v)+c(y)).toLowerCase()}
/* ================= SHA1 ================= */
function sha1(msg){function rotate_left(n,s){var t4=(n<<s)|(n>>>(32-s));return t4};function cvt_hex(val){var str='';var i;var v;for(i=7;i>=0;i--){v=(val>>>(i*4))&0x0f;str+=v.toString(16)}return str};function Utf8Encode(string){string=string.replace(/\r\n/g,'\n');var utftext='';for(var n=0;n<string.length;n++){var c=string.charCodeAt(n);if(c<128){utftext+=String.fromCharCode(c)}else if((c>127)&&(c<2048)){utftext+=String.fromCharCode((c>>6)|192);utftext+=String.fromCharCode((c&63)|128)}else{utftext+=String.fromCharCode((c>>12)|224);utftext+=String.fromCharCode(((c>>6)&63)|128);utftext+=String.fromCharCode((c&63)|128)}}return utftext};var blockstart;var i,j;var W=new Array(80);var H0=0x67452301;var H1=0xEFCDAB89;var H2=0x98BADCFE;var H3=0x10325476;var H4=0xC3D2E1F0;var A,B,C,D,E;var temp;msg=Utf8Encode(msg);var msg_len=msg.length;var word_array=new Array();for(i=0;i<msg_len-3;i+=4){j=msg.charCodeAt(i)<<24|msg.charCodeAt(i+1)<<16|msg.charCodeAt(i+2)<<8|msg.charCodeAt(i+3);word_array.push(j)}switch(msg_len%4){case 0:i=0x080000000;break;case 1:i=msg.charCodeAt(msg_len-1)<<24|0x0800000;break;case 2:i=msg.charCodeAt(msg_len-2)<<24|msg.charCodeAt(msg_len-1)<<16|0x08000;break;case 3:i=msg.charCodeAt(msg_len-3)<<24|msg.charCodeAt(msg_len-2)<<16|msg.charCodeAt(msg_len-1)<<8|0x80;break}word_array.push(i);while((word_array.length%16)!=14)word_array.push(0);word_array.push(msg_len>>>29);word_array.push((msg_len<<3)&0x0ffffffff);for(blockstart=0;blockstart<word_array.length;blockstart+=16){for(i=0;i<16;i++)W[i]=word_array[blockstart+i];for(i=16;i<=79;i++)W[i]=rotate_left(W[i-3]^W[i-8]^W[i-14]^W[i-16],1);A=H0;B=H1;C=H2;D=H3;E=H4;for(i=0;i<=19;i++){temp=(rotate_left(A,5)+((B&C)|(~B&D))+E+W[i]+0x5A827999)&0x0ffffffff;E=D;D=C;C=rotate_left(B,30);B=A;A=temp}for(i=20;i<=39;i++){temp=(rotate_left(A,5)+(B^C^D)+E+W[i]+0x6ED9EBA1)&0x0ffffffff;E=D;D=C;C=rotate_left(B,30);B=A;A=temp}for(i=40;i<=59;i++){temp=(rotate_left(A,5)+((B&C)|(B&D)|(C&D))+E+W[i]+0x8F1BBCDC)&0x0ffffffff;E=D;D=C;C=rotate_left(B,30);B=A;A=temp}for(i=60;i<=79;i++){temp=(rotate_left(A,5)+(B^C^D)+E+W[i]+0xCA62C1D6)&0x0ffffffff;E=D;D=C;C=rotate_left(B,30);B=A;A=temp}H0=(H0+A)&0x0ffffffff;H1=(H1+B)&0x0ffffffff;H2=(H2+C)&0x0ffffffff;H3=(H3+D)&0x0ffffffff;H4=(H4+E)&0x0ffffffff}var temp=cvt_hex(H0)+cvt_hex(H1)+cvt_hex(H2)+cvt_hex(H3)+cvt_hex(H4);return temp.toLowerCase()}
/* ================= AES-256-ECB + PKCS7 ================= */
const AES_SBOX=new Uint8Array([0x63,0x7c,0x77,0x7b,0xf2,0x6b,0x6f,0xc5,0x30,0x01,0x67,0x2b,0xfe,0xd7,0xab,0x76,0xca,0x82,0xc9,0x7d,0xfa,0x59,0x47,0xf0,0xad,0xd4,0xa2,0xaf,0x9c,0xa4,0x72,0xc0,0xb7,0xfd,0x93,0x26,0x36,0x3f,0xf7,0xcc,0x34,0xa5,0xe5,0xf1,0x71,0xd8,0x31,0x15,0x04,0xc7,0x23,0xc3,0x18,0x96,0x05,0x9a,0x07,0x12,0x80,0xe2,0xeb,0x27,0xb2,0x75,0x09,0x83,0x2c,0x1a,0x1b,0x6e,0x5a,0xa0,0x52,0x3b,0xd6,0xb3,0x29,0xe3,0x2f,0x84,0x53,0xd1,0x00,0xed,0x20,0xfc,0xb1,0x5b,0x6a,0xcb,0xbe,0x39,0x4a,0x4c,0x58,0xcf,0xd0,0xef,0xaa,0xfb,0x43,0x4d,0x33,0x85,0x45,0xf9,0x02,0x7f,0x50,0x3c,0x9f,0xa8,0x51,0xa3,0x40,0x8f,0x92,0x9d,0x38,0xf5,0xbc,0xb6,0xda,0x21,0x10,0xff,0xf3,0xd2,0xcd,0x0c,0x13,0xec,0x5f,0x97,0x44,0x17,0xc4,0xa7,0x7e,0x3d,0x64,0x5d,0x19,0x73,0x60,0x81,0x4f,0xdc,0x22,0x2a,0x90,0x88,0x46,0xee,0xb8,0x14,0xde,0x5e,0x0b,0xdb,0xe0,0x32,0x3a,0x0a,0x49,0x06,0x24,0x5c,0xc2,0xd3,0xac,0x62,0x91,0x95,0xe4,0x79,0xe7,0xc8,0x37,0x6d,0x8d,0xd5,0x4e,0xa9,0x6c,0x56,0xf4,0xea,0x65,0x7a,0xae,0x08,0xba,0x78,0x25,0x2e,0x1c,0xa6,0xb4,0xc6,0xe8,0xdd,0x74,0x1f,0x4b,0xbd,0x8b,0x8a,0x70,0x3e,0xb5,0x66,0x48,0x03,0xf6,0x0e,0x61,0x35,0x57,0xb9,0x86,0xc1,0x1d,0x9e,0xe1,0xf8,0x98,0x11,0x69,0xd9,0x8e,0x94,0x9b,0x1e,0x87,0xe9,0xce,0x55,0x28,0xdf,0x8c,0xa1,0x89,0x0d,0xbf,0xe6,0x42,0x68,0x41,0x99,0x2d,0x0f,0xb0,0x54,0xbb,0x16]);
const AES_RCON=new Uint8Array([0x00,0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80,0x1b,0x36,0x6c,0xd8,0xab,0x4d]);
function aesGMul(a,b){let p=0;for(let i=0;i<8;i++){if(b&1)p^=a;const hi=a&0x80;a=(a<<1)&0xff;if(hi)a^=0x1b;b>>=1}return p}
function aesKeyExpansion256(key){const Nk=8,Nb=4,Nr=14;const w=new Uint8Array(4*Nb*(Nr+1));for(let i=0;i<Nk*4;i++)w[i]=key[i];for(let i=Nk;i<Nb*(Nr+1);i++){let t0=w[4*(i-1)],t1=w[4*(i-1)+1],t2=w[4*(i-1)+2],t3=w[4*(i-1)+3];if(i%Nk===0){const tmp=t0;t0=AES_SBOX[t1]^AES_RCON[i/Nk];t1=AES_SBOX[t2];t2=AES_SBOX[t3];t3=AES_SBOX[tmp]}else if(i%Nk===4){t0=AES_SBOX[t0];t1=AES_SBOX[t1];t2=AES_SBOX[t2];t3=AES_SBOX[t3]}w[4*i]=w[4*(i-Nk)]^t0;w[4*i+1]=w[4*(i-Nk)+1]^t1;w[4*i+2]=w[4*(i-Nk)+2]^t2;w[4*i+3]=w[4*(i-Nk)+3]^t3}return w}
function aesEncryptBlock(input,w){const Nb=4,Nr=14;const s=new Uint8Array(16);for(let i=0;i<16;i++)s[i]=input[i];for(let i=0;i<16;i++)s[i]^=w[i];for(let round=1;round<=Nr;round++){for(let i=0;i<16;i++)s[i]=AES_SBOX[s[i]];let t=s[1];s[1]=s[5];s[5]=s[9];s[9]=s[13];s[13]=t;t=s[2];s[2]=s[10];s[10]=t;t=s[6];s[6]=s[14];s[14]=t;t=s[3];s[3]=s[15];s[15]=s[11];s[11]=s[7];s[7]=t;if(round!==Nr){for(let c=0;c<4;c++){const i=4*c;const a0=s[i],a1=s[i+1],a2=s[i+2],a3=s[i+3];s[i]=aesGMul(a0,2)^aesGMul(a1,3)^a2^a3;s[i+1]=a0^aesGMul(a1,2)^aesGMul(a2,3)^a3;s[i+2]=a0^a1^aesGMul(a2,2)^aesGMul(a3,3);s[i+3]=aesGMul(a0,3)^a1^a2^aesGMul(a3,2)}}const off=round*16;for(let i=0;i<16;i++)s[i]^=w[off+i]}return s}
function aesUtf8Bytes(str){const out=[];for(let i=0;i<str.length;i++){let c=str.charCodeAt(i);if(c<0x80)out.push(c);else if(c<0x800)out.push(0xc0|(c>>6),0x80|(c&0x3f));else if(c>=0xd800&&c<=0xdbff){const c2=str.charCodeAt(++i);c=0x10000+((c-0xd800)<<10)+(c2-0xdc00);out.push(0xf0|(c>>18),0x80|((c>>12)&0x3f),0x80|((c>>6)&0x3f),0x80|(c&0x3f))}else out.push(0xe0|(c>>12),0x80|((c>>6)&0x3f),0x80|(c&0x3f))}return new Uint8Array(out)}
function aesBytesToBase64(bytes){const chars="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";let result="",i=0;for(;i+2<bytes.length;i+=3){const n=(bytes[i]<<16)|(bytes[i+1]<<8)|bytes[i+2];result+=chars[(n>>18)&63]+chars[(n>>12)&63]+chars[(n>>6)&63]+chars[n&63]}const rem=bytes.length-i;if(rem===1){const n=bytes[i]<<16;result+=chars[(n>>18)&63]+chars[(n>>12)&63]+"=="}else if(rem===2){const n=(bytes[i]<<16)|(bytes[i+1]<<8);result+=chars[(n>>18)&63]+chars[(n>>12)&63]+chars[(n>>6)&63]+"="}return result}
function aes256EcbEncryptBase64(plaintext,keyStr){const key=aesUtf8Bytes(keyStr);if(key.length!==32)throw new Error("AES-256需要32字节密钥，当前"+key.length);const w=aesKeyExpansion256(key);const data=aesUtf8Bytes(plaintext);const padLen=16-(data.length%16);const padded=new Uint8Array(data.length+padLen);padded.set(data);for(let i=data.length;i<padded.length;i++)padded[i]=padLen;const out=new Uint8Array(padded.length);for(let off=0;off<padded.length;off+=16){out.set(aesEncryptBlock(padded.slice(off,off+16),w),off)}return aesBytesToBase64(out)}

/* ================= 存储 ================= */
function loadJSON(k,fallback){try{const raw=localStorage.getItem(k);if(!raw)return fallback;const v=JSON.parse(raw);return v===undefined||v===null?fallback:v}catch(e){return fallback}}
function saveJSON(k,v){try{localStorage.setItem(k,JSON.stringify(v));return true}catch(e){return false}}
const DEFAULT_CFG={app:{appId:"S7qPWPU1",appSecret:"c5e0da7f4da28df805694ec3dd1fc6792e9df99d"},h5:{appId:"Sw5F9uJi",appSecret:"46870a8f678a09109468f5b0168818b91c292845"},community:{enablePost:true,enableLike:true,enableComment:true,enableShare:true,enableDelete:true},vehicleAesKey:"ce2cd7cb57124c1349dd8543bf6fd31d",vehicleControlRisk:"",autoRefreshSec:60,serverBase:"",autoSignin:false,autoSigninTime:"07:00",vehicleMonitor:false,widgetVehicle:"",customBg:"",pics:{}};
function getCfg(){const c=loadJSON(KEYS.cfg,null);if(!c)return JSON.parse(JSON.stringify(DEFAULT_CFG));return{app:{appId:c.app?.appId||DEFAULT_CFG.app.appId,appSecret:c.app?.appSecret||DEFAULT_CFG.app.appSecret},h5:{appId:c.h5?.appId||DEFAULT_CFG.h5.appId,appSecret:c.h5?.appSecret||DEFAULT_CFG.h5.appSecret},community:{enablePost:c.community?.enablePost!==false,enableLike:c.community?.enableLike!==false,enableComment:c.community?.enableComment!==false,enableShare:c.community?.enableShare!==false,enableDelete:c.community?.enableDelete!==false},vehicleAesKey:((typeof c.vehicleAesKey==="string"?c.vehicleAesKey:"").trim()||DEFAULT_CFG.vehicleAesKey),vehicleControlRisk:(typeof c.vehicleControlRisk==="string"?c.vehicleControlRisk:"").trim(),autoRefreshSec:normalizeRefreshSec(c.autoRefreshSec),serverBase:String(c.serverBase||"").trim(),autoSignin:c.autoSignin===true,autoSigninTime:(typeof c.autoSigninTime==="string"&&/^\d{1,2}:\d{2}$/.test(c.autoSigninTime)?c.autoSigninTime:"07:00"),vehicleMonitor:c.vehicleMonitor===true, widgetVehicle:String(c.widgetVehicle||""), customBg:String(c.customBg||"")}}
function saveCfg(c){return saveJSON(KEYS.cfg,c)}
function getAccounts(){const a=loadJSON(KEYS.accounts,[]);return Array.isArray(a)?a:[]}
function saveAccounts(list){return saveJSON(KEYS.accounts,list)}
function getLogs(){const a=loadJSON(KEYS.logs,[]);return Array.isArray(a)?a:[]}
function addLog(entry){const logs=getLogs();logs.unshift(entry);if(logs.length>50)logs.length=50;saveJSON(KEYS.logs,logs)}
function clearLogs(){return saveJSON(KEYS.logs,[])}
function isProxyMode(){return !!(window.__PANEL_MODE__)||!!getCfg().serverBase}
/* ================= 签名 ================= */
function getSign(type,params={},body='',cfg){const c=cfg||getCfg();const ac=c[type]||c.app;const query=toQuery(params);const timestamp=new Date().getTime();const nonce=type==="h5"?getUuid():timestamp+getRandomChars();const param="appId="+ac.appId+"&nonce="+nonce+"&timestamp="+timestamp;const bodyStr=body?(typeof body==="string"?body:JSON.stringify(body)):'';const signature=type==="h5"?(query+param+ac.appSecret):(bodyStr+param+ac.appSecret);const sign=md5(sha1(signature),32).toString();return{'cfmoto-x-param':param,'cfmoto-x-sign':sign,'cfmoto-x-sign-type':'0','timestamp':String(timestamp),'nonce':nonce,'signature':sign}}

// H5 端含 body 签名（loginByPhone 等接口必须把请求体纳入签名，否则返回 permit error）
function h5SignWithBody(body,cfg){const c=cfg||getCfg();const ac=c.h5||c.app;const timestamp=new Date().getTime();const nonce=getUuid();const param="appId="+ac.appId+"&nonce="+nonce+"&timestamp="+timestamp;const bodyStr=typeof body==="string"?body:JSON.stringify(body);const sign=md5(sha1(bodyStr+param+ac.appSecret),32).toString();return{'cfmoto-x-param':param,'cfmoto-x-sign':sign,'cfmoto-x-sign-type':'0','timestamp':String(timestamp),'nonce':nonce,'appId':ac.appId}}

// App 网关完整签名（发码与登录同网关，避免 H5 authCode 发码进 App 池而 H5 loginByPhone 查不到）
function appGatewaySign(url,method,params={},body='',cfg){const c=cfg||getCfg();const ac=c.app||c.h5;const timestamp=new Date().getTime();const nonce=timestamp+getRandomChars();const param="appId="+ac.appId+"&nonce="+nonce+"&timestamp="+timestamp;const query=toQuery(params);let preSign="";if(String(method).toUpperCase()==="GET"){const u=new URL(url);preSign=u.origin+u.pathname+(query?"?"+query:"");}else{preSign=query+(body?(typeof body==="string"?body:JSON.stringify(body)):"");}const sign=md5(sha1(preSign+param+ac.appSecret),32).toString();return{'appId':ac.appId,'nonce':nonce,'timestamp':String(timestamp),'signature':sign,'Cfmoto-X-Param':param,'Cfmoto-X-Sign':sign,'Cfmoto-X-Sign-Type':'0'}}

// v2.16.0 服务端已对「带 query 的 GET」收紧：带旧短格式 UA 时必须 query 入签（否则 430/30121 permit error），
// 与社交写操作同一套签名（md5(sha1(query+param+secret))）。浏览器无法自定义 Cookie，但实测非必需。
function appQuerySign(queryStr,cfg){const c=cfg||getCfg();const ac=c.app||c.h5;const timestamp=new Date().getTime();const nonce=timestamp+getRandomChars(16);const param="appId="+ac.appId+"&nonce="+nonce+"&timestamp="+timestamp;const sign=md5(sha1((queryStr||"")+param+ac.appSecret),32).toString();return{"cfmoto-x-param":param,"cfmoto-x-sign":sign,"cfmoto-x-sign-type":"0","timestamp":String(timestamp),"nonce":nonce,"signature":sign}}
function appQueryHeaders(acc,queryStr,cfg){const c=cfg||getCfg();const ua="MOBILE|iOS|17.5.1|ZEEHO_APP|3.0.5|iPhone|iPhone 15 Pro|1179*2556|"+getRandomChars(32).toUpperCase()+"|WWAN|iOS";return{"Authorization":"Bearer "+cleanToken(acc.token),"Content-Type":"application/json;charset=UTF-8","interfaceversion":"2","Accept":"*/*","Accept-Language":"zh-CN","appid":c.app.appId,"x-app-info":ua,...appQuerySign(queryStr,c)}}

/* ================= HTTP（fetch 版） ================= */
async function httpGet(url,headers,timeoutMs){const ctrl=timeoutMs?AbortSignal.timeout(timeoutMs):undefined;try{const r=await fetch(url,{method:"GET",headers:headers||{},signal:ctrl});const t=await r.text();try{return JSON.parse(t)}catch(e){return{error:"parse error",raw:t}}}catch(e){return{error:String((e&&e.message)||e)}}}
async function httpPost(url,headers,body,timeoutMs){const ctrl=timeoutMs?AbortSignal.timeout(timeoutMs):undefined;try{const r=await fetch(url,{method:"POST",headers:headers||{},body:typeof body==="string"?body:JSON.stringify(body==null?{}:body),signal:ctrl});const t=await r.text();try{return JSON.parse(t)}catch(e){return{error:"parse error",raw:t}}}catch(e){return{error:String((e&&e.message)||e)}}}
async function httpPut(url,headers,body,timeoutMs){const ctrl=timeoutMs?AbortSignal.timeout(timeoutMs):undefined;try{const r=await fetch(url,{method:"PUT",headers:headers||{},body:body!==undefined&&body!==null?(typeof body==="string"?body:JSON.stringify(body)):undefined,signal:ctrl});const t=await r.text();try{return JSON.parse(t)}catch(e){return{error:"parse error",raw:t}}}catch(e){return{error:String((e&&e.message)||e)}}}
async function httpDelete(url,headers,timeoutMs){const ctrl=timeoutMs?AbortSignal.timeout(timeoutMs):undefined;try{const r=await fetch(url,{method:"DELETE",headers:headers||{},signal:ctrl});const t=await r.text();try{return JSON.parse(t)}catch(e){return{error:"parse error",raw:t}}}catch(e){return{error:String((e&&e.message)||e)}}}
function networkHint(res){const m=String((res&&res.error)||"");if(/failed to fetch|networkerror|cors|load failed|无法连接|网络/i.test(m))return"网络/跨域受限：直连模式需 ZEEHO 服务端放行 CORS，请检查网络连接后重试";return""}

/* ================= 直连后端（浏览器直接调 ZEEHO API） ================= */
// 页面直连模式下的兜底头：UA 未自定义时每次请求随机设备指纹（与脚本引擎同策略，避免固定指纹被风控拉黑）
function pageRandomUA(){const vers=["16.1.1","16.6.1","16.7.8","17.1.1","17.2.1","17.4.1","17.5.1","17.6.1","18.0","18.1.1","18.3.1"];return "MOBILE|iOS|"+vers[Math.floor(Math.random()*vers.length)]+"|ZEEHO_APP|3.0.1|iPhone|"+(Math.random()<0.7?"WWAN":"WIFI")+"|iOS"}
function baseHeaders(acc){const ua=acc.userAgent||pageRandomUA();const h={"Authorization":"Bearer "+cleanToken(acc.token),"Content-Type":"application/json;charset=UTF-8","interfaceversion":"2","Accept-Language":"zh-CN","Accept":"*/*","User-Agent":ua,"x-app-info":ua};if(acc.userId){h["user_id"]=String(acc.userId);h["Cookie"]="user_id="+acc.userId}return h}

async function fetchVehicleList(acc,cfg){try{const token=cleanToken(acc.token);const signH=getSign("app",{},'',cfg);const headers={"Authorization":"Bearer "+token,"Content-Type":"application/json;charset=UTF-8","interfaceversion":"2",...signH};if(acc.userId)headers["user_id"]=String(acc.userId);const res=await httpGet("https://tapi.zeehoev.com/v1.0/app/cfmotoserverapp/vehicle/list",headers);let list=[];if(res.code=="10000"||res.code===10000){if(Array.isArray(res.data))list=res.data;else if(res.data&&Array.isArray(res.data.list))list=res.data.list;else if(res.data&&Array.isArray(res.data.records))list=res.data.records;else if(res.data&&Array.isArray(res.data.rows))list=res.data.rows}return list.map(v=>({vinNo:String(v.vinNo||v.frameNo||v.vin||"").trim(),name:String(v.vehicleName||v.vehicleType||v.deviceName||v.name||"车辆").trim()||"车辆",pic:String(v.vehiclePicUrl||v.pic||v.imageUrl||"").trim(),vehicleType:String(v.vehicleType||v.type||"").trim(),licensePlate:v.licensePlate||null})).filter(v=>v.vinNo)}catch(e){return[]}}

async function fetchVehicleWidgets(acc,cfg,vinNo){try{const token=cleanToken(acc.token);const signH=getSign("app",{},'',cfg);const res=await httpGet("https://tapi.zeehoev.com/v1.0/app/cfmotoserverapp/vehicle/widgets/"+encodeURIComponent(vinNo),{"Authorization":"Bearer "+token,"Content-Type":"application/json;charset=UTF-8","interfaceversion":"2","user_id":acc.userId||"",...signH});if((res.code=="10000"||res.code===10000)&&res.data){const d=res.data;const soc=Number(d.bmssoc||d.batteryLevel||0);const range=Number(d.hmiRidableMile||d.vehicleRidableMile||d.ridableMileage||0);const voltage=Number(d.voltage||d.batteryVoltage||d.bmsVoltage||d.totalVoltage||d.batteryTotalVoltage||0);const lngStr=deepPick(d,["longitude","lng","lon","gpsX","longitudeValue","coordX","x"]);const latStr=deepPick(d,["latitude","lat","gpsY","latitudeValue","coordY","y"]);const longitude=Number(lngStr),latitude=Number(latStr);return{batteryPercent:Math.max(0,Math.min(100,isFinite(soc)?soc:0)),residualRangeKm:isFinite(range)?range:0,voltage:isFinite(voltage)&&voltage>0?voltage:0,address:String(d.address||"").trim(),locationTime:String(d.location?.locationTime||"").trim(),vehicleName:String(d.vehicleName||"").trim(),vehicleImageUrl:String(d.vehicleScalePicUrl||d.vehiclePicUrl||"").trim(),headLockState:String(d.headLockState||"").trim(),batteryPullOut:String(d.batteryPullOutFlag||"")==="1",online:String(d.onlineStatus||d.online||d.netStatus||d.tboxStatus||d.deviceOnline||"").trim(),cushionState:deepPick(d,["cushionState","cushionStatus","cushionLockState","seatState","seatStatus","seatLockState","saddleState","saddleStatus","saddleLockState"]),longitude:(isFinite(longitude)&&Math.abs(longitude)<=180&&longitude!==0)?longitude:"",latitude:(isFinite(latitude)&&Math.abs(latitude)<=90&&latitude!==0)?latitude:"",powerStatus:String(d.accStatus||d.powerStatus||d.vehicleStatus||d.ignitionStatus||d.powerMode||d.accState||d.powerState||d.vehicleState||d.engineStatus||d.isPowerOn||d.powerOn||"").trim(),lockState:String(d.headLockState||d.lockState||d.lockStatus||d.vehicleLockState||d.carLockState||d.doorLockState||d.lockFlag||d.isLocked||d.locked||d.centralLockingStatus||"").trim()}}return null}catch(e){return null}}

async function fetchVehicleHomePage(acc,cfg,vinNo){try{const deviceId=getDeviceIdentify(acc);const query="uniqueIdentify="+deviceId+"&phoneDeviceName=ios_"+deviceId;const url="https://tapi.zeehoev.com/v1.0/app/cfmotoserverapp/vehicleHomePageV2/"+encodeURIComponent(vinNo)+"?"+query;const res=await httpGet(url,appQueryHeaders(acc,query,cfg));if(res&&(res.code=="10000"||res.code===10000)&&res.data){const d=res.data;const vehicleLock=pickIotProp(d,"VehicleLock_S");const headLockIot=pickIotProp(d,"HeadLockState");const topLock=String(d.headLockState||d.lockState||d.lockStatus||d.vehicleLockState||headLockIot||vehicleLock||"").trim();const lngStr=deepPick(d,["longitude","lng","lon","gpsX","longitudeValue","coordX","x"]);const latStr=deepPick(d,["latitude","lat","gpsY","latitudeValue","coordY","y"]);const longitude=Number(lngStr),latitude=Number(latStr);return{powerStatus:deepPick(d,["accStatus","powerStatus","vehicleStatus","ignitionStatus","powerMode","accState","powerState","vehicleState","engineStatus","isPowerOn","powerOn","acc"]).trim(),lockState:topLock,online:String(d.onlineStatus||d.rideState||d.online||d.netStatus||d.tboxStatus||"").trim(),rideState:String(d.rideState||"").trim(),cushionState:deepPick(d,["cushionState","cushionStatus","cushionLockState","seatState","seatStatus","seatLockState","saddleState","saddleStatus","saddleLockState"]),longitude:(isFinite(longitude)&&Math.abs(longitude)<=180&&longitude!==0)?longitude:"",latitude:(isFinite(latitude)&&Math.abs(latitude)<=90&&latitude!==0)?latitude:""}}return null}catch(e){return null}}

async function fetchTirePressure(acc,cfg,vinNo){try{const query="vinNo="+encodeURIComponent(vinNo)+"&timePeriodType=1";const res=await httpGet("https://tapi.zeehoev.com/v1.0/app/cfmotoserverapp/app/vehicle/tire/monitoring?"+query,appQueryHeaders(acc,query,cfg));if((res.code=="10000"||res.code===10000)&&res.data){const list=Array.isArray(res.data.realTimeData)?res.data.realTimeData:(Array.isArray(res.data)?res.data:[]);const byPos={};for(const it of list){const pos=Number(it?.sensorPosition);if(pos)byPos[pos]=it}const fmt=(it)=>{const warn=Number(it?.warningType??0);const v=String(it?.tirePressure??"").trim();const n=parseFloat(v);if(warn!==0||!v||!isFinite(n)||n<=0)return"未绑定";return v+"bar"};const fmtTemp=(it)=>{const warn=Number(it?.warningType??0);const v=it?.tireTemp;if(warn!==0||v==null)return"";const s=String(v).trim();const n=parseFloat(s);if(!s||s.toLowerCase()==="null"||!isFinite(n)||n<=0)return"";return s+"°C"};const front=byPos[1]||list[0];const rear=byPos[2]||list[1];return{frontPressure:front?fmt(front):"未绑定",rearPressure:rear?fmt(rear):"未绑定",frontTemp:front?fmtTemp(front):"",rearTemp:rear?fmtTemp(rear):""}}return null}catch(e){return null}}

async function fetchRideInfo(acc,cfg,vinNo){try{const month=new Date().getFullYear()+"."+String(new Date().getMonth()+1).padStart(2,"0");const qHome="vinNo="+encodeURIComponent(vinNo);const qMy="vinNo="+encodeURIComponent(vinNo)+"&month="+month;const [homeRes,myRes]=await Promise.all([httpGet("https://tapi.zeehoev.com/v1.0/app/cfmotoserverapp/homeRideInfo?"+qHome,appQueryHeaders(acc,qHome,cfg)),httpGet("https://tapi.zeehoev.com/v1.0/app/cfmotoserverapp/myRideInfo?"+qMy,appQueryHeaders(acc,qMy,cfg))]);const h=homeRes?.data||homeRes||{};const d=myRes?.data||myRes||{};const list=Array.isArray(d.rideRecordList)?d.rideRecordList:[];const todayKey=new Date().getFullYear()+"."+String(new Date().getMonth()+1).padStart(2,"0")+"."+String(new Date().getDate()).padStart(2,"0");const day=list.find(x=>String(x?.date||"")===todayKey)||list[list.length-1]||{};const yest=new Date(Date.now()-86400000);const yestKey=yest.getFullYear()+"."+String(yest.getMonth()+1).padStart(2,"0")+"."+String(yest.getDate()).padStart(2,"0");const yd=list.find(x=>String(x?.date||"")===yestKey)||{};return{todayDistance:Number(day.rideMileage??h.rideMileageDay??0),todayDuration:Number(day.ridingTimeDayUnitMinute??h.lastRidingTimeUnitMinute??0),todayMaxSpeed:Number(day.maxSpeed??0),totalMileage:Number(d.rideMileageTotal??0),yesterdayDistance:Number(yd.rideMileage??0),lastRideMileage:Number(h.lastRideMileage??0),lastRideDuration:Number(h.lastRidingTimeUnitMinute??0)}}catch(e){return null}}

async function fetchBatteryChargeState(acc,cfg,vinNo){try{const token=cleanToken(acc.token);const signH=getSign("app",{},'',cfg);const headers={"Authorization":"Bearer "+token,"Content-Type":"application/json;charset=UTF-8","interfaceversion":"2","appid":cfg.app.appId,"user_id":acc.userId||"",...signH};const res=await httpGet("https://tapi.zeehoev.com/v1.0/app/cfmotoserverapp/batteryInfo/"+encodeURIComponent(vinNo),headers);if(res.code=="10000"&&res.data){const d=res.data;const voltage=Number(d.voltage||d.batteryVoltage||d.bmsVoltage||d.totalVoltage||d.batteryTotalVoltage||d.vol||d.batVoltage||d.batteryVol||0);const current=Number(d.current||d.batteryCurrent||d.bmsCurrent||d.cur||d.batteryCur||0);const batteryTemp=Number(d.batteryTemp||d.batTemp||d.temp||d.temperature||d.bmsTemp||d.batteryTemperature||0);const range=Number(d.hmiRidableMile||d.vehicleRidableMile||d.ridableMileage||d.residualRange||0);return{chargeState:String(d.chargeStateStr||d.chargeState||"未充电"),voltage:isFinite(voltage)&&voltage>0?voltage:0,current:isFinite(current)?current:0,batteryTemp:isFinite(batteryTemp)?batteryTemp:0,soc:Number(d.soc||d.bmssoc||0),residualRangeKm:isFinite(range)?range:0}}return{chargeState:"未充电",voltage:0,current:0,batteryTemp:0,soc:0,residualRangeKm:0}}catch(e){return{chargeState:"未充电",voltage:0,current:0,batteryTemp:0,soc:0,residualRangeKm:0}}}

async function fetchServiceRechargeDetail(acc,cfg,vinNo){try{const token=cleanToken(acc.token);const signH=getSign("h5",{vinNo:vinNo},'',cfg);const headers={"Authorization":"Bearer "+token,"Content-Type":"application/json;charset=UTF-8","interfaceversion":"2",...signH};if(acc.userId)headers["user_id"]=String(acc.userId);const res=await httpGet("https://h5.zeehoev.com/cfmotoserverapp/app/service/recharge/vehicle/detail?vinNo="+encodeURIComponent(vinNo),headers);if(res.code=="10000"&&res.data){return{rechargeEndDate:String(res.data.rechargeEndDate||""),lastUseDate:Number(res.data.lastUseDate)||0,serviceRechargeStatus:String(res.data.serviceRechargeStatus||""),vehicleName:String(res.data.vehicleName||"")}}return null}catch(e){return null}}

async function fetchVehicleInfo(acc,cfg){const result={hasVehicle:false,vehicleName:"",vehicleModel:"",vinNo:"",voltage:0,current:0,batteryTemp:0,batteryPercent:0,residualRangeKm:0,rangeEstimated:false,address:"",locationTime:"",chargeState:"未充电",frontPressure:"",rearPressure:"",frontTemp:"",rearTemp:"",todayDistance:0,todayDuration:0,todayMaxSpeed:0,lastRideMileage:0,lastRideDuration:0,totalMileage:0,yesterdayDistance:0,vehicleImageUrl:"",serviceEndDate:"",serviceRemainDays:0,serviceStatus:"",powerStatus:"",lockState:"",online:"",rideState:"",cushionState:"",longitude:"",latitude:""};try{const allVehicles=await fetchVehicleList(acc,cfg);const vehicles=allVehicles.filter(x=>!/模拟/.test(String(x.name||"")+" "+String(x.vehicleType||"")));if(vehicles.length===0)return result;const v=vehicles[0];result.hasVehicle=true;result.vehicleName=v.name;result.vinNo=v.vinNo;result.vehicleImageUrl=v.pic;result.vehicleModel=v.vehicleType||"";const [widgets,tire,ride,battery,service,homePage]=await Promise.all([fetchVehicleWidgets(acc,cfg,v.vinNo).catch(()=>null),fetchTirePressure(acc,cfg,v.vinNo).catch(()=>null),fetchRideInfo(acc,cfg,v.vinNo).catch(()=>null),fetchBatteryChargeState(acc,cfg,v.vinNo).catch(()=>({chargeState:"未充电",voltage:0,current:0,batteryTemp:0,soc:0})),fetchServiceRechargeDetail(acc,cfg,v.vinNo).catch(()=>null),fetchVehicleHomePage(acc,cfg,v.vinNo).catch(()=>null)]);if(widgets){result.batteryPercent=widgets.batteryPercent;result.residualRangeKm=widgets.residualRangeKm;result.voltage=widgets.voltage;result.address=widgets.address;result.locationTime=widgets.locationTime;result.powerStatus=widgets.powerStatus||"";result.lockState=widgets.lockState||"";if(widgets.vehicleName)result.vehicleName=widgets.vehicleName;if(widgets.vehicleImageUrl)result.vehicleImageUrl=widgets.vehicleImageUrl;if(widgets.online)result.online=widgets.online;if(widgets.cushionState)result.cushionState=widgets.cushionState;if(widgets.longitude!==""&&widgets.longitude!==undefined)result.longitude=widgets.longitude;if(widgets.latitude!==""&&widgets.latitude!==undefined)result.latitude=widgets.latitude}if(homePage){if(homePage.powerStatus)result.powerStatus=homePage.powerStatus;if(homePage.lockState)result.lockState=homePage.lockState;if(homePage.online)result.online=homePage.online;if(homePage.rideState)result.rideState=homePage.rideState;if(homePage.cushionState)result.cushionState=homePage.cushionState;if((result.longitude===""||result.longitude===undefined)&&homePage.longitude!==""&&homePage.longitude!==undefined)result.longitude=homePage.longitude;if((result.latitude===""||result.latitude===undefined)&&homePage.latitude!==""&&homePage.latitude!==undefined)result.latitude=homePage.latitude}if(tire){result.frontPressure=tire.frontPressure;result.rearPressure=tire.rearPressure;result.frontTemp=tire.frontTemp;result.rearTemp=tire.rearTemp}if(ride){result.todayDistance=ride.todayDistance;result.todayDuration=ride.todayDuration;result.todayMaxSpeed=ride.todayMaxSpeed;result.lastRideMileage=ride.lastRideMileage;result.lastRideDuration=ride.lastRideDuration||0;result.totalMileage=ride.totalMileage||0;result.yesterdayDistance=ride.yesterdayDistance||0}result.chargeState=battery.chargeState||"未充电";if(battery.voltage)result.voltage=battery.voltage;if(battery.current)result.current=battery.current;if(battery.batteryTemp)result.batteryTemp=battery.batteryTemp;if((!result.residualRangeKm||result.residualRangeKm===0)&&battery.residualRangeKm)result.residualRangeKm=battery.residualRangeKm;if((!result.residualRangeKm||result.residualRangeKm===0)&&result.batteryPercent>0){result.residualRangeKm=Math.round(result.batteryPercent*1.5);result.rangeEstimated=true}if(service){result.serviceEndDate=service.rechargeEndDate||"";result.serviceStatus=service.serviceRechargeStatus||"";result.serviceRemainDays=service.lastUseDate||0;if(service.vehicleName)result.vehicleName=service.vehicleName}}catch(e){}return result}

async function checkToken(acc,cfg){try{const token=cleanToken(acc.token);const userId=acc.userId||"";if(!userId)return{valid:true,score:0,userName:acc.userName};const signH=getSign("app",{},'',cfg);const headers={"Authorization":"Bearer "+token,"Content-Type":"application/json;charset=UTF-8","interfaceversion":"2","user_id":userId,...signH};const res=await httpGet("https://tapi.zeehoev.com/v1.0/mine/cfmotoservermine/setting/"+userId,headers);if(res.code=="10000"&&res.data)return{valid:true,score:Number(res.data.score)||0,userName:res.data.nickName||acc.userName};if(res.code=="40001"||res.code==401)return{valid:false,reason:"token已过期"};return{valid:true,reason:res.message||"请求异常"}}catch(e){return{valid:true,reason:String(e)}}}

async function getUseridByToken(token,cfg){const t=cleanToken(token);const baseHeaders={"Authorization":"Bearer "+t,"Content-Type":"application/json;charset=UTF-8","interfaceversion":"2"};let userId="",userName="",error=null;try{const signH0=getSign("h5",{server_name:"SMART"},'',cfg);const res0=await httpGet("https://h5.zeehoev.com/cfmotoservermine/baseInfo?server_name=SMART",{...baseHeaders,...signH0});if(res0&&String(res0.code)==="10000"&&res0.data){userId=String(res0.data.id||"");userName=String(res0.data.nickName||"")}}catch(e){}if(!userId){try{const signH=getSign("app",{},'',cfg);const res=await httpGet("https://tapi.zeehoev.com/v1.0/mine/cfmotoservermine/setting",{...baseHeaders,...signH});if(res.code=="10000"&&res.data){userId=String(res.data.id||res.data.userId||"");userName=String(res.data.nickName||"")}}catch(e){}}if(!userId){try{const signH=getSign("app",{},'',cfg);const res=await httpGet("https://tapi.zeehoev.com/v1.0/app/cfmotoserverapp/vehicle/list",{...baseHeaders,...signH});const find=(obj,depth)=>{if(!obj||depth>5)return"";for(const key of Object.keys(obj)){const val=obj[key];if(/user.?id|uid|create.?by|owner.?id/i.test(key)&&val&&typeof val!=="object"){const s=String(val);if(s.length>=10&&/^\d+$/.test(s))return s}if(val&&typeof val==="object"){const f=find(val,depth+1);if(f)return f}}return""};const uid=find(res,0);if(uid){userId=uid;const findName=(obj,depth)=>{if(!obj||depth>4)return"";for(const key of Object.keys(obj)){if(/nick.?name|user.?name/i.test(key)&&obj[key]&&typeof obj[key]==="string")return obj[key];if(obj[key]&&typeof obj[key]==="object"){const n=findName(obj[key],depth+1);if(n)return n}}return""};userName=findName(res,0)}}catch(e){}}if(!userId)error="自动获取失败，请手动填写用户ID";return{ok:!!userId,userId,userName,error}}
/* ================= v2.16.0 隐藏骑行数据（轨迹解析 + 急刹/压弯检测）================= */
/* 官方 App 把「极速 / 急加速 / 急刹 / 压弯」藏了起来（服务端能力位 vehicleKinds / cyclingEventStatisticFlag 控制）。
   本页从 ridetrack_v2 的原始轨迹重算这些指标；算法与阈值逐行移植自 ZEEHO SpeedHunter
   （github.com/RyanYuFish/Zeeho-SpeedHunter，AGPL-3.0）的 RideConfig / TrackCalculator / BrakeDetector / BendDetector。
   轨迹串格式：lon,lat,speed,ts[,dir]&...（ridetrack_v2 的 trajectory 字段原样） */
/* __RIDE_ALGO_BEGIN__ */
var RIDE_CFG={BEND_V_MIN:20,BEND_SEED:5,BEND_CUM_MIN:15,BEND_CUM_CAP:90,BEND_COEF:1.0,BEND_V_MAX:80,BEND_MIN_KM:1.0,BEND_STEP_MAX:45,BEND_RUN_MIN:1,BEND_MERGE_GAP:0,BEND_ALLOW_GAP:0,BEND_SEG_DIST_MIN:6,BEND_GAP_MS_MAX:25000,BRAKE_V_MIN:15,BRAKE_WIN_LARGE:5,BRAKE_WIN_SMALL:3,BRAKE_DV_LARGE:15,BRAKE_DV_SMALL:20,BRAKE_A_MIN:0.5,BRAKE_MERGE_GAP:5,BRAKE_MIN_DUR:1.5,BRAKE_CALIB:2.5,MOVING_V_MIN:5,MIN_POINTS:4,EARTH_R:6371000};
function rideNum(v){const n=Number(v);return isFinite(n)?n:0}
function rideParseTrack(str){
  const pts=[];
  if(!str)return pts;
  const seg=String(str).split("&");
  for(const s of seg){
    if(!s)continue;
    const p=s.split(",");
    if(p.length<4)continue;
    const lon=parseFloat(p[0]),lat=parseFloat(p[1]),v=parseFloat(p[2]),t=parseFloat(p[3]);
    if(!isFinite(lon)||!isFinite(lat)||!isFinite(v)||!isFinite(t))continue;
    pts.push({lon:lon,lat:lat,v:v,t:t});
  }
  return pts;
}
function rideHaversine(lon1,lat1,lon2,lat2){
  const dLat=(lat2-lat1)*Math.PI/180,dLon=(lon2-lon1)*Math.PI/180;
  const a=Math.sin(dLat/2)*Math.sin(dLat/2)+Math.cos(lat1*Math.PI/180)*Math.cos(lat2*Math.PI/180)*Math.sin(dLon/2)*Math.sin(dLon/2);
  return RIDE_CFG.EARTH_R*2*Math.atan2(Math.sqrt(a),Math.sqrt(1-a));
}
function rideBearing(lon1,lat1,lon2,lat2){
  const y=Math.sin((lon2-lon1)*Math.PI/180)*Math.cos(lat2*Math.PI/180);
  const x=Math.cos(lat1*Math.PI/180)*Math.sin(lat2*Math.PI/180)-Math.sin(lat1*Math.PI/180)*Math.cos(lat2*Math.PI/180)*Math.cos((lon2-lon1)*Math.PI/180);
  return Math.atan2(y,x)*180/Math.PI;
}
function rideAngDiff(a,b){let d=b-a;while(d>180)d-=360;while(d<-180)d+=360;return d}
function rideMid(a,b){return a+rideAngDiff(a,b)/2}
function rideCalcMetrics(pts){
  if(!pts||pts.length<RIDE_CFG.MIN_POINTS)return null;
  let meters=0,movingMs=0,maxSpeed=0;
  for(let i=1;i<pts.length;i++){
    const a=pts[i-1],b=pts[i];
    meters+=rideHaversine(a.lon,a.lat,b.lon,b.lat);
    const vIn=Math.max(a.v,b.v),dt=b.t-a.t;
    if(vIn>RIDE_CFG.MOVING_V_MIN&&dt>0&&dt<60000)movingMs+=dt;
    if(b.v>maxSpeed)maxSpeed=b.v;
  }
  const durationMin=Math.max(0,pts[pts.length-1].t-pts[0].t)/60000;
  const movingMin=movingMs/60000;
  const distanceKm=meters/1000;
  return{points:pts.length,distanceKm:distanceKm,durationMin:durationMin,movingMin:movingMin,maxSpeed:maxSpeed<0?0:maxSpeed,avgSpeed:durationMin>0?distanceKm/durationMin:0,avgMovingSpeed:movingMin>0?distanceKm/movingMin:0};
}
function rideCountBrakes(pts){
  const n=pts?pts.length:0;
  if(n<4)return 0;
  const cands=[];
  const scan=(win,dvMin)=>{
    for(let i=0;i<=n-win;i++){
      if(pts[i].v<RIDE_CFG.BRAKE_V_MIN)continue;
      let maxV=-Infinity,maxIdx=i,minV=Infinity,minIdx=i;
      const upper=Math.min(i+win,n-1);
      for(let j=i+1;j<=upper;j++){
        const v=pts[j].v;
        if(v>maxV){maxV=v;maxIdx=j}
        if(v<minV){minV=v;minIdx=j}
      }
      const dv=maxV-minV;
      if(dv<dvMin||minIdx<=maxIdx)continue;
      const dt=(pts[minIdx].t-pts[maxIdx].t)/1000;
      if(dt<RIDE_CFG.BRAKE_MIN_DUR||dv/3.6/dt<RIDE_CFG.BRAKE_A_MIN)continue;
      cands.push({idx:maxIdx,dv:dv});
    }
  };
  scan(RIDE_CFG.BRAKE_WIN_LARGE,RIDE_CFG.BRAKE_DV_LARGE);
  scan(RIDE_CFG.BRAKE_WIN_SMALL,RIDE_CFG.BRAKE_DV_SMALL);
  cands.sort((a,b)=>a.idx-b.idx);
  const merged=[];
  for(const c of cands){
    if(!merged.length||c.idx-merged[merged.length-1].idx>=RIDE_CFG.BRAKE_MERGE_GAP)merged.push(c);
    else if(c.dv>merged[merged.length-1].dv)merged[merged.length-1]=c;
  }
  const r=Math.round(merged.length*RIDE_CFG.BRAKE_CALIB);
  return r<0?0:r;
}
function rideCountBends(pts){
  const n=pts?pts.length:0;
  if(n<4)return 0;
  const hdg=new Array(n-1);
  for(let i=0;i<n-1;i++){
    const a=pts[i],b=pts[i+1];
    const d=rideHaversine(a.lon,a.lat,b.lon,b.lat),tt=b.t-a.t;
    hdg[i]=(d<RIDE_CFG.BEND_SEG_DIST_MIN||tt>RIDE_CFG.BEND_GAP_MS_MAX||tt<=0)?NaN:rideBearing(a.lon,a.lat,b.lon,b.lat);
  }
  const sh=new Array(n-1);
  for(let i=0;i<n-1;i++){
    if(isNaN(hdg[i])){sh[i]=NaN;continue}
    const prev=(i>0&&!isNaN(hdg[i-1]))?hdg[i-1]:null;
    const next=(i<n-2&&!isNaN(hdg[i+1]))?hdg[i+1]:null;
    if(prev!==null&&next!==null)sh[i]=rideMid(rideMid(prev,hdg[i]),next);
    else if(prev!==null)sh[i]=rideMid(prev,hdg[i]);
    else if(next!==null)sh[i]=rideMid(hdg[i],next);
    else sh[i]=hdg[i];
  }
  const turn=new Array(n).fill(false),dhdg=new Array(n).fill(0),sgn=new Array(n).fill(0);
  for(let i=1;i<n-1;i++){
    if(isNaN(sh[i-1])||isNaN(sh[i]))continue;
    const d=rideAngDiff(sh[i-1],sh[i]);
    dhdg[i]=d;
    const vIn=Math.max(pts[i-1].v,pts[i].v);
    if(vIn<RIDE_CFG.BEND_V_MIN||vIn>RIDE_CFG.BEND_V_MAX)continue;
    if(Math.abs(d)>=RIDE_CFG.BEND_STEP_MAX)continue;
    if(Math.abs(d)>=RIDE_CFG.BEND_SEED){turn[i]=true;sgn[i]=d>0?1:-1}
  }
  const runs=[];let cur=null,gap=0;
  for(let i=1;i<n-1;i++){
    if(turn[i]){
      if(cur===null){cur={s:i,e:i,cum:Math.abs(dhdg[i]),sign:sgn[i]}}
      else if(sgn[i]===cur.sign){cur.cum+=Math.abs(dhdg[i])}
      else{runs.push(cur);cur={s:i,e:i,cum:Math.abs(dhdg[i]),sign:sgn[i]}}
      cur.e=i;gap=0;
    }else if(cur!==null&&gap<RIDE_CFG.BEND_ALLOW_GAP){gap++;cur.e=i}
    else if(cur!==null){runs.push(cur);cur=null}
  }
  if(cur!==null)runs.push(cur);
  let cnt=0,lastEnd=NaN,lastSign=0;
  for(const r of runs){
    if(r.cum<RIDE_CFG.BEND_CUM_MIN||r.cum>RIDE_CFG.BEND_CUM_CAP)continue;
    if(r.e-r.s+1<RIDE_CFG.BEND_RUN_MIN)continue;
    let maxV=0;
    for(let j=r.s;j<=r.e&&j<n;j++){if(pts[j].v>maxV)maxV=pts[j].v}
    if(maxV>RIDE_CFG.BEND_V_MAX)continue;
    if(r.sign===lastSign&&!isNaN(lastEnd)&&r.s-lastEnd<=RIDE_CFG.BEND_MERGE_GAP){lastEnd=r.e;continue}
    cnt++;lastEnd=r.e;lastSign=r.sign;
  }
  return Math.round(cnt*RIDE_CFG.BEND_COEF);
}
function rideNormDay(raw){
  if(raw==null)return null;
  let t=String(raw).trim();
  if(!t)return null;
  if(t.length===8&&/^\d{8}$/.test(t))return t.slice(0,4)+"."+t.slice(4,6)+"."+t.slice(6,8);
  t=t.replace(/-/g,".").replace(/\//g,".");
  const p=t.split(".");
  if(p.length===3&&/^\d+$/.test(p[0])&&/^\d+$/.test(p[1])&&/^\d+$/.test(p[2]))
    return p[0]+"."+String(parseInt(p[1],10)).padStart(2,"0")+"."+String(parseInt(p[2],10)).padStart(2,"0");
  return null;
}
/* 一组 ridetrack_v2 天分组 → {dayKey:{km,dur,maxV,brakes,bends,rides:[...]}}
   语义与 SpeedHunter RideFill 一致：急刹/压弯按轨迹重算（服务端这两个字段常年缺失）；
   里程/极速服务端非 0 时以服务端为准，为 0 才补算。 */
function rideDayScan(days){
  const out={};
  if(!Array.isArray(days))return out;
  for(const day of days){
    if(!day||typeof day!=="object")continue;
    const list=Array.isArray(day.historyList)?day.historyList:[];
    for(const r of list){
      if(!r||typeof r!=="object")continue;
      const traj=String(r.trajectory||"");
      if(!traj)continue;
      const pts=rideParseTrack(traj);
      if(pts.length<RIDE_CFG.MIN_POINTS)continue;
      const m=rideCalcMetrics(pts);
      const brakes=rideCountBrakes(pts);
      let bends=rideCountBends(pts);
      if(m&&m.distanceKm<RIDE_CFG.BEND_MIN_KM)bends=0;   // 短行程整趟判0：<1km 的密度是长途的 8 倍（GPS 停车乱飘）
      const dk=rideNormDay(r.dayTime||day.dayTime);
      if(!dk)continue;
      const g=out[dk]||(out[dk]={km:0,dur:0,maxV:0,brakes:0,bends:0,rides:[]});
      const srvMax=rideNum(r.maxSpeed);
      const maxV=srvMax>0?srvMax:(m?m.maxSpeed:0);
      g.km+=m?m.distanceKm:0;g.dur+=m?m.durationMin:0;
      if(maxV>g.maxV)g.maxV=maxV;
      g.brakes+=brakes;g.bends+=bends;
      let addr="";
      try{
        const sa=JSON.parse(r.startAddr||"{}"),ea=JSON.parse(r.endAddr||"{}");
        const s1=String(sa.name||sa.address||"").trim(),e1=String(ea.name||ea.address||"").trim();
        if(s1||e1)addr=(s1||"")+" → "+(e1||"");
      }catch(e){}
      g.rides.push({t0:pts[0].t,km:m?m.distanceKm:0,dur:m?m.durationMin:0,maxV:maxV,brakes:brakes,bends:bends,points:pts.length,
        t0str:String(r.startTime||""),t1str:String(r.endTime||""),addr:addr,
        srvKm:rideNum(r.rideMileage),srvDur:rideNum(r.ridingTimeUnitMinute),srvAccel:rideNum(r.accelerationTimes),
        thumb:String(r.trackThumbnails||"")});
    }
  }
  for(const k in out)if(out[k]&&out[k].rides)out[k].rides.sort((a,b)=>a.t0-b.t0);
  return out;
}
/* __RIDE_ALGO_END__ */
/* 直连模式（非代理）拉取：月度汇总 / 轨迹分页（走账号 Token + app 签名，与首页直连一致） */
function rideAccLocal(userId){const accs=getAccounts();return accs.find(a=>String(a.userId)===String(userId))||accs[0]||null}
async function fetchRideMonthDirect(acc,cfg,month,vin){
  try{
    if(!acc)return{ok:false,error:"未找到账号"};
    const month2=month||(new Date().getFullYear()+"."+String(new Date().getMonth()+1).padStart(2,"0"));
    let vinNo=String(vin||"").trim(),vehicleName="";
    if(!vinNo){
      const list=await fetchVehicleList(acc,cfg);
      const vehicles=list.filter(x=>!/模拟/.test(String(x.name||"")+" "+String(x.vehicleType||"")));
      if(!vehicles.length)return{ok:false,error:"账号未绑定车辆"};
      vinNo=vehicles[0].vinNo;vehicleName=vehicles[0].name;
    }
    const query="vinNo="+encodeURIComponent(vinNo)+"&month="+encodeURIComponent(month2);
    const res=await httpGet("https://tapi.zeehoev.com/v1.0/app/cfmotoserverapp/myRideInfo?"+query,appQueryHeaders(acc,query,cfg));
    if(res&&String(res.code)==="10000")return{ok:true,month:month2,vinNo:vinNo,vehicleName:vehicleName,data:res.data||{}};
    return{ok:false,error:(res&&(res.message||res.code))||"接口无响应",vinNo:vinNo};
  }catch(e){return{ok:false,error:String(e)}}
}
async function fetchBatteryStateDirect(acc,cfg,vin){
  try{
    if(!acc)return{ok:false,error:"未找到账号"};
    let vinNo=String(vin||"").trim();
    if(!vinNo){const list=await fetchVehicleList(acc,cfg);const vs=list.filter(x=>!/模拟/.test(String(x.name||"")+" "+String(x.vehicleType||"")));if(!vs.length)return{ok:false,error:"账号未绑定车辆"};vinNo=vs[0].vinNo;}
    const res=await httpGet("https://tapi.zeehoev.com/v1.0/app/cfmotoserverapp/batteryInfo/"+encodeURIComponent(vinNo),baseHeaders(acc));
    if(res&&res.code=="10000"&&res.data){const d=res.data;return{ok:true,vinNo:vinNo,charging:/充电/.test(String(d.chargeStateStr||d.chargeState||"")),current:Number(d.current||d.batteryCurrent||d.bmsCurrent||0),soc:Number(d.soc||d.bmssoc||0),voltage:Number(d.voltage||d.batteryVoltage||d.bmsVoltage||0),chargeState:String(d.chargeStateStr||d.chargeState||"未充电"),fullChargeTime:Number(d.fullChargeTime||0),fullChargeTimeSecond:Number(d.fullChargeTimeSecond||0)};}
    return{ok:false,error:(res&&(res.message||res.msg))||"接口无响应"};
  }catch(e){return{ok:false,error:String(e)}}
}
async function fetchRideTrackDirect(acc,cfg,vin,page,pageSize,month){
  try{
    if(!acc)return{ok:false,error:"未找到账号"};
    let vinNo=String(vin||"").trim();
    if(!vinNo){
      const list=await fetchVehicleList(acc,cfg);
      const vehicles=list.filter(x=>!/模拟/.test(String(x.name||"")+" "+String(x.vehicleType||"")));
      if(!vehicles.length)return{ok:false,error:"账号未绑定车辆"};
      vinNo=vehicles[0].vinNo;
    }
    const pg=Math.max(1,Number(page)||1),ps=Math.max(1,Math.min(200,Number(pageSize)||20));
    const st=String(month||"").replace(".","-")||(new Date().getFullYear()+"-"+String(new Date().getMonth()+1).padStart(2,"0"));
    const query="vinNo="+encodeURIComponent(vinNo)+"&page="+pg+"&pageSize="+ps+"&startTime="+encodeURIComponent(st);
    const res=await httpGet("https://tapi.zeehoev.com/v1.0/app/cfmotoserverapp/ridetrack_v2?"+query,appQueryHeaders(acc,query,cfg));
    if(res&&String(res.code)==="10000"){
      let days=[];
      if(Array.isArray(res.data))days=res.data;
      else if(res.data&&Array.isArray(res.data.list))days=res.data.list;
      else if(res.data&&Array.isArray(res.data.dayList))days=res.data.dayList;
      return{ok:true,page:pg,vinNo:vinNo,days:days};
    }
    return{ok:false,error:(res&&(res.message||res.code))||"接口无响应",page:pg,vinNo:vinNo};
  }catch(e){return{ok:false,error:String(e)}}
}
/* ================= 账号数据拉取 ================= */
async function fetchAccountData(acc,cfg,vinNo){const token=cleanToken(acc.token);let userId=acc.userId||"";const now=new Date();const today=now.getFullYear()+"-"+String(now.getMonth()+1).padStart(2,"0")+"-"+String(now.getDate()).padStart(2,"0");const result={userName:acc.userName||"未知用户",userId,score:0,signedToday:false,continueDays:0,todayScore:0,signCount:0,last7:[],error:null,vehicle:{hasVehicle:false}};
if(!userId){try{const signH=getSign("app",{},'',cfg);const vehicleRes=await httpGet("https://tapi.zeehoev.com/v1.0/app/cfmotoserverapp/vehicle/list",{"Authorization":"Bearer "+token,"Content-Type":"application/json;charset=UTF-8","interfaceversion":"2",...signH});if(vehicleRes.code=="10000"&&vehicleRes.data){const autoUid=String(vehicleRes.data.userId||vehicleRes.data.uid||vehicleRes.data.id||"");if(autoUid){userId=autoUid;result.userId=userId;const accounts=getAccounts();const idx=accounts.findIndex(a=>cleanToken(a.token)===token);if(idx>=0&&!accounts[idx].userId){accounts[idx].userId=userId;saveAccounts(accounts)}}}}catch(e){}}
try{result.vehicle=await fetchVehicleInfo(acc,cfg,vinNo)}catch(e){result.vehicle={hasVehicle:false}}
try{if(!userId){result.error="请在设置页填写用户ID"}else{const signH=getSign("app",{},'',cfg);const infoRes=await httpGet("https://tapi.zeehoev.com/v1.0/mine/cfmotoservermine/setting/"+userId,{"Authorization":"Bearer "+token,"Content-Type":"application/json;charset=UTF-8","interfaceversion":"2","user_id":userId,...signH});if(infoRes.code=="10000"&&infoRes.data){result.score=Number(infoRes.data.score||infoRes.data.integral||infoRes.data.point||infoRes.data.points||infoRes.data.totalScore||infoRes.data.totalIntegral||0)}else if(infoRes.code=="40001"||infoRes.code==401){result.error="Token已过期"}else{result.error="积分获取失败: "+(infoRes.message||infoRes.code||"未知错误")}}}catch(e){if(!result.error)result.error="积分获取异常: "+String(e)}
try{const curMonth=now.getFullYear()+"-"+(now.getMonth()+1);const lastDate=new Date(now.getFullYear(),now.getMonth()-1,1);const lastMonth=lastDate.getFullYear()+"-"+(lastDate.getMonth()+1);const baseHeaders={"Authorization":"Bearer "+token,"Content-Type":"application/json;charset=UTF-8","interfaceversion":"2","user_id":userId};const [curRes,lastRes]=await Promise.all([httpGet("https://h5.zeehoev.com/cfmotoservermine/H5/signin/info?month="+curMonth,{...baseHeaders,...getSign("h5",{month:curMonth},'',cfg)}),httpGet("https://h5.zeehoev.com/cfmotoservermine/H5/signin/info?month="+lastMonth,{...baseHeaders,...getSign("h5",{month:lastMonth},'',cfg)})]);const lastList=(lastRes.code=="10000"&&lastRes.data)?(lastRes.data.nowSignDetailVos||[]):[];const curList=(curRes.code=="10000"&&curRes.data)?(curRes.data.nowSignDetailVos||[]):[];const list=[...lastList,...curList];if(curRes.code=="10000"&&curRes.data){result.signCount=Number(curRes.data.signCount)||0}const todayEntry=curList.find(x=>x.createDate===today);result.signedToday=!!(todayEntry&&(todayEntry.signStatue==3||todayEntry.signStatue==5||todayEntry.signStatue==0));result.todayScore=todayEntry?(Number(todayEntry.integralScore)||0):0;try{const _todayLogs=(getLogs()||[]).filter(l=>l&&l.date===today&&String(l.userId||"")===String(userId)&&l.success);if(_todayLogs.length>0){const _tl=_todayLogs[0];result.todayScore=Number(_tl.totalGain)||result.todayScore;result.todayDetail={signinScore:Number(_tl.signinScore)||0,blindBoxScore:Number(_tl.blindBoxScore)||0,interactScore:Number(_tl.interactScore)||0}}}catch(e){}const todayIdx=list.findIndex(x=>x.createDate===today);let cont=0;if(todayIdx>=0){for(let i=todayIdx;i>=0;i--){const st=list[i]?.signStatue;if(st==3||st==5||(i===todayIdx&&st==0))cont++;else break}}result.continueDays=cont;for(let i=6;i>=0;i--){const d=new Date();d.setDate(d.getDate()-i);const ds=d.getFullYear()+"-"+String(d.getMonth()+1).padStart(2,"0")+"-"+String(d.getDate()).padStart(2,"0");const entry=list.find(x=>x.createDate===ds);result.last7.push({date:ds.slice(5),signed:!!(entry&&(entry.signStatue==3||entry.signStatue==5||entry.signStatue==0)),isToday:i===0})}}catch(e){if(!result.error)result.error="签到状态获取失败"}
try{const tokenCheck=await checkToken(acc,cfg);result.tokenValid=tokenCheck.valid;result.tokenReason=tokenCheck.reason||null;if(tokenCheck.valid&&tokenCheck.userName&&(!result.userName||result.userName==="未知用户"))result.userName=tokenCheck.userName}catch(e){result.tokenValid=true}
return result}

function getPostIdFromData(data){if(!data)return null;if(typeof data==="string"||typeof data==="number")return String(data);if(Array.isArray(data))return getPostIdFromData(data[0]);const direct=data.uuid||data.tuuid||data.postId||data.postid||data.articleId||data.articleID||data.id||data.dataId||data.tid;if(direct)return String(direct);for(const key of ["records","list","rows","data","result"]){const v=data[key];const pid=getPostIdFromData(v);if(pid)return pid}return null}

/* ================= 签到执行 ================= */
async function runSigninForAccount(acc,cfg){const result={userName:acc.userName||"未知",userId:acc.userId,success:false,signinScore:0,blindBoxScore:0,interactScore:0,totalGain:0,continueDays:0,error:null,steps:[]};try{const token=cleanToken(acc.token);const userId=acc.userId||"";const baseHeaders={"Authorization":"Bearer "+token,"Content-Type":"application/json;charset=UTF-8","interfaceversion":"2","user_id":userId};const now=new Date();const today=now.getFullYear()+"-"+String(now.getMonth()+1).padStart(2,"0")+"-"+String(now.getDate()).padStart(2,"0");const month=today.slice(0,7);
try{const infoRes=await httpGet("https://h5.zeehoev.com/cfmotoservermine/H5/signin/info?month="+month,{...baseHeaders,...getSign("h5",{month},'',cfg)});const todayEntry=(infoRes?.data?.nowSignDetailVos||[]).find(x=>x.createDate===today);if(todayEntry&&(todayEntry.signStatue==3||todayEntry.signStatue==5||todayEntry.signStatue==0)){result.steps.push("今日已签到")}else{let signRes=null,signMsg="未知";for(let at=1;at<=3;at++){signRes=await httpPost("https://h5.zeehoev.com/cfmotoservermine/H5/signin",{...baseHeaders,...getSign("h5",{},'{}',cfg)},{});if(signRes?.code=="10000")break;signMsg=signRes?.message||"未知";if(/请稍|稍后|稍候|频繁|繁忙|重试/.test(signMsg)&&at<3){await new Promise(r=>setTimeout(r,(at+1)*2000));continue}break}if(signRes?.code=="10000"){const infoRes2=await httpGet("https://h5.zeehoev.com/cfmotoservermine/H5/signin/info?month="+month,{...baseHeaders,...getSign("h5",{month},'',cfg)});const te=(infoRes2?.data?.nowSignDetailVos||[]).find(x=>x.createDate===today);result.signinScore=te?(Number(te.integralScore)||0):0;result.steps.push("签到成功 +"+result.signinScore)}else{try{const chk=await httpGet("https://h5.zeehoev.com/cfmotoservermine/H5/signin/info?month="+month,{...baseHeaders,...getSign("h5",{month},'',cfg)});const ce=(chk?.data?.nowSignDetailVos||[]).find(x=>x.createDate===today);if(ce&&(ce.signStatue==3||ce.signStatue==5||ce.signStatue==0))result.steps.push("今日已签到");else result.steps.push("签到失败: "+signMsg)}catch(e){result.steps.push("签到失败: "+signMsg)}}}
}catch(e){result.steps.push("签到异常: "+e)}
try{const infoRes=await httpGet("https://h5.zeehoev.com/cfmotoservermine/H5/signin/info?month="+month,{...baseHeaders,...getSign("h5",{month},'',cfg)});const list=infoRes?.data?.nowSignDetailVos||[];const todayIdx=list.findIndex(x=>x.createDate===today);let cont=0;for(let i=todayIdx;i>=0;i--){const st=list[i]?.signStatue;if(st==3||st==5||(i===todayIdx&&st==0))cont++;else break}result.continueDays=cont;const signCount=Number(infoRes?.data?.signCount)||0;const prizeDate=String(infoRes?.data?.signPrizeDate||"");const isBoxDay=prizeDate?(prizeDate===today):(signCount>=30);if(isBoxDay){const blindRes=await httpPost("https://h5.zeehoev.com/cfmotoservermine/H5/signin/lottery?dateTime="+encodeURIComponent(today),{...baseHeaders,...getSign("h5",{dateTime:today},'',cfg)},"");const bd=(blindRes?.data&&blindRes.data.signPrizesVO)||blindRes?.data||{};result.blindBoxScore=Number(bd.integral||bd.integralScore||bd.score||0);if(String(blindRes?.code)=="10000"){result.steps.push("盲盒获得 +"+result.blindBoxScore+" ("+(bd.prizesName||bd.prizeName||"积分")+")")}else{result.steps.push("盲盒未开: "+(blindRes?.message||blindRes?.error||("code="+blindRes?.code)))}}else{result.steps.push("距盲盒 "+Math.max(0,30-(signCount||cont))+" 天")}}catch(e){result.steps.push("盲盒异常: "+e)}
const comm=cfg.community||{};let postId=null;
if(comm.enablePost!==false){try{const postRes=await httpPost("https://tapi.zeehoev.com/v1.0/social/cfmotoserversocial/commonArticle",{...baseHeaders,...getSign("app",{},'',cfg)},{postcontent:"lucky"});if(postRes?.code=="10000"){postId=getPostIdFromData(postRes.data);result.interactScore+=1;result.steps.push("发帖成功 +1")}}catch(e){result.steps.push("发帖异常: "+e)}}
if(!postId){try{const listRes=await httpGet("https://tapi.zeehoev.com/v1.0/social/cfmotoserversocial/community/mineArticleInfo?userId="+userId+"&page=1&pageSize=10",{...baseHeaders,...getSign("app",{},'',cfg)});const rawList=Array.isArray(listRes?.data)?listRes.data:(listRes?.data?.records||listRes?.data?.list||[]);const list=Array.isArray(rawList)?rawList:[];const mine=list.find(it=>String(it.userId||it.createBy||it.uid||"")===String(userId));postId=getPostIdFromData(mine||list[0]||listRes?.data)}catch(e){}}
if(postId){if(comm.enableLike!==false){try{const likeRes=await httpPost("https://tapi.zeehoev.com/v1.0/social/cfmotoserversocial/socialCommu/likeFavoriteInfo",{...baseHeaders,...getSign("app",{},'',cfg)},{postId:String(postId),kindFlag:"0"});if(likeRes?.code=="10000"){result.interactScore+=1;result.steps.push("点赞成功 +1")}}catch(e){result.steps.push("点赞异常: "+e)}}if(comm.enableComment!==false){try{await httpPost("https://tapi.zeehoev.com/v1.0/social/cfmotoserversocial/commentInfo",{...baseHeaders,...getSign("app",{},'',cfg)},{postid:String(postId),userId:String(userId),comments:"今日已签到",sendTos:"[\n\n]"});result.steps.push("评论完成")}catch(e){result.steps.push("评论异常: "+e)}}if(comm.enableShare!==false){try{const shareRes=await httpPut("https://tapi.zeehoev.com/v1.0/social/cfmotoserversocial/article/share/"+postId,{...baseHeaders,...getSign("app",{},'',cfg)});if(shareRes?.code=="10000"){result.interactScore+=1;result.steps.push("分享成功 +1")}await httpGet("https://tapi.zeehoev.com/v1.0/mine/cfmotoservermine/integral/adjustByShare",{...baseHeaders,...getSign("app",{},'',cfg)})}catch(e){result.steps.push("分享异常: "+e)}}if(comm.enableDelete!==false&&postId){try{await httpDelete("https://tapi.zeehoev.com/v1.0/social/cfmotoserversocial/commonArticle/deleteArticle?articleId="+postId+"&postType=1",{...baseHeaders,...getSign("app",{},'',cfg)});result.steps.push("动态已删除")}catch(e){result.steps.push("删除异常: "+e)}}}
result.totalGain=result.signinScore+result.blindBoxScore+result.interactScore;result.success=true}catch(e){result.error=String(e);result.steps.push("执行异常: "+e)}return result}

/* ================= 车辆控制 ================= */
const VEHICLE_ACTION_TEXT={find:"短按寻车",loudFind:"鸣笛闪灯",cushion:"打开坐垫",unlock:"云端开锁",lock:"云端关锁"};
function vehicleCheckRes(res,okMsg){if(res&&!res.error&&(res.code=="10000"||res.code===10000))return{ok:true,message:okMsg};const errText=String((res&&(res.error||res.message||res.msg))||"").toLowerCase();if(res&&res.error&&/timeout|timed out|time out|请求超时/.test(errText))return{ok:true,message:okMsg+"（响应超时但车辆通常已执行，可下拉刷新确认）"};return{ok:false,message:(res&&(res.message||res.msg))||(res&&res.error)||"指令下发失败",code:res&&res.code}}
async function vehicleControl(acc,action,cfg){try{const c=cfg||getCfg();let vin=acc.vinNo||"";if(!vin){const list=await fetchVehicleList(acc,c);if(!list||!list.length)return{ok:false,message:"未获取到绑定车辆(VIN)，请确认账号已绑定车辆"};vin=list[0].vinNo}const base=baseHeaders(acc);if(action==="find"){const h={...base,...getSign("app",{},"",c)};const res=await httpPut("https://tapi.zeehoev.com/v1.0/app/cfmotoserverapp/vehicleInfo/control/"+vin,h);return vehicleCheckRes(res,"寻车指令已下发，车辆应闪灯提示")}if(action==="loudFind"){const bodyStr=JSON.stringify({param:"4",vin:vin});const h={...base,...getSign("app",{},bodyStr,c)};const res=await httpPost("https://tapi.zeehoev.com/v1.0/app/cfmotoserverapp/vehicleInfo/controlV2",h,bodyStr);return vehicleCheckRes(res,"鸣笛闪灯指令已下发")}if(action==="cushion"){const bodyStr=JSON.stringify({commond:"28",commondParam:"1",vcu:vin,version:"v2"});const h={...base,...getSign("app",{},bodyStr,c)};const res=await httpPut("https://tapi.zeehoev.com/v1.0/app/cfmotoserverapp/vehicleSet/propertyTwo/one",h,bodyStr);return vehicleCheckRes(res,"开坐垫指令已下发，坐垫应弹起")}if(action==="unlock"||action==="lock"){const vKey=(c.vehicleAesKey||"").trim();if(!vKey)return{ok:false,message:"尚未配置云端控车密钥：请到「设置-签名密钥配置」填写云端控车AES密钥并保存后再使用开/关锁"};if(!/^[0-9a-fA-F]{32}$/.test(vKey))return{ok:false,message:"云端控车密钥格式错误（应为32位十六进制），请到设置页核对后保存"};const lockFlag=action==="unlock"?"1":"0";const plain='{\n  "lockFlag" : "'+lockFlag+'",\n  "vinNo" : "'+vin+'"\n}';const secret=aes256EcbEncryptBase64(plain,vKey);const sendBody=JSON.stringify({secret:secret});const h={...base,...getSign("app",{},plain,c)};const res=await httpPost("https://tapi.zeehoev.com/v1.0/app/cfmotoserverapp/vehicleSet/network/unlock",h,sendBody,25000);return vehicleCheckRes(res,action==="unlock"?"云端开锁指令已下发":"云端关锁指令已下发")}return{ok:false,message:"未知操作类型: "+action}}catch(e){return{ok:false,message:"控制异常: "+String(e)}}}

async function barkPush(barkKey,title,body){try{let s=String(barkKey||"").trim().replace(/\/+$/,"");s=s.replace(/^https?:\/\/api\.day\.app\//i,"");if(!s)return{skipped:true};let base="https://api.day.app",key=s;const m=s.match(/^(https?:\/\/[^/]+)\/(.+)$/i);if(m){base=m[1];key=m[2]}key=key.replace(/^\/+/,"");const u=base+"/"+encodeURIComponent(key)+"/"+encodeURIComponent(title)+"/"+encodeURIComponent(body)+"?group=ZEEHO&sound=birdsong";return await httpGet(u,{})}catch(e){return{error:String(e)}}}

/* ================= 代理模式（指向原脚本 zeeho.box 后端） ================= */
async function proxyFetch(path,opts){const rawBase=getCfg().serverBase.replace(/\/+$/,"");const base=(window.__PANEL_MODE__&&!rawBase)?"":rawBase;const r=await fetch(base+path,opts||{});const t=await r.text();try{return JSON.parse(t)}catch(e){return{error:"parse error",raw:t}}}
function proxyPost(path,body){return proxyFetch(path,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(body||{})})}

async function fetchAllAccounts(accounts,cfg,limit){const out=new Array(accounts.length);let i=0;async function worker(){while(i<accounts.length){const idx=i++;try{out[idx]=await fetchAccountData(accounts[idx],cfg)}catch(e){out[idx]={userName:accounts[idx].userName||"未知",userId:accounts[idx].userId,success:false,error:String(e)}}}}const n=Math.max(1,Math.min(limit||3,accounts.length));await Promise.all(Array.from({length:n},worker));return out}

const Backend={
  async sendCode(phone){
    if(isProxyMode()){const d=await proxyPost("/api/send-code",{phone:phone});return{ok:!!d.ok,message:d.message||(d.ok?"验证码已发送":"发送失败")};}
    const cfg=getCfg();const url="https://tapi.zeehoev.com/v1.0/mine/cfmotoservermine/authCode/"+encodeURIComponent(phone);
    const d=await httpGet(url,{"Content-Type":"application/json;charset=UTF-8","User-Agent":"okhttp/4.9.2",...appGatewaySign(url,"GET",{},"",cfg)});
    return{ok:String(d.code)==="10000",message:String(d.code)==="10000"?"验证码已发送，请查收短信":((d&&(d.message||d.msg))||"发送失败")};
  },
  async phoneLogin(phone,code,basicAuth){
    const basic=String(basicAuth||"").trim().replace(/^Basic\s+/i,"");
    if(isProxyMode()){const d=await proxyPost("/api/phone-login",{phone:phone,code:code,basicAuth:basic});return{ok:!!d.ok,message:d.message||(d.ok?"登录成功":"登录失败")};}
    const cfg=getCfg();const payload={phone:phone,authCode:code};
    const url="https://tapi.zeehoev.com/v1.0/mine/cfmotoservermine/user/loginByPhone";
    const hdr={"Content-Type":"application/json;charset=UTF-8","User-Agent":"okhttp/4.9.2",...appGatewaySign(url,"POST",{},payload,cfg)};
    if(basic)hdr["Authorization"]="Basic "+basic;
    const res=await httpPost(url,hdr,payload,20000);
    const tokenInfo=res&&res.data&&res.data.tokenInfo;const accessToken=tokenInfo&&String(tokenInfo.access_token||"");
    if(!res||String(res.code)!=="10000"||!accessToken)return{ok:false,message:"登录失败："+((res&&(res.message||res.msg))||"验证码有误或已过期")};
    let userId="",userName="";
    try{const signH0=getSign("h5",{server_name:"SMART"},"",cfg);const infoRes=await httpGet("https://h5.zeehoev.com/cfmotoservermine/baseInfo?server_name=SMART",{"Authorization":"Bearer "+accessToken,"Content-Type":"application/json;charset=UTF-8","interfaceversion":"2",...signH0});if(infoRes&&String(infoRes.code)==="10000"&&infoRes.data){userId=String(infoRes.data.id||"");userName=String(infoRes.data.nickName||"");}}catch(e){}
    const list=getAccounts();let replaced=false;
    for(let i=0;i<list.length;i++){if(list[i]&&(String(list[i].token||"")===accessToken||(list[i].userId&&userId&&String(list[i].userId)===userId))){list[i].token=accessToken;if(userId)list[i].userId=userId;if(userName)list[i].userName=userName;replaced=true;break;}}
    const newAcc={userName:userName||phone,userId:userId,token:accessToken,barkKey:"",userAgent:""};
    if(!replaced)list.push(newAcc);
    saveAccounts(list);
    return{ok:true,message:replaced?"登录成功，已更新该账号":"登录成功，已添加账号"};
  },
  async getDashboard(){
    if(isProxyMode()){
      const d=await proxyFetch("/api/data");
      if(d&&d.accounts)return{accounts:d.accounts,timestamp:d.timestamp||new Date().toISOString(),config:d.config||null,ok:true};
      return{ok:false,error:(d&&d.error)||"代理服务无响应",raw:d};
    }
    const cfg=getCfg();const accounts=getAccounts();const data=await fetchAllAccounts(accounts,cfg,3);
    return{accounts:data,timestamp:new Date().toISOString(),ok:true};
  },
  async runSignin(userId,all){
    if(isProxyMode()){const d=await proxyPost("/api/run-signin",all?{all:true}:{userId:userId});if(d&&d.results)return{ok:true,results:d.results};return{ok:false,error:(d&&d.error)||"执行失败"}}
    const cfg=getCfg();const accounts=getAccounts();const results=[];const targets=all?accounts:accounts.filter(a=>String(a.userId)===String(userId));
    if(!targets.length)return{ok:true,results:[]};
    for(const acc of targets){const r=await runSigninForAccount(acc,cfg);results.push(r);const _d=new Date();const _ds=_d.getFullYear()+"-"+String(_d.getMonth()+1).padStart(2,"0")+"-"+String(_d.getDate()).padStart(2,"0");addLog({time:_d.toLocaleString("zh-CN",{hour12:false}),date:_ds,type:"signin",userName:r.userName,userId:r.userId,success:r.success,totalGain:r.totalGain,signinScore:r.signinScore,blindBoxScore:r.blindBoxScore,interactScore:r.interactScore,continueDays:r.continueDays,error:r.error,steps:r.steps});if(r.success&&acc.barkKey&&String(acc.barkKey).trim()){try{await barkPush(acc.barkKey,"极核签到成功 · "+(r.userName||""),"今日获得 "+r.totalGain+" 分（签到"+r.signinScore+" / 盲盒"+r.blindBoxScore+" / 互动"+r.interactScore+"），连签 "+r.continueDays+" 天")}catch(e){}}}
    return{ok:true,results};
  },
  async vehicleCtrl(userId,action){
    if(isProxyMode()){const d=await proxyPost("/api/vehicle-control",{userId:userId,action:action});return{ok:!!d.ok,message:d.message||(d.ok?"指令已下发":"指令失败")}}
    const cfg=getCfg();const accounts=getAccounts();let acc=accounts.find(a=>String(a.userId)===String(userId));if(!acc&&accounts.length)acc=accounts[0];if(!acc)return{ok:false,message:"未找到账号，请先在设置页添加"};if(!VEHICLE_ACTION_TEXT[action])return{ok:false,message:"非法操作类型"};const r=await vehicleControl(acc,action,cfg);const _vd=new Date();const _vds=_vd.getFullYear()+"-"+String(_vd.getMonth()+1).padStart(2,"0")+"-"+String(_vd.getDate()).padStart(2,"0");addLog({time:_vd.toLocaleString("zh-CN",{hour12:false}),date:_vds,type:"vehicle",action:action,actionText:VEHICLE_ACTION_TEXT[action]||"车辆控制",userName:acc.userName||"未知",userId:acc.userId,success:!!r.ok,message:r.message||"",error:r.ok?"":(r.message||"指令失败")});return r;
  },
  async getLogs(){if(isProxyMode()){const d=await proxyFetch("/api/get-logs");return d&&d.logs?d.logs:[]}return getLogs()},
  async clearLogs(){if(isProxyMode()){const d=await proxyPost("/api/clear-logs");return !!d.ok}return clearLogs()},
  async saveConfig(c){if(isProxyMode()){const d=await proxyPost("/api/save-config",c);return !!d.ok}return saveCfg(c)},
  async saveAccounts(list){if(isProxyMode()){const d=await proxyPost("/api/save-accounts",{accounts:list});return !!d.ok}return saveAccounts(list)},
  async getUserid(token){if(isProxyMode()){const d=await proxyPost("/api/get-userid",{token:token});return{ok:!!d.ok,userId:d.userId||"",userName:d.userName||"",error:d.error||""}}return getUseridByToken(token,getCfg())},
  async getConfig(){if(isProxyMode()){const d=await proxyFetch("/api/config");if(d&&d.config)return{ok:true,config:d.config};return{ok:false,error:(d&&d.error)||"获取配置失败"}}return{ok:true,config:getCfg()}},
  async getAccountsFull(){if(isProxyMode()){const d=await proxyFetch("/api/accounts");return Array.isArray(d&&d.accounts)?d.accounts:[]}return getAccounts()},
  async backup(){
    if(isProxyMode()){const d=await proxyFetch("/api/backup");return d&&d.ok?d:null}
    return{ok:true,app:"极核ZEEHO",type:"zeeho_backup",version:APP_VERSION,time:fmtTime(new Date().toISOString()),accounts:getAccounts(),config:getCfg()}
  },
  async restoreBackup(json){
    if(isProxyMode()){const d=await proxyPost("/api/import",{json:json});return d||{ok:false,error:"后端无响应"}}
    try{
      const b=typeof json==="string"?JSON.parse(json):json;
      if(!b||(b.type!=="zeeho_backup"&&!Array.isArray(b.accounts)))return{ok:false,error:"备份格式不正确"};
      const list=(b.accounts||[]).map(a=>({userName:a.userName||"",userId:a.userId||"",token:cleanToken(a.token),barkKey:cleanBarkKey(a.barkKey||""),userAgent:a.userAgent||""}));
      saveAccounts(list);
      if(b.config&&typeof b.config==="object"){
        const cur=getCfg();
        saveCfg({
          app:{appId:b.config.app?.appId||cur.app.appId,appSecret:b.config.app?.appSecret||cur.app.appSecret},
          h5:{appId:b.config.h5?.appId||cur.h5.appId,appSecret:b.config.h5?.appSecret||cur.h5.appSecret},
          community:{enablePost:b.config.community?.enablePost!==false,enableLike:b.config.community?.enableLike!==false,enableComment:b.config.community?.enableComment!==false,enableShare:b.config.community?.enableShare!==false,enableDelete:b.config.community?.enableDelete!==false},
          vehicleAesKey:String(b.config.vehicleAesKey||"").trim()||cur.vehicleAesKey,
          vehicleControlRisk:String(b.config.vehicleControlRisk||"").trim(),
          autoRefreshSec:normalizeRefreshSec(b.config.autoRefreshSec),
          serverBase:cur.serverBase
        });
      }
      return{ok:true,count:list.length};
    }catch(e){return{ok:false,error:String(e)}}
  },
  /* ---- v2.14.9 新增后端能力（仅代理模式） ---- */
  async integral(userId,page){
    if(isDemo())return DEMO_INTEGRAL;
    if(isProxyMode()){return await proxyFetch("/api/integral?userId="+encodeURIComponent(userId||"")+"&page="+(page||1))}
    return{ok:false,error:"积分功能仅支持代理模式（iOS App / 桌面版 / Loon）"}
  },
  async supplement(action,userId,params){
    if(isDemo())return action==="month"?{ok:true,data:{nowSignDetailVos:demoCal()}}:(DEMO_SUPPLEMENT[action]||{ok:true,data:1});
    if(isProxyMode()){
      let q="/api/supplement?action="+encodeURIComponent(action)+"&userId="+encodeURIComponent(userId||"");
      params=params||{};Object.keys(params).forEach(k=>{q+="&"+encodeURIComponent(k)+"="+encodeURIComponent(params[k])});
      return await proxyFetch(q)
    }
    return{ok:false,error:"补签功能仅支持代理模式（iOS App / 桌面版 / Loon）"}
  },
  async vehicleMonitor(userId,vin){
    if(isDemo())return DEMO_MONITOR;
    if(isProxyMode()){let q="/api/vehicle-monitor?userId="+encodeURIComponent(userId||"");if(vin)q+="&vin="+encodeURIComponent(vin);return await proxyFetch(q)}
    return{ok:false,error:"车辆监控仅支持代理模式"}
  },
  async vehicleControlExt(body){
    if(isDemo())return (body&&body.action==="options")?DEMO_CTRL_OPTS:{ok:true,message:"演示模式：指令未真实下发"};
    if(isProxyMode()){return await proxyPost("/api/vehicle-control-ext",body)}
    return{ok:false,message:"车控扩展仅支持代理模式"}
  },
  async batteryState(userId,vin){
    if(isDemo())return{ok:true,vinNo:"DEMO",charging:false,current:0,soc:70,voltage:80.5,chargeState:"未充电",fullChargeTime:0,fullChargeTimeSecond:0};
    if(isProxyMode())return await proxyFetch("/api/battery-state?userId="+encodeURIComponent(userId||"")+(vin?"&vin="+encodeURIComponent(vin):""));
    return await fetchBatteryStateDirect(rideAccLocal(userId),getCfg(),vin);
  },
  async infoCenter(userId,vin){
    if(isDemo())return DEMO_INFO;
    if(isProxyMode()){let q="/api/info-center?userId="+encodeURIComponent(userId||"");if(vin)q+="&vin="+encodeURIComponent(vin);return await proxyFetch(q)}
    return{ok:false,error:"信息中心仅支持代理模式"}
  },
  /* ---- v2.16.0 隐藏骑行数据 ---- */
  async rideMonth(userId,month,vin){
    if(isDemo())return demoRideMonth(month);
    if(isProxyMode()){let q="/api/ride-month?userId="+encodeURIComponent(userId||"")+"&month="+encodeURIComponent(month||"");if(vin)q+="&vin="+encodeURIComponent(vin);return await proxyFetch(q)}
    return await fetchRideMonthDirect(rideAccLocal(userId),getCfg(),month,vin);
  },
  async rideTrack(userId,vin,page,pageSize,month){
    if(isDemo())return demoRideTrack(page);
    if(isProxyMode()){let q="/api/ride-track?userId="+encodeURIComponent(userId||"")+"&page="+(page||1)+"&pageSize="+(pageSize||20);if(vin)q+="&vin="+encodeURIComponent(vin);if(month)q+="&month="+encodeURIComponent(month);return await proxyFetch(q)}
    return await fetchRideTrackDirect(rideAccLocal(userId),getCfg(),vin,page,pageSize,month);
  },
  async installInfo(){
    if(isProxyMode()){const d=await proxyFetch("/api/app-install-info");return d||null}
    return null
  }
};
/* ================= 面板数据同步（面板模式：设置页从脚本后端读账号与配置） ================= */
function applyRemoteCfg(c){
  if(!c||typeof c!=="object")return;
  const local=getCfg();
  saveCfg({
    app:{appId:c.app?.appId||local.app.appId,appSecret:c.app?.appSecret||local.app.appSecret},
    h5:{appId:c.h5?.appId||local.h5.appId,appSecret:c.h5?.appSecret||local.h5.appSecret},
    community:{enablePost:c.community?.enablePost!==false,enableLike:c.community?.enableLike!==false,enableComment:c.community?.enableComment!==false,enableShare:c.community?.enableShare!==false,enableDelete:c.community?.enableDelete!==false},
    vehicleAesKey:String(c.vehicleAesKey||"").trim()||local.vehicleAesKey,
    vehicleControlRisk:String(c.vehicleControlRisk||"").trim(),
    autoRefreshSec:normalizeRefreshSec(c.autoRefreshSec),
    serverBase:local.serverBase,
    autoSignin:c.autoSignin===true,
    autoSigninTime:(typeof c.autoSigninTime==="string"&&/^\d{1,2}:\d{2}$/.test(c.autoSigninTime)?c.autoSigninTime:"07:00"),
    vehicleMonitor:c.vehicleMonitor===true,
    widgetVehicle:String(c.widgetVehicle||""),
    customBg:String(c.customBg||""),
    pics:(c.pics&&typeof c.pics==="object")?c.pics:(local.pics||{})
  });
}
let panelSyncing=false;
async function ensurePanelData(force){
  if(!isProxyMode()||location.search.indexOf("demo")>=0)return;
  if(panelSyncing)return;
  if(!force&&STATE.panelLoaded)return;
  panelSyncing=true;
  try{
    const [c,a]=await Promise.all([Backend.getConfig(),Backend.getAccountsFull()]);
    if(a&&a.length){STATE.panelAccounts=a}
    if(c&&c.ok&&c.config)applyRemoteCfg(c.config);
    STATE.panelLoaded=true;
  }catch(e){}
  panelSyncing=false;
}
/* ================= 图标 ================= */
const I={
check:'<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.6" stroke-linecap="round" stroke-linejoin="round"><path d="M20 6 9 17l-5-5"/></svg>',
x:'<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.6" stroke-linecap="round"><path d="M18 6 6 18M6 6l12 12"/></svg>',
zap:'<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round"><path d="M13 2 3 14h7l-1 8 10-12h-7l1-8z"/></svg>',
lock:'<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round"><rect x="4" y="11" width="16" height="10" rx="3"/><path d="M8 11V7a4 4 0 0 1 8 0v4"/></svg>',
unlock:'<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round"><rect x="4" y="11" width="16" height="10" rx="3"/><path d="M8 11V7a4 4 0 0 1 7.5-1.7"/></svg>',
bell:'<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round"><path d="M18 8a6 6 0 1 0-12 0c0 7-3 9-3 9h18s-3-2-3-9"/><path d="M13.7 21a2 2 0 0 1-3.4 0"/></svg>',
vol:'<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round"><path d="M11 5 6 9H2v6h4l5 4V5z"/><path d="M15.5 8.5a5 5 0 0 1 0 7M18.5 5.5a9 9 0 0 1 0 13"/></svg>',
seat:'<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round"><path d="M5 4h14v7a4 4 0 0 1-4 4H9a4 4 0 0 1-4-4V4z"/><path d="M9 15v5h6v-5"/></svg>',
pin:'<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round"><path d="M20 10c0 6-8 12-8 12s-8-6-8-12a8 8 0 0 1 16 0z"/><circle cx="12" cy="10" r="3"/></svg>',
tire:'<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"><circle cx="12" cy="12" r="9"/><circle cx="12" cy="12" r="3.5"/><path d="M12 3v5.5M12 15.5V21M3 12h5.5M15.5 12H21"/></svg>',
bolt:'<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round"><path d="M13 2 3 14h7l-1 8 10-12h-7l1-8z"/></svg>',
thermo:'<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round"><path d="M14 14.76V5a2 2 0 1 0-4 0v9.76a4 4 0 1 0 4 0z"/></svg>',
cal:'<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round"><rect x="3" y="4" width="18" height="18" rx="3"/><path d="M16 2v4M8 2v4M3 10h18"/></svg>',
car:'<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round"><path d="M5 13 6.5 7.5A2 2 0 0 1 8.4 6h7.2a2 2 0 0 1 1.9 1.5L19 13"/><path d="M4 13h16a1 1 0 0 1 1 1v3a1 1 0 0 1-1 1h-1a2 2 0 1 1-4 0H9a2 2 0 1 1-4 0H4a1 1 0 0 1-1-1v-3a1 1 0 0 1 1-1z"/></svg>',
scooter:'<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="5" cy="18" r="2.4"/><circle cx="19" cy="17" r="2.4"/><path d="M5 18h10l4-1-2.5-4H9M7 9h4M12 13V7m0 0 2 2"/></svg>',
plug:'<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round"><path d="M9 2v6M15 2v6M7 8h10v4a5 5 0 0 1-10 0V8zM12 17v5"/></svg>',
clock:'<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="9"/><path d="M12 7v5l3 3"/></svg>',
wifi:'<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round"><path d="M5 12.5a10 10 0 0 1 14 0M8.5 16a5 5 0 0 1 7 0"/><circle cx="12" cy="19" r="1" fill="currentColor"/></svg>',
alert:'<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round"><path d="M12 9v4M12 17h.01"/><path d="M10.3 3.9 1.8 18a2 2 0 0 0 1.7 3h17a2 2 0 0 0 1.7-3L13.7 3.9a2 2 0 0 0-3.4 0z"/></svg>',
warn:'<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round"><path d="M12 3 2 21h20L12 3z"/><path d="M12 10v5M12 18h.01"/></svg>',
kv:'<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round"><rect x="3" y="5" width="18" height="14" rx="3"/><path d="M7 9h3M14 15h3M10 9h.01M17 15h.01"/></svg>',
key:'<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round"><circle cx="8" cy="15" r="4.5"/><path d="M11.2 11.8 20 3M16 7l3 3M13 10l2 2"/></svg>',
users:'<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round"><circle cx="9" cy="8" r="4"/><path d="M2 21a7 7 0 0 1 14 0M16 4.6a4 4 0 0 1 0 6.8M19 21a6.5 6.5 0 0 0-3-5.5"/></svg>',
map:'<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round"><path d="M9 3 3.5 5v16L9 19l6 2 5.5-2V3L15 5 9 3z"/><path d="M9 3v16M15 5v16"/></svg>'
};

/* ================= 基础 UI ================= */
let toastTimer=null;
function toast(msg,type){const el=document.getElementById("toast");el.className=type||"info";el.innerHTML=(type==="err"?I.x:type==="ok"?I.check:I.wifi)+'<span>'+esc(msg)+'</span>';requestAnimationFrame(()=>el.classList.add("show"));clearTimeout(toastTimer);toastTimer=setTimeout(()=>el.classList.remove("show"),2600)}
/* v2.14.10 修复：旧版把回调函数源码直接拼进 onclick 属性，async 回调内的双引号会截断 HTML 属性，
   导致补签/兑换补签卡/防盗布控等「确定」按钮点击无反应。改为暂存回调、按钮调用全局 confirmYes() */
let __confirmAct=null;
function confirmDialog(title,desc,onYes,yesTxt){__confirmAct=onYes;const layer=document.getElementById("confirmLayer");layer.innerHTML='<div class="confirm"><div class="ct">'+esc(title)+'</div><div class="cd">'+desc+'</div><div class="cb"><button class="no" onclick="closeConfirm()">取消</button><button class="yes" onclick="confirmYes()">'+esc(yesTxt||"确定")+'</button></div></div>';layer.classList.remove("hidden")}
function confirmYes(){closeConfirm();const a=__confirmAct;__confirmAct=null;if(a==null)return;try{if(typeof a==="function"){a()}else if(typeof a==="string"){const r=new Function("return ("+a+")")();if(typeof r==="function")r()}}catch(e){}}
function closeConfirm(){document.getElementById("confirmLayer").classList.add("hidden")}
function openSheet(title,icon,html){document.getElementById("sheetTitle").innerHTML=icon+'<span>'+esc(title)+'</span>';document.getElementById("sheetBody").innerHTML=html;document.getElementById("sheetBackdrop").classList.add("show");document.getElementById("sheet").classList.add("show");document.body.style.overflow="hidden"}
function closeSheet(){document.getElementById("sheetBackdrop").classList.remove("show");document.getElementById("sheet").classList.remove("show");document.body.style.overflow=""}
function fmtTime(iso){try{const d=new Date(iso);const p=n=>String(n).padStart(2,"0");return d.getFullYear()+"-"+p(d.getMonth()+1)+"-"+p(d.getDate())+" "+p(d.getHours())+":"+p(d.getMinutes())+":"+p(d.getSeconds())}catch(e){return""}}

/* ================= 页面切换 ================= */
function switchTab(tab){
  document.querySelectorAll(".tab").forEach(t=>t.classList.toggle("on",t.dataset.tab===tab));
  const pages={home:"pageHome",points:"pagePoints",vehicle:"pageVehicle",ride:"pageRide",logs:"pageLogs",cfg:"pageCfg"};
  Object.keys(pages).forEach(k=>{const el=document.getElementById(pages[k]);if(el)el.classList.toggle("hidden",k!==tab)});
  // 立即签到悬浮按钮仅首页显示
  const fab=document.getElementById("signinFab");if(fab)fab.style.display=(tab==="home"?"flex":"none");
  if(tab==="points")renderPoints();
  if(tab==="vehicle"){renderVehiclePage()}
  if(tab==="ride"){renderRidePage()}
  if(tab==="logs")renderLogs();
  if(tab==="cfg")renderCfg();
}

/* ================= 自动刷新 ================= */
let refreshTimer=null,refreshLeft=60;
function startAutoRefresh(sec){stopAutoRefresh();refreshLeft=sec||getCfg().autoRefreshSec;updateCountChip();refreshTimer=setInterval(()=>{refreshLeft--;if(refreshLeft<=0){refreshLeft=0;updateCountChip();refreshAll(true)}else updateCountChip()},1000)}
function stopAutoRefresh(){if(refreshTimer){clearInterval(refreshTimer);refreshTimer=null}}
function updateCountChip(){const chip=document.getElementById("countChip");const txt=document.getElementById("countTxt");const arc=document.getElementById("countArc");const sec=getCfg().autoRefreshSec||60;if(!chip)return;if(refreshTimer){chip.classList.add("on");txt.textContent=refreshLeft+"s";const C=2*Math.PI*5.6;arc.setAttribute("stroke-dashoffset",String(C*(1-refreshLeft/sec)))}else{chip.classList.remove("on");txt.textContent="手动"}}
function toggleAutoRefresh(){if(refreshTimer)stopAutoRefresh();else startAutoRefresh();updateCountChip()}

/* ================= 下拉刷新 ================= */
(function(){const wrap=document.getElementById("ptrWrap"),ind=document.getElementById("ptrInd"),txt=document.getElementById("ptrTxt"),spin=document.getElementById("ptrSpin");let startY=0,pulling=false,distance=0;const TH=64;
wrap.addEventListener("touchstart",e=>{if(window.scrollY<=0&&document.getElementById("pageHome")&&!document.getElementById("pageHome").classList.contains("hidden")){startY=e.touches[0].clientY;pulling=true;distance=0}},{passive:true});
wrap.addEventListener("touchmove",e=>{if(!pulling)return;const dy=e.touches[0].clientY-startY;if(dy>0&&window.scrollY<=0){distance=Math.min(dy*0.5,90);ind.style.height=distance+"px";ind.classList.add("pulling");spin.style.transform="rotate("+(distance*3.6)+"deg)";txt.textContent=distance>=TH?"松开刷新":"下拉刷新";if(distance>=TH&&!e.cancelable)return;if(distance>=TH&&e.cancelable)e.preventDefault()}},{passive:false});
wrap.addEventListener("touchend",()=>{if(!pulling)return;pulling=false;if(distance>=TH){txt.textContent="刷新中…";ind.style.height="46px";spin.classList.add("spinner");refreshAll(true).finally(()=>{ind.style.height="0";ind.classList.remove("pulling")})}else{ind.style.height="0"}distance=0},{passive:true});
})();

/* ================= 首页渲染 ================= */
let STATE={data:[],timestamp:"",tsText:"",refreshSec:60,proxy:false,panelAccounts:null,panelLoaded:false};
// 首页卡片入场动画只在第一次渲染时播放，之后静默刷新直接替换内容，避免屏闪
let HOME_ANIM=true;
function skeletonHome(){return '<div class="hero" style="height:132px"></div>'+
'<div class="sk-card"><div class="sk-line w40"></div><div class="sk-row">'+Array(4).fill('<div class="sk-cell"></div>').join("")+'</div><div class="sk-bar w80"></div></div>'+
'<div class="sk-card"><div class="sk-line w60"></div><div class="sk-row">'+Array(4).fill('<div class="sk-cell"></div>').join("")+'</div><div class="sk-bar w80"></div></div>'}
function scooterFallback(){return '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.4" stroke-linecap="round" stroke-linejoin="round"><circle cx="5" cy="18" r="2.4"/><circle cx="19" cy="17" r="2.4"/><path d="M5 18h10l4-1-2.5-4H9M7 9h4M12 13V7m0 0 2 2"/></svg>'}

function renderHome(){
  const el=document.getElementById("pageHome");const data=STATE.data;
  // 不再在每次渲染前插入骨架屏：静默自动刷新时会先清空再填充，造成整页闪烁
  if(data.length===0){
    el.innerHTML='<div class="empty"><div class="e-icon">'+I.car+'</div><h3>还没有极核账号</h3><p>去「设置」页添加账号：粘贴抓包得到的 Authorization Token（Bearer 前缀会自动去掉），再点「获取ID」即可自动填充用户ID。</p><button class="btn primary" onclick="switchTab(\'cfg\')">去添加账号</button></div>';
    return;
  }
  // 没有绑定车辆的账号不在首页显示卡片
  const cards=data.filter(a=>a.vehicle&&a.vehicle.hasVehicle).map((a,idx)=>renderAccountCard(a,idx)).join("");
  el.innerHTML=cards
  +'<div class="foot">极核 ZEEHO 面板 '+APP_VERSION+' · 数据更新 '+esc(STATE.tsText||"-")+'<br><a class="link" href="https://github.com/cluck798/ZEEHO" target="_blank" rel="noopener">作者 lucky · GitHub</a> · <a class="link" href="https://afdian.com/a/lucky798" target="_blank" rel="noopener">爱发电</a> · 仅供学习研究</div>';
  HOME_ANIM=false;
}

function powerText(p,l){p=String(p||"").toLowerCase().trim();l=String(l||"").toLowerCase().trim();const onVals=["1","on","true","开机","open","激活","acc_on","acc on","power_on","power on","已开机","已上电"];const offVals=["0","off","false","关机","closed","待机","acc_off","acc off","power_off","power off","已关机","已下电"];if(p){if(onVals.includes(p))return{text:"已开机",cls:"on"};if(offVals.includes(p))return{text:"已关机",cls:"off"}}if(l){if(["0","未锁","开锁","unlocked","false","open","已开锁","未锁车"].includes(l))return{text:"已开机",cls:"on"};if(["1","已锁","锁车","locked","true","closed","已锁车"].includes(l))return{text:"已关机",cls:"off"}}return{text:"状态未知",cls:"off"}}
function onlineText(o){const s=String(o||"").toLowerCase().trim();if(!s)return"";if(["1","on","online","true","在线","已在线","connected","normal"].includes(s))return"在线";if(["0","off","offline","false","离线","未在线","已离线","disconnect","disconnected","sleep","休眠"].includes(s))return"离线";return s}
function renderAccountCard(a,idx){
  const v=a.vehicle||{};
  const onl=onlineText(v.online||v.rideState);
  const isCharging=!!(v.chargeState&&v.chargeState!=="未充电");
  const soc=v.batteryPercent||0;
  const socCol=soc<=20?"#F9706A":soc<=50?"#F7B955":"#3DDC97";
  const range=v.residualRangeKm||0;
  const volt=v.voltage?Math.round(v.voltage)+"V":"";
  const fb=scooterFallback();
  // onerror 里不能再嵌套引号（旧写法会把 SVG 引号截断，页面残留 '"> 乱码符号）
  const img=v.vehicleImageUrl?'<img src="'+esc(v.vehicleImageUrl)+'" alt="" onerror="this.remove()">'+fb:fb;
  const vehSw=v.hasVehicle?renderVehicleSwitch(v,idx):"";
  const bound=x=>!!x&&x!=="未绑定"&&x!=="-";
  const rows=[];
  rows.push('里程：'+(v.totalMileage?v.totalMileage.toFixed(1):(v.lastRideMileage?v.lastRideMileage.toFixed(1):"0"))+'km');
  rows.push('上次：'+(v.yesterdayDistance?v.yesterdayDistance.toFixed(1):"--")+'km');
  rows.push('当日：'+(v.todayDistance?v.todayDistance.toFixed(1):"0")+'km'+(fmtMin(v.todayDuration)?" "+fmtMin(v.todayDuration):"")+(v.todayMaxSpeed?" "+v.todayMaxSpeed+"km/h":""));
  if(bound(v.frontPressure)||bound(v.rearPressure))rows.push('胎压：'+(bound(v.frontPressure)?"前 "+esc(v.frontPressure):"")+((bound(v.frontPressure)&&bound(v.rearPressure))?" / ":"")+(bound(v.rearPressure)?"后 "+esc(v.rearPressure):""));
  if(bound(v.frontTemp)||bound(v.rearTemp))rows.push('胎温：'+(bound(v.frontTemp)?"前 "+esc(v.frontTemp):"")+((bound(v.frontTemp)&&bound(v.rearTemp))?" / ":"")+(bound(v.rearTemp)?"后 "+esc(v.rearTemp):""));
  if(isCharging&&v.current)rows.push('电流：'+Number(v.current).toFixed(1)+'A');
  // v2.16.6 卡片充电剩余（充电中且该车已设容量才显示）
  if(isCharging&&Number(v.current)>0.5&&soc>0&&soc<100){const bc=rideBattCfg(v.currentVin||"");if(Number(bc.ah)>0)rows.push('⏱ 充电剩余：约 '+fmtRemainHm(Number(bc.ah)*(100-soc)/100/Number(v.current)*60));}
  return '<div class="acc-card home-card'+(isCharging?' charging':'')+(HOME_ANIM?' anim-in':'')+'" style="animation-delay:'+(idx*60)+'ms">'+
    '<div class="hc-upd">更新：'+esc(STATE.tsText||"-")+'</div>'+
    '<div class="hc-top"><div class="hc-name">'+esc(v.hasVehicle?(v.vehicleName||a.userName):a.userName)+'</div>'+
    (v.hasVehicle?(onl==="在线"?'<span class="hc-badge on">在线</span>':(onl?'<span class="hc-badge">'+esc(onl)+'</span>':"")):"")+
    (a.tokenValid===false?'<span class="hc-badge err">Token失效</span>':"")+
    (isCharging?'<span class="hc-badge chg">充电中</span>':"")+'</div>'+
    (v.hasVehicle&&v.vehicleModel?'<div class="hc-model">车型：'+esc(v.vehicleModel)+'</div>':"")+
    (v.hasVehicle?'<div class="hc-mid"><div class="hc-left"><div class="hc-big num">'+Math.round(soc)+'%<span class="hc-km num">'+(range||0)+'km</span>'+(volt?'<span class="hc-v num">'+volt+'</span>':"")+'</div>'+
    '<div class="hc-bar"><div class="hc-fill" style="width:'+Math.max(0,Math.min(100,soc))+'%;background:'+socCol+'"></div></div>'+
    '<div class="hc-rows">'+rows.map(r=>'<div class="hc-row">'+r+'</div>').join("")+'</div></div>'+
    '<div class="hc-img">'+img+'</div></div>':
    '<div class="no-vehicle" style="margin:12px 0">'+I.car+' 该账号未绑定车辆</div>')+
    '<div class="hc-bottom"><div class="hc-score"><span>总积分 <b class="num">'+Number(a.score||0).toLocaleString()+'</b></span><span class="plus num">今+'+Number(a.todayScore||0)+'</span><span class="streak num">连签'+Number(a.continueDays||0)+'天</span>'+(a.signedToday?'<span class="signed num">✓ 已签到</span>':"")+'</div></div>'+
    vehSw+'</div>';
}
function fmtMin(min){min=Number(min)||0;if(min<=0)return"";const h=Math.floor(min/60),m=Math.round(min%60);return h>0?h+"h"+(m?m+"min":""):m+"min"}
function fmtRemainHm(min){min=Math.max(1,Math.round(Number(min)||0));const h=Math.floor(min/60),m=min%60;return (h>0?h+" 时 ":"")+m+" 分"}

/* ============ 多车切换 ============ */
function renderVehicleSwitch(v,idx){
  if(!v.vehicles||v.vehicles.length<2)return "";
  const cur=v.currentVin||"";
  const items=v.vehicles.map(x=>'<button class="veh-chip'+(x.vinNo===cur?" on":"")+'" onclick="switchVehicle('+idx+',\''+esc(x.vinNo)+'\')">'+esc(x.vehicleType||x.name)+'</button>').join("");
  return '<div class="veh-switch"><span class="veh-sw-label">车辆</span>'+items+'</div>';
}
async function switchVehicle(idx,vin){
  const src=STATE.data[idx];if(!src||!vin)return;
  try{
    let d;
    if(isProxyMode()){
      const r=await proxyFetch("/api/vehicle?userId="+encodeURIComponent(src.userId||"")+"&vin="+encodeURIComponent(vin));
      d=(r&&r.ok)?r.result:null;
    }else{
      const cfg=getCfg();const acc=getAccounts()[idx];
      if(!acc)return;
      d=await fetchAccountData(acc,cfg,vin);
    }
    if(d&&d.vehicle&&d.vehicle.hasVehicle){
      STATE.data[idx]=Object.assign({},STATE.data[idx],d);
      renderHome();
    }
  }catch(e){}
}

/* ============ 主题（v2.14.14 起仅保留深色单主题） ============ */
function applyTheme(){
  document.documentElement.setAttribute("data-theme","dark");
}

/* ================= 立即签到悬浮按钮 ================= */
function mountSigninFab(){
  if(document.getElementById("signinFab"))return;
  const b=document.createElement("button");
  b.id="signinFab";b.className="signin-fab";b.innerHTML=(I.check||"")+"<span>立即签到</span>";
  b.onclick=runSigninNow;
  const cur=document.querySelector(".tab.on");
  b.style.display=(!cur||cur.dataset.tab==="home")?"flex":"none";
  document.body.appendChild(b);
}
async function runSigninNow(){
  if(isDemo()){demoSignin();return}
  const btn=document.getElementById("signinFab");
  if(!btn||btn.classList.contains("busy"))return;
  btn.classList.add("busy");btn.querySelector("span").textContent="签到中…";
  toast("正在为全部账号执行签到…","info");
  const d=await Backend.runSignin(null,true);
  btn.classList.remove("busy");btn.querySelector("span").textContent="立即签到";
  if(d&&d.ok&&d.results){
    const okN=d.results.filter(r=>r.success).length;
    toast("签到完成："+okN+"/"+d.results.length+" 成功",okN===d.results.length?"ok":"err");
    openSheet("签到结果",I.check,signinResultHtml(d.results));
    refreshAll(true);
  }else{
    toast((d&&d.error)||"签到执行失败","err");
  }
}
function signinResultHtml(results){
  return (results||[]).map(r=>'<div class="sig-card '+(r.success?"ok":"fail")+'"><div class="h"><span>'+esc(r.userName||"未知")+'</span><span class="r">'+(r.success?("+"+(r.totalGain||0)+" 分"):"失败")+'</span></div><div class="steps">'+(r.steps||[]).map(s=>'<div><i>·</i>'+esc(s)+'</div>').join("")+(r.error?'<div class="err">'+esc(r.error)+'</div>':"")+'</div></div>').join("");
}
/* 演示模式：模拟一次签到并弹出结果，避免演示时结果为空 */
function demoSignin(){
  const btn=document.getElementById("signinFab");
  if(btn){btn.classList.add("busy");btn.querySelector("span").textContent="签到中…"}
  toast("演示模式：模拟执行签到…","info");
  setTimeout(()=>{
    if(btn){btn.classList.remove("busy");btn.querySelector("span").textContent="立即签到"}
    const res=[
      {userName:"阿泽",success:true,totalGain:9,steps:["签到成功 +6","盲盒获得 +3 (积分)","发帖成功 +1","点赞成功 +1","分享成功 +1","评论完成"]},
      {userName:"小满",success:false,error:"Token已过期，请重新登录",steps:["签到失败: 请先登录"]}
    ];
    toast("签到完成：1/2 成功（演示数据）","ok");
    openSheet("签到结果",I.check,signinResultHtml(res));
  },700);
}

/* ================= 车辆详情 & 地图 ================= */
function openMap(idx){const v=STATE.data[idx]&&STATE.data[idx].vehicle;if(!v)return;if(!hasValidCoord(v.latitude,v.longitude)){toast("暂无有效 GPS 坐标","err");return}const url="https://maps.apple.com/?q="+Number(v.latitude)+","+Number(v.longitude)+"&z=17";window.open(url,"_blank")}
function showVehicleDetail(idx){
  const a=STATE.data[idx];if(!a)return;const v=a.vehicle||{};
  const pw=powerText(v.powerStatus,v.lockState);
  const rows=[];
  if(v.vinNo)rows.push(['车架号','<span class="v mono" id="vinDtl">'+esc(maskVin(v.vinNo))+'</span> <button class="vin-show" onclick="toggleDtlVin()">显示</button>']);
  rows.push(['充电状态',esc(v.chargeState||"未充电")]);
  rows.push(['电源状态','<span style="color:'+(pw.cls==="on"?"var(--ok)":"var(--txt2)")+'">'+pw.text+'</span>']);
  if(v.rideState||v.online)rows.push(['车辆状态',esc(v.rideState||v.online)]);
  rows.push(['电量 SOC','<b style="color:'+(v.batteryPercent<=20?"var(--err)":v.batteryPercent<=50?"var(--warn)":"var(--brand)")+'">'+(v.batteryPercent||0)+'%</b>']);
  if(v.voltage)rows.push(['电压',v.voltage.toFixed(1)+"V"]);
  if(v.current)rows.push(['电流',v.current.toFixed(1)+"A"]);
  if(v.batteryTemp)rows.push(['电池温度',v.batteryTemp.toFixed(0)+"°C"]);
  rows.push(['剩余续航',(v.residualRangeKm||0)+" km"+(v.rangeEstimated?"（估算）":"")]);
  rows.push(['今日骑行',(v.todayDistance?v.todayDistance.toFixed(1):0)+" km / "+(v.todayDuration||0)+" min"]);
  if((v.frontPressure&&v.frontPressure!=="未绑定")||(v.rearPressure&&v.rearPressure!=="未绑定"))rows.push(['胎压','前 '+esc(v.frontPressure||"-")+' / 后 '+esc(v.rearPressure||"-")]);
  if(v.address)rows.push(['车辆位置','<span style="font-size:12px;font-weight:600">'+esc(v.address)+'</span>']);
  const dOk=hasValidCoord(v.latitude,v.longitude);
  if(dOk)rows.push(['GPS 坐标','<span class="v mono">'+Number(v.latitude).toFixed(6)+", "+Number(v.longitude).toFixed(6)+'</span>']);
  if(v.locationTime)rows.push(['最后定位','<span style="color:var(--txt3);font-weight:600">'+esc(v.locationTime)+'</span>']);
  if(v.serviceEndDate)rows.push(['服务到期',esc(v.serviceEndDate)]);
  STATE.vinDtlRaw=v.vinNo||"";
  const html=rows.map(r=>'<div class="sr-item"><span class="k">'+r[0]+'</span><span class="v">'+r[1]+'</span></div>').join("")+
  '<div class="btn-row" style="margin-top:16px"><button class="btn '+(dOk?"primary":"")+'" '+(dOk?'onclick="closeSheet();openMap('+idx+')"':'disabled title="暂无有效GPS坐标"')+'>'+I.map+' 地图查看</button></div>';
  openSheet("车辆详情 · "+esc(v.vehicleName||"极核车辆"),I.car,html);
}
function toggleDtlVin(){const el=document.getElementById("vinDtl");if(!el)return;if(el.textContent.indexOf("*")>=0){el.textContent=STATE.vinDtlRaw;document.querySelector('#sheetBody .vin-show').textContent="隐藏"}else{document.querySelector('#sheetBody .vin-show').textContent="显示";el.textContent=maskVin(el.textContent)}}
/* ================= 签到执行（面板已移除手动签到入口，定时签到由脚本 cron 负责） ================= */

/* ================= 车辆控制 ================= */
// v2.14.21 车控风险确认改为首次使用弹窗：同意后可用，不同意则不启用
let __riskPending=null;
function riskOk(){const r=(getCfg().vehicleControlRisk||"").trim();return r==="我同意风险并使用"||r==="我自愿承担相关风险"}
function ctrlAct(idx,action,btn){if(location.search.indexOf("demo")>=0){toast("演示模式：仅预览界面","info");return}const a=ptAccounts()[idx];if(!a||!a.userId){toast("该账号缺少用户ID","err");return}if(!riskOk()){showRiskDialog(idx,action);return}ctrlConfirm(idx,action)}
function ctrlConfirm(idx,action){const a=ptAccounts()[idx];const names={find:"短按寻车（车辆闪灯）",loudFind:"鸣笛闪灯（高声寻车）",cushion:"打开坐垫（坐垫会弹起）",unlock:"云端开锁",lock:"云端关锁"};const name=names[action]||action;confirmDialog("确认执行 "+name,"该指令会通过 4G 网络真实控制你的车辆："+esc(a.userName)+"。",'doCtrl('+idx+",'"+action+"')")}
function showRiskDialog(idx,action){
  __riskPending={idx:idx,action:action};
  const layer=document.getElementById("confirmLayer");
  layer.innerHTML='<div class="confirm"><div class="ct">车控功能风险告知</div><div class="cd">寻车 / 鸣笛 / 坐垫 / 开锁 / 关锁等指令经 4G 云端下发，会<b>真实操作你的车辆</b>。受网络延迟、信号等影响，指令可能延迟、失败，极端情况下车辆可能意外动作（如误开锁）。使用车控功能即视为你已充分知悉并自愿承担上述风险，由此产生的一切后果由你自行承担。</div><div class="cb"><button class="no" onclick="riskDecline()">我不同意风险不使用</button><button class="yes" onclick="riskAgree()">我同意风险并使用</button></div></div>';
  layer.classList.remove("hidden");
}
function riskAgree(){closeConfirm();const c=getCfg();c.vehicleControlRisk="我同意风险并使用";Backend.saveConfig(c).then(function(ok){if(ok){if(isProxyMode())applyRemoteCfg(c);else saveCfg(c);toast("已同意风险，车控功能已启用","ok");if(__riskPending){const p=__riskPending;__riskPending=null;ctrlConfirm(p.idx,p.action)}}else{toast("保存失败","err");__riskPending=null}})}
function riskDecline(){closeConfirm();__riskPending=null;toast("已选择不同意风险，车控功能不启用","info")}
async function doCtrl(idx,action){const a=ptAccounts()[idx];if(!a)return;const btn=document.querySelector('.ctrl-btn[data-act="'+action+'"]');const old=btn?btn.innerHTML:"";if(btn){btn.disabled=true;btn.classList.add("busy");btn.innerHTML=I.clock}toast("指令下发中…","info");const d=await Backend.vehicleCtrl(a.userId,action);if(btn){btn.disabled=false;btn.classList.remove("busy");btn.innerHTML=old}if(d&&d.ok){toast(d.message||"指令已下发","ok")}else{toast((d&&d.message)||"指令失败","err")}}

/* ================= 日志页 ================= */
let logFilter="all";
async function renderLogs(){
  const el=document.getElementById("pageLogs");
  el.innerHTML='<div class="section-title">'+I.kv+'运行日志</div>'+
  '<div class="log-panel"><div class="log-head"><h3>'+I.kv+'<span>最近 50 条</span></h3><div class="log-filters">'+
  ['<button class="chip '+(logFilter==="all"?"on":"")+'" onclick="setLogFilter(\'all\')">全部</button>','<button class="chip '+(logFilter==="signin"?"on":"")+'" onclick="setLogFilter(\'signin\')">签到</button>','<button class="chip '+(logFilter==="vehicle"?"on":"")+'" onclick="setLogFilter(\'vehicle\')">控车</button>'].join("")+
  '</div></div><div class="log-list" id="logList"><div style="padding:40px;text-align:center;color:var(--txt3)">加载中…</div></div></div>'+
  '<div class="btn-row" style="margin-top:14px"><button class="btn danger" style="flex:1" onclick="clearLogsUI()">清空日志</button></div>';
  const logs=location.search.indexOf("demo")>=0?DEMO_LOGS:await Backend.getLogs();renderLogList(logs);
}
function setLogFilter(f){logFilter=f;renderLogs()}
function renderLogList(logs){const el=document.getElementById("logList");if(!el)return;const list=(logs||[]).filter(l=>{const t=l.type||"signin";if(logFilter==="all")return true;return t===logFilter});if(!list.length){el.innerHTML='<div class="log-empty">'+I.warn+'<br>该分类下暂无日志</div>';return}el.innerHTML=list.map((log,i)=>{const t=log.type||"signin";const tag=t==="vehicle"?'<span class="pill amber">控车</span>':'<span class="pill cyan">签到</span>';let res;if(t==="vehicle"){res='<span class="log-res '+(log.success?"":"err")+'">'+(log.actionText||"车辆控制")+' '+(log.success?"成功":"失败："+esc(log.message||log.error||"未知"))+'</span>'}else{res='<span class="log-res '+(log.success?"":"err")+'">'+(log.success?"成功 +"+log.totalGain:"失败: "+(log.error||"未知"))+'</span>'}const steps=log.steps?(log.steps.map(s=>'<div><i>·</i>'+esc(s)+'</div>').join("")):"";return '<div class="log-item" style="animation-delay:'+(i*25)+'ms"><div class="log-time">'+esc(log.time||"")+'</div><div class="log-main">'+tag+'<span class="log-user">'+esc(log.userName||"")+'</span>'+res+'</div>'+(steps?'<div class="log-steps">'+steps+'</div>':"")+'</div>'}).join("")}
async function clearLogsUI(){confirmDialog("清空日志","将删除全部运行日志，此操作不可恢复。","clearLogsNow")}
async function clearLogsNow(){const ok=await Backend.clearLogs();if(ok){toast("日志已清空","ok");renderLogs()}else toast("清空失败","err")}

/* ================= 设置页 ================= */
let cfgAccounts=[];
/* ================= v2.15.6 软件版本检测 ================= */
async function checkVersion(manual){
  const btn=document.getElementById("verCheckBtn");
  if(btn){btn.disabled=true;btn.textContent="检测中…"}
  let d=null;
  if(isDemo()){d={ok:true,demo:true,current:APP_VERSION.replace(/^v/,""),hasUpdate:false,latest:{script:APP_VERSION.replace(/^v/,"")}}}
  else{d=await proxyFetch("/api/version-check"+(manual?"?fresh=1":""));}
  STATE.ver=d||null;
  if(btn){btn.disabled=false;btn.textContent="检查更新"}
  const ex=document.getElementById("verExtra");if(ex)ex.innerHTML=verExtraHtml();
  if(STATE.ver&&STATE.ver.ok&&STATE.ver.hasUpdate&&!STATE.ver.demo){
    toast("发现新版本 v"+STATE.ver.latest.script+"（当前 v"+STATE.ver.current+"），可到「设置」查看更新方式");
  }else if(manual){
    toast(STATE.ver&&STATE.ver.ok?"已是最新版本 v"+STATE.ver.current:((STATE.ver&&STATE.ver.error)||"检测失败"),STATE.ver&&STATE.ver.ok?"ok":"err");
  }
}
function verExtraHtml(){
  const v=STATE.ver;
  if(!v)return '点「检查更新」获取最新版本与各端推荐版本';
  if(!v.ok)return '检测失败：'+esc(v.error||"未知错误");
  const L=v.latest||{};
  if(!v.hasUpdate)return '已是最新版本 · 脚本 v'+esc(v.current)+(v.cached?'（本地缓存）':'');
  return '<span style="color:var(--warn);font-weight:600">发现新版本：脚本 v'+esc(L.script||"")+'（当前 v'+esc(v.current)+'）</span>'+
  '<br>推荐版本：iOS App '+esc(L.ios||"-")+' · Windows '+esc(L.pc||"-")+' · Android '+esc(L.android||"-")+
  (L.note?'<br>更新内容：'+esc(L.note):'')+
  '<br><b style="color:var(--txt2)">更新方式</b>：Loon / Shadowrocket / Surge 更新模块订阅即可拉取最新脚本；iOS App（TrollStore）与 Windows / Android 端请重新下载对应安装包。';
}
function renderCfg(){
  if(isProxyMode()&&location.search.indexOf("demo")<0&&!STATE.panelLoaded){
    const el0=document.getElementById("pageCfg");
    if(el0)el0.innerHTML='<div class="cfg-panel"><div class="cfg-head"><h3><span class="bar green"></span>账号管理</h3></div><div class="cfg-body" style="text-align:center;padding:26px;color:var(--txt3);font-size:13px">正在从脚本后端同步账号与配置…</div></div>';
    ensurePanelData().then(()=>renderCfg());
    return;
  }
  const cfg=getCfg();cfgAccounts=(isProxyMode()&&STATE.panelAccounts?STATE.panelAccounts:getAccounts()).map(a=>({userName:a.userName||"",userId:a.userId||"",token:cleanToken(a.token||""),barkKey:a.barkKey||""}));
  const el=document.getElementById("pageCfg");
  const accRows=cfgAccounts.map((a,idx)=>'<div class="acc-edit" data-i="'+idx+'"><div class="acc-edit-head"><span class="acc-edit-title"><span class="n">'+String(idx+1)+'</span>账号 '+String(idx+1)+'</span><span class="acts"><button class="btn sm" id="uidBtn_'+idx+'" onclick="fetchUserIdUI('+idx+')">获取ID</button><button class="btn sm danger" onclick="deleteAccountUI('+idx+')">删除</button></span></div>'+
  '<div class="form-grid"><div class="f-item"><label>昵称</label><input type="text" id="acc_name_'+idx+'" value="'+esc(a.userName)+'" placeholder="如 lucky798"></div><div class="f-item"><label>用户ID</label><input type="text" id="acc_uid_'+idx+'" value="'+esc(a.userId)+'" placeholder="留空可点「获取ID」" style="font-family:ui-monospace,Menlo,monospace;font-size:13px"></div></div>'+
  '<div class="f-item" style="margin-top:10px"><label>Authorization Token（粘贴即可，自动去掉 Bearer 前缀）</label><input type="text" id="acc_token_'+idx+'" value="'+esc(a.token)+'" placeholder="a74779c7-…" style="font-family:ui-monospace,Menlo,monospace;font-size:13px"></div>'+
  '<div class="f-item" style="margin-top:10px"><label>Bark 通知 Key（选填，签到成功推送）</label><input type="text" id="acc_bark_'+idx+'" value="'+esc(a.barkKey)+'" placeholder="Bark Key 或自建 https://域名/Key"></div></div>').join("");
  const comm=cfg.community;
  const sw=(id,label,sub,checked)=>'<label class="switch"><input type="checkbox" id="'+id+'" '+(checked?"checked":"")+'><span class="sw"></span><span class="lbl">'+label+'</span><span class="sc">'+sub+'</span></label>';
  el.innerHTML=
  '<div class="section-title">'+I.key+'设置</div>'+
  '<div class="cfg-panel"><div class="cfg-head"><h3><span class="bar vio"></span>手机号登录</h3></div><div class="cfg-body">'+
'<div class="form-grid">'+
'<div class="f-item"><label>手机号（极核 App 绑定号码）</label><input type="tel" id="pl_phone" placeholder="11 位手机号" style="font-family:ui-monospace,Menlo,monospace;font-size:13px"></div>'+
'<div class="f-item"><label>短信验证码</label><input type="text" id="pl_code" placeholder="6 位验证码" style="font-family:ui-monospace,Menlo,monospace;font-size:13px"></div>'+
'</div>'+
'<div class="btn-row"><button class="btn sm" onclick="sendSmsCode()" id="pl_send_btn">获取验证码</button><button class="btn primary" onclick="phoneLoginUI()" id="pl_login_btn">登录并添加账号</button></div>'+
'<div class="hint" style="margin-top:10px">用手机号 + 短信验证码登录，自动获取 Token 与用户ID并加入账号列表，登录成功后自动保存并刷新页面。<br>· 小号登录：可多次登录不同手机号，按小号逐个添加与管理。<br>· 服务到期 / 绑定续费：车辆智能服务到期、或需要绑定续费时，重新用手机号登录即可刷新授权，全程无需抓包。</div>'+
'</div></div>'+
  '<div class="cfg-panel"><div class="cfg-head"><h3><span class="bar green"></span>定时签到</h3></div><div class="cfg-body">'+
  sw("auto_signin","定时签到","到点自动为全部账号签到",cfg.autoSignin===true)+
  sw("vehicle_monitor","车辆状态监控","充满/离线时本地通知提醒（打开面板时检查）",cfg.vehicleMonitor===true)+
  '<div class="f-item" style="margin-top:10px"><label>签到时间（每天，HH:MM）</label><input type="time" id="cfg_signin_time" value="'+esc(cfg.autoSigninTime||"07:00")+'" style="font-family:ui-monospace,Menlo,monospace;font-size:13px"></div>'+
  '<div class="hint" style="margin-top:10px">代理脚本无常驻后台，采用「打开补签」机制：开启后，每天首次打开面板且已过设定时间时，自动为全部账号执行一次签到（写日志、推 Bark，与手动签到一致），同一天只执行一次。首页「立即签到」悬浮按钮可随时手动执行。</div>'+
  '</div></div>'+
  '<div class="cfg-panel"><div class="cfg-head"><h3><span class="bar amber"></span>社区任务开关</h3></div><div class="cfg-body"><div class="form-grid" style="gap:8px">'+
  sw("comm_post","发布动态","+1 分",comm.enablePost!==false)+sw("comm_like","点赞动态","+1 分",comm.enableLike!==false)+sw("comm_comment","评论动态","不加分",comm.enableComment!==false)+sw("comm_share","分享动态","+1 分",comm.enableShare!==false)+sw("comm_delete","执行后删除动态","清理痕迹",comm.enableDelete!==false)+
  '</div><div class="hint" style="margin-top:10px">关闭对应开关后，签到脚本将跳过该任务。修改后点击页面底部「保存配置」生效。</div></div></div>'+
  '<div class="cfg-panel"><div class="cfg-head"><h3><span class="bar green"></span>账号管理（'+cfgAccounts.length+' 个）</h3><button class="btn sm primary" onclick="addAccountUI()">+ 添加账号</button></div><div class="cfg-body" id="accList">'+(accRows||'<div style="text-align:center;padding:22px;color:var(--txt3);font-size:13px">暂无账号，点击「添加账号」</div>')+'</div>'+
  '<div class="cfg-body" style="padding-top:0"><div class="btn-row"><button class="btn primary" onclick="saveAccountsUI()">保存极核账号</button></div>'+
  '<div class="cfg-note"><b>使用说明</b><br>· Token：粘贴抓包得到的 Authorization 值即可，自动去掉 <code>Bearer </code> 前缀。<br>· 获取ID：填入 Token 后点「获取ID」，自动从 H5 baseInfo / App setting / 车辆列表接口解析用户ID与昵称。<br>· Bark Key：该账号签到成功后推送通知，留空不推。<br>· 控车指令（寻车/鸣笛/坐垫/开关锁）会真实操作车辆，需二次确认。</div></div></div>'+
  '<div class="cfg-panel"><div class="cfg-head"><h3><span class="bar amber"></span>备份账号配置</h3></div><div class="cfg-body">'+
  '<div class="btn-row"><button class="btn primary" onclick="exportBackupUI()">一键导出备份</button><button class="btn" onclick="copyBackupUI()">复制备份</button></div>'+
  '<div class="f-item" style="margin-top:12px"><label>备份内容（包含全部账号与面板配置，可复制保存）</label><textarea id="backupArea" rows="4" readonly placeholder="点击「一键导出备份」生成…" style="width:100%;padding:9px 11px;border:1px solid var(--line);border-radius:10px;background:var(--bg);color:var(--txt);font-family:ui-monospace,Menlo,monospace;font-size:11px;box-sizing:border-box"></textarea></div>'+
  '<div class="f-item" style="margin-top:12px"><label>恢复备份（粘贴备份 JSON 后点恢复，将覆盖现有账号与配置）</label><textarea id="importArea" rows="4" placeholder="粘贴备份 JSON…" style="width:100%;padding:9px 11px;border:1px solid var(--line);border-radius:10px;background:var(--bg);color:var(--txt);font-family:ui-monospace,Menlo,monospace;font-size:11px;box-sizing:border-box"></textarea></div>'+
  '<div class="btn-row"><button class="btn danger" onclick="importBackupUI()">恢复备份</button></div>'+
  '<div class="hint" style="margin-top:10px">备份包含全部账号（昵称/用户ID/Token/BarkKey）与面板配置（签名密钥/社区任务开关/自动刷新等）。换机或重装后粘贴即可一键还原，无需重新抓包填写。</div>'+
  '</div></div>'+
  '<div class="cfg-panel"><div class="cfg-head"><h3><span class="bar vio"></span>小组件显示车辆</h3></div><div class="cfg-body">'+
  '<div class="f-item"><label>账号</label><select id="widget_acc" style="width:100%;padding:10px 12px;border:1px solid var(--line);border-radius:12px;background:var(--card2);color:var(--txt);font-size:14px" onchange="widgetAccChanged()">'+widgetAccOptions()+ '</select></div>'+
  '<div class="f-item" style="margin-top:10px"><label>车辆</label><select id="widget_veh" style="width:100%;padding:10px 12px;border:1px solid var(--line);border-radius:12px;background:var(--card2);color:var(--txt);font-size:14px"></select></div>'+
  '<div class="hint" style="margin-top:10px">选择后，iOS 桌面小组件将展示该车辆的实时状态（电量/续航/充电/签到）。<b>不选择时默认取第一个账号的第一辆车。</b>保存配置后生效。</div>'+
  '</div></div>'+
  '<div class="cfg-panel"><div class="cfg-head"><h3><span class="bar"></span>车辆图片替换</h3><button class="btn sm" onclick="loadPicRows()">刷新车辆</button></div><div class="cfg-body" id="picList"><div style="text-align:center;padding:18px;color:var(--txt3);font-size:13px">加载中…</div></div>'+
  '<div class="cfg-body" style="padding-top:0"><div class="btn-row"><button class="btn primary" onclick="savePicCfg()">保存图片替换</button></div>'+
  '<div class="hint" style="margin-top:10px">为每辆车选择官方车型图（含 <b>AE5i 电轻摩版</b>四种配色）。保存后在 <b>Loon/代理脚本环境</b>下，官方 App 与面板里的该车辆照片即被替换（需面板脚本处于运行状态）；选「不替换」恢复官方原图。浏览器直开模式仅保存配置、不改写 App。</div></div></div>'+
  '<div class="cfg-panel"><div class="cfg-head"><h3><span class="bar"></span>自定义背景</h3></div><div class="cfg-body">'+
  '<div class="f-item"><label>上传背景照片（会铺在深色底色之上，建议深色/低亮度图片以保证文字可读）</label><input type="file" id="bg_file" accept="image/*" style="font-size:12px" onchange="bgFileChanged(this)"></div>'+
  '<div style="margin-top:10px;display:flex;gap:8px;flex-wrap:wrap;align-items:center"><div id="bgPreview" style="width:120px;height:72px;border-radius:10px;border:1px solid var(--line);background:var(--card3);background-size:cover;background-position:center;display:flex;align-items:center;justify-content:center;color:var(--txt3);font-size:10px;overflow:hidden">未选择</div><div style="display:flex;flex-direction:column;gap:8px"><button class="btn sm primary" onclick="applyBgUpload()" id="bg_apply_btn">应用背景</button><button class="btn sm" onclick="resetBg()">恢复默认</button></div></div>'+
  '<div class="hint" style="margin-top:10px">图片以 base64 存入配置，随备份一并导出。切换背景实时生效，无需重启。</div>'+
  '</div></div>'+
  // v2.14.21 删除「车控风险确认」面板：改为首次使用车控功能时弹窗确认（同意/不同意）
  '<div class="cfg-panel"><div class="cfg-head"><h3><span class="bar amber"></span>当前安装信息</h3></div><div class="cfg-body" style="font-size:12px;line-height:1.9;color:var(--txt2)" id="installInfo">'+
  '<div style="color:var(--txt3)">正在检测安装方式…</div>'+
  '</div></div>'+
  '<div class="btn-row" style="margin:14px 2px"><button class="btn primary" onclick="saveCfgUI()">保存配置</button><button class="btn" onclick="resetCfgUI()">恢复默认</button></div>'+
  '<div class="cfg-panel" style="margin-top:14px"><div class="cfg-body" style="padding:4px 0">'+
  '<a href="mailto:mlink798@outlook.com" style="display:flex;align-items:center;justify-content:space-between;padding:12px 16px;text-decoration:none;color:var(--brand)"><span style="display:flex;align-items:center;gap:10px"><span style="font-size:16px">✉️</span><span style="font-size:14px;font-weight:600">mlink798@outlook.com</span></span></a>'+
  '<div style="height:1px;background:var(--line);margin:0 16px"></div>'+
  '<a href="https://github.com/cluck798/ZEEHO" target="_blank" rel="noopener" style="display:flex;align-items:center;justify-content:space-between;padding:12px 16px;text-decoration:none;color:var(--brand)"><span style="display:flex;align-items:center;gap:10px"><span style="font-size:16px">⭐</span><span style="font-size:14px;font-weight:600">GitHub 仓库</span></span><span style="font-size:13px;color:var(--txt3)">cluck798/ZEEHO</span></a>'+
  '<div style="height:1px;background:var(--line);margin:0 16px"></div>'+
  '<div style="display:flex;align-items:center;justify-content:space-between;padding:12px 16px"><span style="display:flex;align-items:center;gap:10px"><span style="font-size:16px">📋</span><span style="font-size:14px;font-weight:600;color:var(--txt2)">版本 / 更新检测</span></span><span style="display:flex;align-items:center;gap:8px"><span style="font-size:13px;color:var(--txt3)">'+APP_VERSION+'</span><button class="btn sm" id="verCheckBtn" onclick="checkVersion(true)">检查更新</button></span></div>'+
  '<div id="verExtra" style="padding:0 16px 12px;font-size:12px;line-height:1.75;color:var(--txt3)">'+verExtraHtml()+'</div>'+
  '</div></div>'+
  '<div class="foot">极核 ZEEHO 面板 '+APP_VERSION+' · '+(isProxyMode()?'账号与密钥存储于脚本后端（本机持久化）':'数据存储于本机浏览器 localStorage')+'<br><a class="link" href="https://afdian.com/a/lucky798" target="_blank" rel="noopener">爱发电 · afdian.com/a/lucky798</a></div>';
  // 小组件车辆下拉初始化（回填已保存的选择）
  const wsel=document.getElementById("widget_acc");
  if(wsel){
    const cur=getCfg().widgetVehicle;let curUid="",curVin="";
    if(cur){const p=cur.split("|");curUid=p[0]||"";curVin=p[1]||"";}
    if(curUid)wsel.value=curUid;
    document.getElementById("widget_veh").innerHTML=widgetVehOptions(wsel.value||"");
    if(curVin){const vsel=document.getElementById("widget_veh");for(let i=0;i<vsel.options.length;i++){if(vsel.options[i].value===curVin){vsel.selectedIndex=i;break}}}
  }
  // 背景预览回填
  const bp=document.getElementById("bgPreview");
  if(bp){const bg=getCfg().customBg;if(bg){bp.style.backgroundImage="url("+bg+")";bp.textContent="";}}
  loadPicCfg();
  renderInstallInfo();
}
/* ================= 当前安装信息 ================= */
function installEnvName(){
  if(isDemo())return "演示模式（示例数据）";
  const p=(typeof location!=="undefined"&&location.protocol)||"";
  if(p==="zeeho:")return "iOS App（极核签到面板）";
  if(typeof navigator!=="undefined"&&/Electron/i.test(navigator.userAgent||""))return "桌面版（Windows）";
  if(isProxyMode())return "代理脚本";
  return "浏览器";
}
async function renderInstallInfo(){
  const box=document.getElementById("installInfo");
  let html='<div style="margin-bottom:8px"><b style="color:var(--txt)">运行环境：</b>'+installEnvName()+'</div>';
  // 原生桥接自检：行车记录仪桥由原生注入，缺失时对应功能不可用
  html+='<div style="margin-bottom:8px"><b style="color:var(--txt)">原生桥接：</b>记录仪 '+((typeof dashcamHandler==="function")?'✓ 可用':'✗ 未注入')+'</div>';
  let info=null;
  try{info=await Backend.installInfo();}catch(e){info=null}
  if(!info||!info.ios){
    html+='<div style="color:var(--txt3)">签名方式仅支持 iOS App 内查看（读取当前安装包的签名描述文件）。</div>';
  } else {
    const m=info.signMethod||"unknown";
    const label={trollstore:"巨魔 TrollStore（永久签名）",enterprise:"企业签名（分发）",sideload:"个人自签（7 天有效期）",developer:"开发者 / TestFlight（长期）",unknown:"无法确定"}[m]||"无法确定";
    html+='<div style="margin-bottom:6px"><b style="color:var(--txt)">安装方式：</b>'+label+'</div>';
    if(info.expiration){
      let extra="";
      if(typeof info.daysRemain==="number"&&isFinite(info.daysRemain)&&info.daysRemain>=0)extra='（剩余约 '+info.daysRemain+' 天）';
      html+='<div style="margin-bottom:6px"><b style="color:var(--txt)">签名有效期至：</b>'+esc(String(info.expiration).replace("T"," ").replace("Z",""))+' '+extra+'</div>';
    }
    if(info.teamName||info.teamId){
      html+='<div style="margin-bottom:6px"><b style="color:var(--txt)">签名团队：</b>'+esc(info.teamName||info.teamId)+'</div>';
    }
    if(m==="sideload"){html+='<div class="hint" style="margin-top:6px">个人自签 7 天到期后，需连接电脑用 AltStore / Sideloadly 重新签名；建议改用巨魔 TrollStore 永久签名。</div>';}
    else if(m==="enterprise"){html+='<div class="hint" style="margin-top:6px">如遇「未受信任的开发者」，请在 设置 → 通用 → VPN与设备管理 信任对应企业证书。</div>';}
    else if(m==="trollstore"){html+='<div class="hint" style="margin-top:6px">已通过 TrollStore 安装，永久有效、不怕掉签，无需电脑续签。</div>';}
  }
  if(box)box.innerHTML=html;
}
/* ================= 小组件车辆选择 ================= */
function widgetAccOptions(){
  const list=STATE.data||[];
  if(!list.length)return '<option value="">暂无账号数据（请先在首页刷新加载）</option>';
  return list.map((a,i)=>{
    const nm=esc((a.vehicle&&(a.vehicle.vehicleName||a.vehicle.vehicleType))||a.userName||("账号"+(i+1)));
    return '<option value="'+esc(a.userId||"")+'" data-i="'+i+'">'+nm+'</option>';
  }).join("");
}
function widgetVehOptions(uid){
  const list=STATE.data||[];
  const a=list.find(x=>String(x.userId||"")===String(uid));
  if(!a||!a.vehicle||!a.vehicle.hasVehicle)return '<option value="">该账号暂无绑定车辆</option>';
  const v=a.vehicle;
  const arr=(Array.isArray(v.vehicles)&&v.vehicles.length)?v.vehicles.map(x=>({name:x.vehicleType||x.name||x.vinNo,vin:x.vinNo})):[{name:v.vehicleType||v.vehicleName||v.vinNo,vin:v.vinNo}];
  return arr.map(x=>'<option value="'+esc(x.vin)+'">'+esc(x.name)+'</option>').join("");
}
function widgetAccChanged(){
  const sel=el("widget_acc");if(!sel)return;
  el("widget_veh").innerHTML=widgetVehOptions(sel.value||"");
}
function widgetSelectionText(){
  const acc=el("widget_acc"),veh=el("widget_veh");
  if(!acc||!veh||!acc.value||!veh.value)return "";
  return acc.value+"|"+veh.value;
}
/* ================= v2.16.9 车辆图片替换 ================= */
const PIC_CATALOG=[{n:"不替换（官方原图）",u:""},{n:"AE5i 电轻摩 · 星光黑",u:"https://aka.doubaocdn.com/s/LbHzfCJq5Y"},{n:"AE5i 电轻摩 · 速感灰",u:"https://aka.doubaocdn.com/s/ozRKIcaSZG"},{n:"AE5i 电轻摩 · 星光白",u:"https://aka.doubaocdn.com/s/N5d9A3msPY"},{n:"AE5i 电轻摩 · 极核橙",u:"https://aka.doubaocdn.com/s/RsVDVGMIvF"},{n:"AE5i Pro 官方 · 灰",u:"https://oss-cfmoto.zeehoev.com/uploads/zeeho-client-pc/media/1758172641684.png"},{n:"AE5i Pro Max 官方 · 白",u:"https://oss-cfmoto.zeehoev.com/uploads/zeeho-client-pc/media/1758172630857.png"},{n:"AE8 S+ MY25 官方",u:"https://oss-cfmoto.zeehoev.com/uploads/zeeho-client-pc/media/1784626678222.png"}];
let PIC_CFG={};
function picKnown(u){return PIC_CATALOG.some(o=>o.u&&o.u===u)}
function picRow(vin,name,acc){
  const cur=PIC_CFG[vin]||"";
  const opts=PIC_CATALOG.map(o=>'<option value="'+esc(o.u)+'"'+((o.u||"")===cur?" selected":"")+">"+esc(o.n)+"</option>").join("")+'<option value="__custom__"'+(cur&&!picKnown(cur)?" selected":"")+">自定义 URL…</option>";
  const showCustom=cur&&!picKnown(cur);
  return '<div class="f-item" style="margin-bottom:12px" data-vin="'+esc(vin)+'"><label>'+esc(name)+(acc?' <span style="color:var(--txt3);font-size:11px">('+esc(acc)+')</span>':'')+' · <code style="font-size:10px">'+esc(String(vin).slice(-6))+'</code></label>'+
  '<select style="width:100%;padding:9px 11px;border:1px solid var(--line);border-radius:10px;background:var(--card2);color:var(--txt);font-size:13px" onchange="picSelChanged(this)">'+opts+'</select>'+
  '<input class="pic-custom" placeholder="自定义图片 URL（https 开头，建议官方 OSS/图床直链）" value="'+esc(showCustom?cur:"")+'" style="display:'+(showCustom?"block":"none")+';margin-top:6px;width:100%;padding:9px 11px;border:1px solid var(--line);border-radius:10px;background:var(--bg);color:var(--txt);font-size:12px;box-sizing:border-box"></div>';
}
function picSelChanged(s){const item=s.closest(".f-item");const inp=item?item.querySelector(".pic-custom"):null;if(!inp)return;if(s.value==="__custom__"){inp.style.display="block";inp.focus()}else{inp.style.display="none"}}
function picRowsHtml(){
  const list=STATE.data||[];const rows=[];const seen={};
  for(const a of list){
    const v=a.vehicle;
    if(v&&v.hasVehicle){
      const arr=(Array.isArray(v.vehicles)&&v.vehicles.length)?v.vehicles:[{vehicleType:v.vehicleType||v.vehicleName,vinNo:v.vinNo}];
      for(const x of arr){const vin=String(x.vinNo||"").trim();if(!vin||seen[vin])continue;seen[vin]=1;rows.push({vin,name:String(x.vehicleType||x.name||v.vehicleType||v.vehicleName||"车辆"),acc:a.userName||""})}
    }
  }
  for(const vin of Object.keys(PIC_CFG)){if(!seen[vin])rows.push({vin,name:"已配置车辆",acc:""})}
  return rows.length?rows.map(r=>picRow(r.vin,r.name,r.acc)).join(""):'<div style="text-align:center;padding:16px;color:var(--txt3);font-size:13px">未检测到已绑定车辆，可在下方按 VIN 手动添加</div>';
}
function picManualHtml(){
  const opts=PIC_CATALOG.map(o=>'<option value="'+esc(o.u)+'">'+esc(o.n)+'</option>').join("");
  return '<div class="f-item" style="margin-top:4px"><label>按 VIN 手动添加（完整 VIN 见 App 车辆信息）</label><div style="display:flex;gap:8px;flex-wrap:wrap"><input id="pic_manual_vin" placeholder="完整 VIN（17位）" style="flex:1;min-width:150px;padding:9px 11px;border:1px solid var(--line);border-radius:10px;background:var(--bg);color:var(--txt);font-size:12px;box-sizing:border-box"><select id="pic_manual_pic" style="flex:1;min-width:130px;padding:9px 10px;border:1px solid var(--line);border-radius:10px;background:var(--card2);color:var(--txt);font-size:12px">'+opts+'</select><button class="btn sm primary" onclick="addPicManual()">添加</button></div></div>';
}
function loadPicRows(){const box=el("picList");if(!box)return;box.innerHTML=picRowsHtml()+picManualHtml()}
function addPicManual(){
  const vin=((el("pic_manual_vin")||{}).value||"").trim();
  const u=(el("pic_manual_pic")||{}).value||"";
  if(!vin){toast("请输入完整 VIN","err");return}
  if(u)PIC_CFG[vin]=u;else delete PIC_CFG[vin];
  loadPicRows();
}
function collectPicCfg(){
  const out={};
  document.querySelectorAll("#picList .f-item[data-vin]").forEach(item=>{
    const vin=item.getAttribute("data-vin");if(!vin)return;
    const s=item.querySelector("select");const inp=item.querySelector(".pic-custom");
    const u=s.value==="__custom__"?(inp?inp.value.trim():""):s.value;
    if(u&&/^https?:[/][/]/.test(u))out[vin]=u;
  });
  return out;
}
async function loadPicCfg(){
  PIC_CFG={};
  try{const r=await fetch("/api/pic-cfg").then(x=>x.json());if(r&&r.ok)PIC_CFG=r.pics||{}}catch(e){PIC_CFG=getCfg().pics||{}}
  loadPicRows();
}
async function savePicCfg(){
  const pics=collectPicCfg();PIC_CFG=pics;
  if(isProxyMode()){
    try{const r=await fetch("/api/pic-cfg",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({pics})}).then(x=>x.json());
      if(r&&r.ok){toast("图片替换已保存（"+r.count+" 辆车），打开极核App车辆页即生效","ok")}else{toast("保存失败:"+((r&&r.error)||"未知"),"err")}
    }catch(e){toast("保存失败:"+e,"err")}
  }else{const c=getCfg();c.pics=pics;saveCfg(c);toast("已保存到本地（浏览器模式不改写官方App）","info")}
}
/* ================= 自定义背景 ================= */
let __bgData="";
function bgFileChanged(inp){
  const f=inp&&inp.files&&inp.files[0];
  if(!f)return;
  if(f.size>6*1024*1024){toast("图片过大（限 6MB）","err");inp.value="";return;}
  const r=new FileReader();
  r.onload=function(){__bgData=r.result;const p=el("bgPreview");if(p){p.style.backgroundImage="url("+__bgData+")";p.textContent="";}toast("已选择图片，点「应用背景」生效","info");};
  r.readAsDataURL(f);
}
function applyBgUpload(){
  if(!__bgData){toast("请先选择图片","err");return;}
  const c=getCfg();c.customBg=__bgData;saveCfg(c);
  applyCustomBg();
  const inp=el("bg_file");if(inp)inp.value="";
  __bgData="";
  toast("背景已应用","ok");
}
function resetBg(){
  const c=getCfg();c.customBg="";saveCfg(c);
  applyCustomBg();
  const p=el("bgPreview");if(p){p.style.backgroundImage="";p.textContent="未选择";}
  toast("已恢复默认背景","info");
}
function applyCustomBg(){
  const bg=getCfg().customBg,b=document.body;
  if(bg){b.style.backgroundImage="url("+bg+")";b.style.backgroundSize="cover";b.style.backgroundPosition="center";b.style.backgroundAttachment="fixed";}
  else{b.style.backgroundImage="";b.style.backgroundSize="";b.style.backgroundPosition="";b.style.backgroundAttachment="";}
}
/* ================= 手机号登录（免抓包） ================= */
async function sendSmsCode(){
  const phone=(el("pl_phone")?.value||"").trim();
  if(!/^1\d{10}$/.test(phone)){toast("请输入正确的11位手机号","err");return;}
  const btn=el("pl_send_btn");btn.disabled=true;btn.textContent="发送中…";
  const d=await Backend.sendCode(phone);
  if(d&&d.ok){toast(d.message||"验证码已发送","ok");let t=60;btn.textContent="重新获取("+t+"s)";
    const iv=setInterval(()=>{t--;if(t<=0){clearInterval(iv);btn.textContent="获取验证码";btn.disabled=false;}else btn.textContent="重新获取("+t+"s)";},1000);
  }else{toast((d&&d.message)||"发送失败，请检查网络","err");btn.disabled=false;btn.textContent="获取验证码";}
}
async function phoneLoginUI(){
  const phone=(el("pl_phone")?.value||"").trim();
  const code=(el("pl_code")?.value||"").trim();
  if(!/^1\d{10}$/.test(phone)){toast("请输入正确的11位手机号","err");return;}
  if(!code){toast("请输入短信验证码","err");return;}
  const btn=el("pl_login_btn");btn.disabled=true;btn.textContent="登录中…";
  const d=await Backend.phoneLogin(phone,code,"");
  if(d&&d.ok){toast(d.message||"登录成功","ok");setTimeout(()=>location.reload(),1200);}
  else{toast((d&&d.message)||"登录失败","err");}
  btn.disabled=false;btn.textContent="登录并添加账号";
}
// v2.14.21 签名密钥配置面板已删除：app/h5/AES 密钥直接沿用当前值（内置默认），不再从输入框读取
// v2.14.21 风险确认改弹窗：保存配置时沿用当前 vehicleControlRisk，不清空同意状态
function collectCfgUI(){const cur=getCfg();return{app:{appId:cur.app.appId,appSecret:cur.app.appSecret},h5:{appId:cur.h5.appId,appSecret:cur.h5.appSecret},vehicleAesKey:cur.vehicleAesKey,vehicleControlRisk:cur.vehicleControlRisk,autoRefreshSec:normalizeRefreshSec(cur.autoRefreshSec||60),serverBase:cur.serverBase||"",autoSignin:el("auto_signin")?el("auto_signin").checked:false,autoSigninTime:(val("cfg_signin_time")||"07:00"),vehicleMonitor:el("vehicle_monitor")?el("vehicle_monitor").checked:false,widgetVehicle:widgetSelectionText()||cur.widgetVehicle,customBg:cur.customBg,pics:(cur.pics||{}),community:{enablePost:el("comm_post").checked,enableLike:el("comm_like").checked,enableComment:el("comm_comment").checked,enableShare:el("comm_share").checked,enableDelete:el("comm_delete").checked}}}
function val(id){const e=document.getElementById(id);return e?e.value:""}
function el(id){return document.getElementById(id)}
async function saveCfgUI(){const c=collectCfgUI();const ok=await Backend.saveConfig(c);if(ok){if(isProxyMode()){applyRemoteCfg(c);STATE.panelLoaded=false}toast("配置已保存","ok");startAutoRefresh(c.autoRefreshSec);refreshAll(true)}else toast("保存失败","err")}
// v2.14.21 签名密钥面板已删除：恢复默认时密钥直接写回内置默认值
function resetCfgUI(){if(el("auto_signin"))el("auto_signin").checked=false;if(el("cfg_signin_time"))el("cfg_signin_time").value="07:00";if(el("comm_post"))el("comm_post").checked=true;if(el("comm_like"))el("comm_like").checked=true;if(el("comm_comment"))el("comm_comment").checked=true;if(el("comm_share"))el("comm_share").checked=true;if(el("comm_delete"))el("comm_delete").checked=true;const c=getCfg();c.app={appId:DEFAULT_CFG.app.appId,appSecret:DEFAULT_CFG.app.appSecret};c.h5={appId:DEFAULT_CFG.h5.appId,appSecret:DEFAULT_CFG.h5.appSecret};c.vehicleAesKey=DEFAULT_CFG.vehicleAesKey;c.vehicleControlRisk="";c.widgetVehicle="";c.customBg="";saveCfg(c);applyCustomBg();if(el("widget_acc")){el("widget_acc").value="";el("widget_veh").innerHTML="";}const bp=el("bgPreview");if(bp){bp.style.backgroundImage="";bp.textContent="未选择";}toast("已恢复默认（需点击保存）","info")}
function addAccountUI(){cfgAccounts.push({userName:"",userId:"",token:"",barkKey:""});const list=el("accList");const idx=cfgAccounts.length-1;const html='<div class="acc-edit" data-i="'+idx+'"><div class="acc-edit-head"><span class="acc-edit-title"><span class="n">'+String(idx+1)+'</span>账号 '+String(idx+1)+'（新）</span><span class="acts"><button class="btn sm" id="uidBtn_'+idx+'" onclick="fetchUserIdUI('+idx+')">获取ID</button><button class="btn sm danger" onclick="deleteAccountUI('+idx+')">删除</button></span></div><div class="form-grid"><div class="f-item"><label>昵称</label><input type="text" id="acc_name_'+idx+'" placeholder="如 lucky798"></div><div class="f-item"><label>用户ID</label><input type="text" id="acc_uid_'+idx+'" placeholder="留空可点「获取ID」"></div></div><div class="f-item" style="margin-top:10px"><label>Authorization Token</label><input type="text" id="acc_token_'+idx+'" placeholder="a74779c7-…"></div><div class="f-item" style="margin-top:10px"><label>Bark 通知 Key（选填）</label><input type="text" id="acc_bark_'+idx+'" placeholder="Bark Key 或自建 https://域名/Key"></div></div>';if(list.querySelector(".acc-edit")||list.querySelector("[style*='text-align']")){list.insertAdjacentHTML("beforeend",html)}else{list.innerHTML=html}}
function deleteAccountUI(idx){const row=document.querySelector('.acc-edit[data-i="'+idx+'"]');if(row){row.remove();cfgAccounts.splice(idx,1);toast("已删除（需点击保存）","info")}}
function collectAccountsUI(){const rows=document.querySelectorAll("#accList .acc-edit");const list=[];rows.forEach(row=>{const i=row.getAttribute("data-i");const token=el("acc_token_"+i)?.value||"";if(token.trim()){list.push({userName:el("acc_name_"+i)?.value||"",userId:el("acc_uid_"+i)?.value||"",token:cleanToken(token),barkKey:cleanBarkKey(el("acc_bark_"+i)?.value||"")})}});return list}
async function saveAccountsUI(){const list=collectAccountsUI().map(a=>({userName:(a.userName||"").trim(),userId:(a.userId||"").trim(),token:cleanToken(a.token),barkKey:cleanBarkKey(a.barkKey)}));const ok=await Backend.saveAccounts(list);if(ok){if(isProxyMode())STATE.panelAccounts=list;toast("极核账号已保存","ok");refreshAll(true)}else toast("保存失败","err")}
async function fetchUserIdUI(idx){const token=cleanToken(el("acc_token_"+idx)?.value||"");const btn=el("uidBtn_"+idx);if(!token){toast("请先填写 Token","err");return}btn.textContent="获取中…";btn.disabled=true;const d=await Backend.getUserid(token);if(d&&d.ok&&d.userId){if(el("acc_uid_"+idx))el("acc_uid_"+idx).value=d.userId;if(d.userName&&el("acc_name_"+idx)&&!el("acc_name_"+idx).value)el("acc_name_"+idx).value=d.userName;toast("获取成功："+(d.userName||d.userId),"ok")}else{toast("获取失败："+((d&&d.error)||"未知错误"),"err")}btn.textContent="获取ID";btn.disabled=false}

/* ================= 备份 / 恢复 ================= */
function exportBackupUI(){const el=document.getElementById("backupArea");if(!el){toast("界面未就绪","err");return}el.value="生成中…";Backend.backup().then(d=>{if(d&&d.ok){el.value=JSON.stringify(d,null,2);toast("备份已生成，可复制保存","ok")}else{el.value="";toast("导出失败："+((d&&d.error)||"无法连接脚本后端"),"err")}})}
function copyBackupUI(){const el=document.getElementById("backupArea");if(!el||!el.value){toast("请先点击「一键导出备份」","err");return}if(navigator.clipboard&&navigator.clipboard.writeText){navigator.clipboard.writeText(el.value).then(()=>toast("已复制到剪贴板","ok"),()=>{el.select();document.execCommand("copy");toast("已复制到剪贴板","ok")})}else{el.select();document.execCommand("copy");toast("已复制到剪贴板","ok")}}
function importBackupUI(){const el=document.getElementById("importArea");if(!el||!el.value.trim()){toast("请先粘贴备份内容","err");return}confirmDialog("恢复备份","将覆盖当前全部账号与面板配置，此操作不可撤销。","importBackupNow")}
async function importBackupNow(){const el=document.getElementById("importArea");const v=el?el.value.trim():"";if(!v){toast("备份内容为空","err");return}const d=await Backend.restoreBackup(v);if(d&&d.ok){toast("恢复成功："+(d.count||0)+" 个账号","ok");if(isProxyMode()){STATE.panelAccounts=[];STATE.panelLoaded=false}STATE.data=[];renderCfg();refreshAll(true)}else toast("恢复失败："+((d&&d.error)||"备份内容格式错误"),"err")}

/* ================= 演示数据（?demo 预览用，不联网） ================= */
function isDemo(){return location.search.indexOf("demo")>=0}
function demoCal(){
  const now=new Date(),y=now.getFullYear(),m=now.getMonth()+1,dim=new Date(y,m,0).getDate(),p=n=>String(n).padStart(2,"0"),out=[];
  for(let d=1;d<=dim;d++){
    const ds=y+"-"+p(m)+"-"+p(d);
    if(ds>y+"-"+p(m)+"-"+p(now.getDate()))break;
    if(d===3||d===11)continue;          // 演示：两天漏签
    out.push({createDate:ds,signStatue:5});
  }
  return out;
}
const DEMO_INTEGRAL={ok:true,total:{integralTotal:"12,880"},expire:[{integralScore:320,expiryDateStr:"2026-12-31"}],detail:[
  {name:"每日签到",integralScore:6,myDateStr:"2026-09-29 07:00"},
  {name:"社区发帖",integralScore:1,myDateStr:"2026-09-29 07:00"},
  {name:"社区点赞",integralScore:1,myDateStr:"2026-09-29 07:00"},
  {name:"社区分享",integralScore:1,myDateStr:"2026-09-29 07:00"},
  {name:"盲盒奖励",integralScore:6,myDateStr:"2026-09-28 07:00"},
  {name:"补签消耗",integralScore:-1,myDateStr:"2026-09-27 21:10"}
]};
const DEMO_SUPPLEMENT={count:{ok:true,data:{count:2,cardNum:2}},month:{ok:true,data:{nowSignDetailVos:[]}}};
const DEMO_MONITOR={ok:true,snapshot:{vin:"LB7JM1C10NA000001",soc:76,range:63,voltage:84.5,current:0,chargeState:"未充电",headLock:"1",offline:false,refreshTime:"2026-09-29 03:10",frontPressure:"2.35bar",rearPressure:"2.40bar",frontTemp:"31°C",rearTemp:"32°C",batteryTemp:26,todayDistance:12.6,todayDuration:34,todayMaxSpeed:56,address:"福建省宁德市蕉城区东侨开发区",serviceEndDate:"2027-03-18"},
  vehicles:[{vehicleName:"ZEEHO AE4",vinNo:"LB7JM1C10NA000001",vehicleType:"AE4 MAX2+"},{vehicleName:"极核 AE6",vinNo:"LB7JM1C10NA000002",vehicleType:"AE6"}]};
const DEMO_CTRL_OPTS={ok:true,chargePower:[{key:"400"},{key:"800"},{key:"1000"}],gears:["25","45","60"]};
const DEMO_INFO={ok:true,unread:{total:3},prizeRecords:{records:[{prizesName:"积分 +6",createTime:"2026-09-28 07:00",integral:6},{prizesName:"补签卡 ×1",createTime:"2026-09-21 07:00"}]},coupons:{records:[{},{},{}]},ota:[]};
/* v2.16.0 骑行演示数据：合成轨迹（确定性生成），月度记录与轨迹扫描结果保持一致 */
function demoTrack(seed,steps,day){
  let s=seed>>>0;
  let lon=119.5509,lat=26.6654,hdg=45,out=[];
  const d0=new Date();d0.setDate(day);d0.setHours(14,20,0,0);
  const t0=d0.getTime()+(seed%13)*60000;
  for(let i=0;i<steps;i++){
    const ph=i/steps;
    const target=45+50*Math.sin(ph*Math.PI*2.6)+14*Math.sin(ph*Math.PI*6.3+(seed%7));
    hdg=hdg+(target-hdg)*0.32;
    let v=34+13*Math.sin(ph*Math.PI*3.3+(seed%5))+1.5*Math.sin(ph*Math.PI*17);
    if(i>Math.floor(steps*0.60)&&i<Math.floor(steps*0.64))v-=24;
    v=Math.max(6,Math.min(64,v));
    const rad=hdg*Math.PI/180;
    const stepM=v*1000/3600*2;
    lat+=stepM*Math.cos(rad)/111320;
    lon+=stepM*Math.sin(rad)/(111320*Math.cos(lat*Math.PI/180));
    out.push(lon.toFixed(6)+","+lat.toFixed(6)+","+v.toFixed(1)+","+(t0+i*2000));
  }
  return out.join("&");
}
function demoRideDays(){
  const now=new Date();const cur=now.getFullYear()+"."+String(now.getMonth()+1).padStart(2,"0");const p=n=>String(n).padStart(2,"0");
  return [{dayTime:cur+"."+p(10),rides:[{rideId:"DEMO-R1",trajectory:demoTrack(11,90,10)},{rideId:"DEMO-R2",trajectory:demoTrack(23,70,10)}]},
          {dayTime:cur+"."+p(8),rides:[{rideId:"DEMO-R3",trajectory:demoTrack(7,110,8)}]}];
}
function demoRideTrack(page){
  if(page&&page>1)return{ok:true,page:page,vinNo:"LB7JM1C10NA000001",days:[]};
  return{ok:true,page:1,vinNo:"LB7JM1C10NA000001",days:demoRideDays().map(d=>({dayTime:d.dayTime,historyList:d.rides}))};
}
function demoRideMonth(month){
  const now=new Date();const cur=now.getFullYear()+"."+String(now.getMonth()+1).padStart(2,"0");const p=n=>String(n).padStart(2,"0");
  if(month&&month!==cur)return{ok:true,month:month,vinNo:"LB7JM1C10NA000001",vehicleName:"ZEEHO AE4",data:{rideMileageTotal:0,rideRecordList:[]}};
  const scan=rideDayScan(demoRideTrack(1).days);
  const mk=(d,extra)=>{
    const c=scan[d]||null;
    return Object.assign({date:d,
      rideMileage:(c&&c.km>0)?c.km.toFixed(1):"0",
      ridingTimeDayUnitMinute:(c&&c.dur>0)?String(Math.round(c.dur)):"0",
      maxSpeed:(c&&c.maxV>0)?String(Math.round(c.maxV)):"0",
      accelerationTimesDay:"0",brakesTimesDay:"0",bendingTimesDay:"0"},extra||{});
  };
  const records=[
    {date:cur+"."+p(3),rideMileage:"12.4",ridingTimeDayUnitMinute:"46",maxSpeed:"58",accelerationTimesDay:"1",brakesTimesDay:"0",bendingTimesDay:"0"},
    {date:cur+"."+p(5),rideMileage:"8.8",ridingTimeDayUnitMinute:"31",maxSpeed:"52",accelerationTimesDay:"0",brakesTimesDay:"1",bendingTimesDay:"4"},
    mk(cur+"."+p(8)),
    mk(cur+"."+p(10),{accelerationTimesDay:"1"})
  ];
  return{ok:true,month:cur,vinNo:"LB7JM1C10NA000001",vehicleName:"ZEEHO AE4",data:{rideMileageTotal:268.5,rideRecordList:records}};
}
const DEMO_DATA=[
{userName:"阿泽",userId:"2025100912345678",score:12880,signedToday:true,continueDays:42,todayScore:12,signCount:36,tokenValid:true,last7:[{date:"09-04",signed:true,isToday:false},{date:"09-05",signed:true,isToday:false},{date:"09-06",signed:true,isToday:false},{date:"09-07",signed:true,isToday:false},{date:"09-08",signed:true,isToday:false},{date:"09-09",signed:true,isToday:false},{date:"09-10",signed:true,isToday:true}],vehicle:{hasVehicle:true,vehicleName:"ZEEHO AE4",vinNo:"LB7JM1C10NA000001",batteryPercent:76,residualRangeKm:63,rangeEstimated:false,chargeState:"未充电",voltage:84.5,current:0,batteryTemp:26,frontPressure:"2.35bar",rearPressure:"2.40bar",frontTemp:"31°C",rearTemp:"32°C",todayDistance:12.6,todayDuration:34,todayMaxSpeed:56,lastRideMileage:8.2,totalMileage:27105.2,yesterdayDistance:88.4,online:"1",powerStatus:"0",lockState:"1",cushionState:"0",address:"福建省宁德市蕉城区东侨开发区",locationTime:"08:12",longitude:119.5509,latitude:26.6654,serviceEndDate:"2027-03-18"}},
{userName:"小满",userId:"2026010111223344",score:520,signedToday:false,continueDays:3,todayScore:0,signCount:9,tokenValid:false,last7:[{date:"09-04",signed:true,isToday:false},{date:"09-05",signed:false,isToday:false},{date:"09-06",signed:false,isToday:false},{date:"09-07",signed:true,isToday:false},{date:"09-08",signed:true,isToday:false},{date:"09-09",signed:true,isToday:false},{date:"09-10",signed:false,isToday:true}],vehicle:{hasVehicle:true,vehicleName:"极核 AE6",vinNo:"LB7JM1C10NA000002",batteryPercent:23,residualRangeKm:20,rangeEstimated:true,chargeState:"充电中",voltage:86.2,current:5.4,batteryTemp:31,totalMileage:0,yesterdayDistance:0,currentVin:"LB7JM1C10NA000002",vehicles:[{name:"极核 AE6",vinNo:"LB7JM1C10NA000002"},{name:"AE5iProMax",vinNo:"LB7JM1C10NA000003"}],frontPressure:"2.10bar",rearPressure:"",frontTemp:"",rearTemp:"",todayDistance:0,todayDuration:0,todayMaxSpeed:0,lastRideMileage:0,online:"0",powerStatus:"1",lockState:"0",cushionState:"1",address:"",locationTime:"",longitude:"",latitude:"",serviceEndDate:""}},
{userName:"lu小号",userId:"20260925000941283",score:115,signedToday:true,continueDays:4,todayScore:4,signCount:4,tokenValid:true,last7:[{date:"09-04",signed:true,isToday:false},{date:"09-05",signed:true,isToday:false},{date:"09-06",signed:true,isToday:false},{date:"09-07",signed:true,isToday:false},{date:"09-08",signed:true,isToday:false},{date:"09-09",signed:true,isToday:false},{date:"09-10",signed:true,isToday:true}],vehicle:{hasVehicle:false}}
];
const DEMO_LOGS=[
{time:"2026-09-10 07:00:12",type:"signin",userName:"阿泽",success:true,totalGain:12,signinScore:6,blindBoxScore:6,interactScore:0,continueDays:42,steps:["签到成功 +6","盲盒获得 +6 (积分)","盲盒未解锁(36/30)"]},
{time:"2026-09-10 07:00:15",type:"signin",userName:"小满",success:false,error:"Token已过期",steps:["签到失败: 请先登录"]},
{time:"2026-09-09 22:31:05",type:"vehicle",userName:"阿泽",success:true,actionText:"云端开锁",message:"云端开锁指令已下发",steps:[]}
];

/* ================= 刷新 & 初始化 ================= */
let loading=false;
// 入场闪屏：页面可交互（骨架屏已渲染）即撤下，不再等网络数据；数据到达后再填充
function hideSplash(){const s=document.getElementById("splash");if(!s)return;s.classList.add("out");setTimeout(()=>{if(s.parentNode)s.parentNode.removeChild(s)},450)}
async function refreshAll(silent){
  if(loading)return;loading=true;
  if(!silent){const el=document.getElementById("pageHome");if(!STATE.data.length)el.innerHTML=skeletonHome()}
  hideSplash();
  const d=await Backend.getDashboard();
  loading=false;
  if(d&&d.ok){STATE.data=d.accounts||[];STATE.tsText=fmtTime(d.timestamp||new Date().toISOString());STATE.proxy=isProxyMode();renderHome()}
  else{const hint=d&&d.raw&&d.raw.error?networkHint(d.raw):"";const el=document.getElementById("pageHome");el.innerHTML='<div class="empty"><h3>数据加载失败</h3><p>'+(hint||esc((d&&d.error)||"网络异常，请检查网络连接"))+'</p><div class="btn-row" style="justify-content:center"><button class="btn primary" onclick="refreshAll()">重试</button><button class="btn" onclick="switchTab(\'cfg\')">检查设置</button></div></div>'}
}
/* ================= v2.14.9 积分页 ================= */
let PT={accIdx:0,month:"",monthSetDay:""};
function ptAccounts(){return STATE.data&&STATE.data.length?STATE.data:(STATE.panelAccounts||[]).map(a=>({userName:a.userName||"账号",userId:a.userId||""}))}
function accChipsHtml(prefix){
  const list=ptAccounts();
  if(!list.length)return"";
  const cur=prefix==="pt"?PT.accIdx:(prefix==="rt"?RT.accIdx:VH.accIdx);
  return '<div class="acc-chips">'+list.map((a,i)=>'<button class="acc-chip '+(i===cur?'on':'')+'" onclick="pickAcc(\''+prefix+'\','+i+')">'+esc(a.userName||("账号"+(i+1)))+'</button>').join("")+'</div>';
}
function pickAcc(prefix,i){if(prefix==="pt"){PT.accIdx=i;renderPoints()}else if(prefix==="rt"){RT.accIdx=i;RT.tracks=null;RT.tracksAt="";RT.tracksRides=0;RT.tracksDays=0;RT.scanErr="";RT.vin="";renderRidePage()}else{VH.accIdx=i;VH.vin="";renderVehiclePage()}}
async function renderPoints(){
  const el=document.getElementById("pagePoints");if(!el)return;
  const list=ptAccounts();
  if(!list.length){el.innerHTML='<div class="empty"><h3>暂无账号</h3><p>请先在首页加载数据或在设置页添加账号</p></div>';return}
  if(PT.accIdx>=list.length)PT.accIdx=0;
  const acc=list[PT.accIdx];
  if(!acc.userId){el.innerHTML=accChipsHtml("pt")+'<div class="empty"><h3>该账号缺少用户ID</h3><p>请到设置页补全用户ID</p></div>';return}
  el.innerHTML=accChipsHtml("pt")+'<div class="empty" style="padding:40px 20px"><p style="color:var(--txt3)">加载积分数据中…</p></div>';
  // v2.14.20 日历跨月修正：面板常驻时 PT.month 可能滞留上月。跨到新月份（今天不是设置该月份那天）后自动回到当前月，
  // 避免 10月1号 时日历仍停在 9月30号（上月）显示不准确。
  const _now=new Date();
  const _curM=_now.getFullYear()+"-"+String(_now.getMonth()+1).padStart(2,"0");
  const _tdy=_now.getFullYear()+"-"+String(_now.getMonth()+1).padStart(2,"0")+"-"+String(_now.getDate()).padStart(2,"0");
  if(PT.month&&PT.monthSetDay&&PT.monthSetDay!==_tdy&&PT.month<_curM){PT.month="";PT.monthSetDay="";}
  const month=PT.month||_curM;
  const [it,cal,cnt] = await Promise.all([
    Backend.integral(acc.userId,1),
    Backend.supplement("month",acc.userId,{month:month}),
    Backend.supplement("count",acc.userId,{})
  ]);
  let html=accChipsHtml("pt");
  // 总览（v2.14.20 兼容 data 为纯数字或对象两种返回）
  const total=(it&&it.total!=null)?((typeof it.total==="number"||(typeof it.total==="string"&&it.total!==""))?String(it.total):deepPick(it.total,["integralTotal","totalIntegral","score","integral","total"],4)):"";
  const cardNum=(cnt&&cnt.data!=null)?((typeof cnt.data==="number"||(typeof cnt.data==="string"&&cnt.data!==""))?String(cnt.data):deepPick(cnt.data,["count","cardNum","cardCount","number","num","signCount","signSupplementCount","reissueCardNum","supplementCardNum","cardTotal","total"],4)):"";
  html+='<div class="pt-grid">'
    +'<div class="pt-cell"><div class="lb">当前总积分</div><div class="vl num" style="color:var(--brand)">'+esc(total||"--")+'</div></div>'
    +'<div class="pt-cell"><div class="lb">补签卡</div><div class="vl num">'+esc(cardNum||"--")+'</div><div class="sub"><button class="btn sm" style="margin-top:4px" onclick="supGain()">积分兑换补签卡</button></div></div>'
    +'</div>';
  // 盲盒进度（v2.14.14 起由首页迁移至此）
  const cont=Number(acc.continueDays||0);
  const bDay=cont===0?0:((cont-1)%30)+1;const bRound=cont===0?0:Math.ceil(cont/30);const bPct=Math.round((bDay/30)*100);
  html+='<div class="blind" style="margin:0 0 12px"><div class="blind-top"><span>盲盒进度（第'+bRound+'轮）</span><span class="r num">'+bDay+' / 30 · '+bPct+'% · 连签 '+cont+' 天</span></div><div class="blind-bar"><div class="blind-fill" style="width:'+bPct+'%"></div></div></div>';
  // 签到日历
  html+='<div class="panel-card"><div class="pc-head"><h4>'+I.check+'签到日历 · '+esc(month)+'</h4><button class="btn sm" onclick="ptMonthShift(-1)">上月</button></div>';
  const days=(cal&&cal.data&&cal.data.nowSignDetailVos)||[];
  if(days.length){
    html+=calHtml(days,month,acc.userId);
  }else{
    html+='<div style="color:var(--txt3);font-size:12px;padding:8px 0">'+(cal&&cal.message?esc(cal.message):"日历加载失败（可能限流，稍后再试）")+'</div>';
  }
  html+='</div>';
  // v2.14.21 删除积分流水（积分详情）区块
  html+='<div class="foot">积分数据来自极核实时 API · 补签限 30 天内漏签，每次消耗 1 张补签卡</div>';
  el.innerHTML=html;
}
function calHtml(days,month,userId){
  const ym=month.split("-");const y=Number(ym[0]),m=Number(ym[1]);
  const first=new Date(y,m-1,1).getDay();
  const dim=new Date(y,m,0).getDate();
  const today=new Date();const tStr=today.getFullYear()+"-"+String(today.getMonth()+1).padStart(2,"0")+"-"+String(today.getDate()).padStart(2,"0");
  let h='<div class="cal-grid">';
  ["日","一","二","三","四","五","六"].forEach(w=>{h+='<div class="cal-wd">'+w+'</div>'});
  for(let i=0;i<first;i++)h+='<div class="cal-d blank"></div>';
  for(let d=1;d<=dim;d++){
    const ds=month+"-"+String(d).padStart(2,"0");
    const entry=days.find(x=>x.createDate===ds);
    const signed=entry&&(entry.signStatue==3||entry.signStatue==5||entry.signStatue==0);
    const isToday=ds===tStr;
    const future=ds>tStr;
    let cls="cal-d"+(signed?" signed":(future?" future":(entry?" miss":"")));
    if(isToday)cls+=" today";
    const clickable=!signed&&!future&&entry;
    h+='<div class="'+cls+'" '+(clickable?'style="cursor:pointer" onclick="supConsume(\''+ds+'\',\''+esc(userId)+'\')"':'')+'>'
      +'<span>'+d+'</span>'
      +'<span class="dot">'+(signed?"✓":(future?"":(entry?"漏":"")))+'</span>'
      +'</div>';
  }
  h+='</div>';
  h+='<div class="hint" style="margin-top:10px">点击「漏」日期使用补签卡补签（需先有补签卡）</div>';
  return h;
}
function ptMonthShift(dir){
  const cur=PT.month||new Date().getFullYear()+"-"+String(new Date().getMonth()+1).padStart(2,"0");
  const ym=cur.split("-");let y=Number(ym[0]),m=Number(ym[1])+dir;
  if(m<1){m=12;y--}if(m>12){m=1;y++}
  PT.month=y+"-"+String(m).padStart(2,"0");
  // 记录设置该月份的当天，跨月后 renderPoints 据此把滞留的上月自动复位到当前月
  const d=new Date();
  PT.monthSetDay=d.getFullYear()+"-"+String(d.getMonth()+1).padStart(2,"0")+"-"+String(d.getDate()).padStart(2,"0");
  renderPoints();
}
async function supConsume(date,userId){
  confirmDialog("积分补签","使用 1 张补签卡补签 "+date+" ？",async function(){
    toast("补签中…","info");
    const d=await Backend.supplement("consume",userId,{dateTime:date});
    if(d&&d.ok){toast("补签成功","ok");renderPoints()}
    else toast("补签失败："+((d&&(d.message||d.error))||"未知"),"err");
  },"确认补签");
}
async function supGain(){
  const list=ptAccounts();const acc=list[PT.accIdx];if(!acc||!acc.userId)return;
  confirmDialog("兑换补签卡","使用积分兑换 1 张补签卡？",async function(){
    toast("兑换中…","info");
    const d=await Backend.supplement("gain",acc.userId,{});
    if(d&&d.ok){toast("兑换成功","ok");renderPoints()}
    else toast("兑换失败："+((d&&(d.message||d.error))||"未知"),"err");
  },"确认兑换");
}

/* ================= v2.16.0 骑行页（隐藏骑行数据：极速/急加速/急刹/压弯） ================= */
let RT={accIdx:0,month:"",monthSetDay:"",tracks:null,tracksAt:"",tracksRides:0,tracksDays:0,scanning:false,scanErr:"",vin:"",dayCache:[]};
function rtCurMonth(){const n=new Date();return n.getFullYear()+"."+String(n.getMonth()+1).padStart(2,"0")}
function rtMonthShift(dir){
  const cur=RT.month||rtCurMonth();
  const ym=cur.split(".");let y=Number(ym[0]),m=Number(ym[1])+dir;
  if(m<1){m=12;y--}if(m>12){m=1;y++}
  RT.month=y+"."+String(m).padStart(2,"0");
  const d=new Date();RT.monthSetDay=d.getFullYear()+"."+String(d.getMonth()+1).padStart(2,"0")+"."+String(d.getDate()).padStart(2,"0");
  renderRidePage();
}
function rtWeekday(dk){
  try{const p=String(dk||"").split(".");const d=new Date(Number(p[0]),Number(p[1])-1,Number(p[2]));if(isNaN(d.getTime()))return"";return " 周"+["日","一","二","三","四","五","六"][d.getDay()]}catch(e){return""}
}
function rtDayHtml(d,i){
  const md=String(d.dk||"").split(".");
  const label=md.length===3?(md[1]+"."+md[2]):String(d.dk||"");
  const kmTxt=d.km>0?(d.km>=100?d.km.toFixed(0):d.km.toFixed(1))+"km":"";
  const durTxt=d.dur>0?(fmtMin(d.dur)||(Math.round(d.dur)+"min")):"";
  const click=d.rides.length?' style="cursor:pointer" onclick="rtRideSheet('+i+')"':"";
  return '<div class="rt-day"'+click+'>'
    +'<div class="rt-top"><span class="rt-date">'+esc(label)+'<span class="wd">'+esc(rtWeekday(d.dk))+'</span></span><span class="rt-km num">'+esc([kmTxt,durTxt].filter(Boolean).join(" · ")||"--")+'</span></div>'
    +'<div class="rt-chips">'
    +'<span class="rt-chip">极速<b class="num">'+(d.maxV>0?Math.round(d.maxV):"--")+'</b></span>'
    +'<span class="rt-chip">急加速<b class="num">'+d.accel+'</b></span>'
    +'<span class="rt-chip'+(d.cal?' cal':'')+'">急刹<b class="num">'+d.brakes+'</b></span>'
    +'<span class="rt-chip'+(d.cal?' cal':'')+'">压弯<b class="num">'+d.bends+'</b></span>'
    +(d.rides.length?'<span class="rt-chip link">轨迹 '+d.rides.length+' 趟 ›</span>':"")
    +'</div></div>';
}
function rtRideSheet(i){
  const d=(RT.dayCache||[])[i];
  if(!d||!d.rides||!d.rides.length)return;
  const html=d.rides.map(r=>{
    const start=r.t0str?r.t0str.slice(11,16):(r.t0?fmtTime(new Date(r.t0).toISOString()).slice(11,16):"--:--");
    const end=r.t1str?r.t1str.slice(11,16):"";
    const km=r.srvKm>0?r.srvKm:r.km;
    const dur=r.srvDur>0?r.srvDur:r.dur;
    const avg=dur>0?(km/(dur/60)):0;
    return '<div class="flow-item"><div style="flex:1;min-width:0"><div class="nm">'+esc(start)+(end?(' → '+esc(end)):"")+' 骑行</div>'
      +(r.addr?'<div class="tm" style="white-space:normal">'+esc(r.addr)+'</div>':"")
      +'<div class="tm">'+esc(km.toFixed(1))+'km · '+esc(fmtMin(dur)||(Math.round(dur)+"min"))+' · 均速 '+Math.round(avg)+'km/h · 极速 '+Math.round(r.maxV)+'</div>'
      +'<div class="tm">急加速 '+r.srvAccel+' · 急刹 '+r.brakes+' · 压弯 '+r.bends+'（隐藏算法）</div></div>'
      +(r.thumb?'<img src="'+esc(r.thumb)+'" style="width:52px;height:52px;border-radius:10px;object-fit:cover;margin-left:8px;flex-shrink:0" onerror="this.remove()">':"")
      +'</div>';
  }).join("");
  openSheet((d.dk||"")+" 骑行明细",I.map,html+'<div class="hint" style="margin-top:10px">里程/时长/极速/急加速为服务端真值（急加速=服务端计次）；急刹/压弯为隐藏算法计数（移植 SpeedHunter，双窗口合并后 ×2.5 标定）</div>');
}
async function rtScan(){
  if(RT.scanning)return;
  const list=ptAccounts();const acc=list[RT.accIdx]||{};
  if(!acc.userId){toast("该账号缺少用户ID","err");return}
  const month=RT.month||rtCurMonth();
  RT.scanning=true;RT.scanErr="";renderRidePage();
  toast("正在拉取 "+month+" 轨迹并计算隐藏数据…","info");
  let allDays=[],rides=0,err="";
  try{
    for(let page=1;page<=15;page++){
      const r=await Backend.rideTrack(acc.userId,RT.vin||"",page,20,month);
      if(!r||!r.ok){err=(r&&(r.error||r.message))||"接口无响应";break}
      if(r.vinNo&&!RT.vin)RT.vin=r.vinNo;
      const days=Array.isArray(r.days)?r.days:[];
      let cnt=0;
      for(const dd of days)if(dd&&Array.isArray(dd.historyList))cnt+=dd.historyList.length;
      allDays=allDays.concat(days);rides+=cnt;
      if(cnt===0)break;
    }
  }catch(e){err=String(e)}
  if(allDays.length){
    RT.tracks=rideDayScan(allDays);
    RT.tracksAt=fmtTime(new Date().toISOString());RT.tracksRides=rides;
    let nDays=0;for(const k in RT.tracks)if(RT.tracks[k]&&RT.tracks[k].rides&&RT.tracks[k].rides.length)nDays++;
    RT.tracksDays=nDays;
    if(!nDays)RT.scanErr="接口已连通，但未返回轨迹数据（该车暂无历史轨迹记录）";
  }else{
    RT.scanErr=err||"未取到轨迹数据（该车可能没有历史轨迹记录）";
  }
  RT.scanning=false;
  renderRidePage();
  if(RT.scanErr)toast(RT.scanErr,"err");else toast("轨迹扫描完成："+rides+" 趟行程","ok");
}
async function renderRidePage(){
  const el=document.getElementById("pageRide");if(!el)return;
  const list=ptAccounts();
  if(!list.length){el.innerHTML='<div class="empty"><h3>暂无账号</h3><p>请先在首页加载数据或在设置页添加账号</p></div>';return}
  if(RT.accIdx>=list.length)RT.accIdx=0;
  const acc=list[RT.accIdx];
  if(!acc.userId){el.innerHTML=accChipsHtml("rt")+'<div class="empty"><h3>该账号缺少用户ID</h3><p>请到设置页补全用户ID</p></div>';return}
  const _now=new Date();
  const _curM=rtCurMonth();
  const _tdy=_now.getFullYear()+"."+String(_now.getMonth()+1).padStart(2,"0")+"."+String(_now.getDate()).padStart(2,"0");
  if(RT.month&&RT.monthSetDay&&RT.monthSetDay!==_tdy&&RT.month<_curM){RT.month="";RT.monthSetDay="";}
  const month=RT.month||_curM;
  el.innerHTML=accChipsHtml("rt")+'<div class="empty" style="padding:40px 20px"><p style="color:var(--txt3)">加载骑行数据中…</p></div>';
  const res=await Backend.rideMonth(acc.userId,month,RT.vin||"");
  if(res&&res.vinNo&&!RT.vin)RT.vin=res.vinNo;
  let html=accChipsHtml("rt");
  if(!res||!res.ok){
    el.innerHTML=html+'<div class="empty"><h3>骑行数据加载失败</h3><p>'+esc((res&&res.error)||"网络异常，请稍后重试")+'</p><div class="btn-row" style="justify-content:center"><button class="btn primary" onclick="renderRidePage()">重试</button></div></div>';
    return;
  }
  const records=(res.data&&Array.isArray(res.data.rideRecordList))?res.data.rideRecordList:[];
  const isCur=(month===_curM);
  // 合并轨迹计算结果：里程/极速服务端非0优先、为0补算；急刹/压弯按轨迹重算（服务端常年为0）
  const days=[];
  for(const rec of records){
    if(!rec||typeof rec!=="object")continue;
    const dk=rideNormDay(rec.date)||String(rec.date||"");
    const comp=(RT.tracks&&dk&&RT.tracks[dk])||null;
    const srvKm=rideNum(rec.rideMileage),srvDur=rideNum(rec.ridingTimeDayUnitMinute),srvMax=rideNum(rec.maxSpeed);
    days.push({
      dk:dk,
      km:srvKm>0?srvKm:(comp?comp.km:0),
      dur:srvDur>0?srvDur:(comp?comp.dur:0),
      maxV:srvMax>0?srvMax:(comp?comp.maxV:0),
      accel:rideNum(rec.accelerationTimesDay),
      brakes:comp?comp.brakes:rideNum(rec.brakesTimesDay),
      bends:comp?comp.bends:rideNum(rec.bendingTimesDay),
      cal:!!comp,
      rides:(comp&&comp.rides)||[]
    });
  }
  days.sort((a,b)=>String(b.dk).localeCompare(String(a.dk),"zh"));
  const visible=days.filter(d=>d.km>0||d.dur>0||d.maxV>0||d.accel>0||d.brakes>0||d.bends>0);
  RT.dayCache=visible;
  let sumKm=0,sumDur=0,maxV=0,sumA=0,sumB=0,sumD=0;
  for(const d of visible){sumKm+=d.km;sumDur+=d.dur;if(d.maxV>maxV)maxV=d.maxV;sumA+=d.accel;sumB+=d.brakes;sumD+=d.bends}
  const durTxt=sumDur>=60?(Math.floor(sumDur/60)+"h"+String(Math.round(sumDur%60)).padStart(2,"0")+"m"):(sumDur>0?(Math.round(sumDur)+"min"):"0");
  html+='<div class="panel-card"><div class="pc-head"><h4>'+I.map+'隐藏骑行数据 · '+esc(month)+'</h4><span style="display:flex;gap:6px"><button class="btn sm" onclick="rtMonthShift(-1)">上月</button><button class="btn sm" onclick="rtMonthShift(1)">下月</button></span></div>'
    +'<div class="rt-grid">'
    +'<div class="rt-cell"><div class="lb">里程</div><div class="vl num">'+esc(sumKm>0?sumKm.toFixed(1):"0")+'<span class="u">km</span></div></div>'
    +'<div class="rt-cell"><div class="lb">时长</div><div class="vl num">'+esc(durTxt)+'</div></div>'
    +'<div class="rt-cell"><div class="lb">极速</div><div class="vl num">'+esc(maxV>0?String(Math.round(maxV)):"--")+'<span class="u">km/h</span></div></div>'
    +'</div>'
    +'<div class="rt-grid3">'
    +'<div class="rt-cell"><div class="lb">急加速</div><div class="vl num brand">'+sumA+'</div></div>'
    +'<div class="rt-cell"><div class="lb">急刹</div><div class="vl num brand">'+sumB+'</div></div>'
    +'<div class="rt-cell"><div class="lb">压弯</div><div class="vl num brand">'+sumD+'</div></div>'
    +'</div>'
    +'<div class="hint">官方 App 把这些字段藏了起来（车型能力位控制）。急加速来自服务端；急刹/压弯可点「扫描轨迹」按骑行轨迹重算。</div></div>';
  html+='<div class="panel-card"><div class="pc-head"><h4>'+I.scooter+'每日记录</h4><span style="display:flex;gap:6px">'
    +(RT.scanning?'<button class="btn sm" style="opacity:.6">扫描中…</button>':'<button class="btn sm primary" onclick="rtScan()">扫描轨迹</button>')
    +'</span></div>';
  if(visible.length){
    html+=visible.map((d,i)=>rtDayHtml(d,i)).join("");
  }else{
    html+='<div style="color:var(--txt3);font-size:12px;padding:8px 0">该月暂无骑行记录（换个月份或确认账号已绑定车辆）</div>';
  }
  html+='<div class="hint">轨迹按所选月份查询（每次 20 趟自动翻页，最多 15 页）</div>';
  if(RT.tracksAt)html+='<div class="hint">上次扫描：'+esc(RT.tracksAt)+' · '+Number(RT.tracksRides||0)+' 趟 / '+Number(RT.tracksDays||0)+' 天</div>';
  if(RT.scanErr)html+='<div class="hint" style="color:var(--err)">'+esc(RT.scanErr)+'</div>';
  html+='</div>';
  html+='<div class="foot">数据来源：极核 myRideInfo / ridetrack_v2 · 压弯/急刹算法移植自 Zeeho SpeedHunter（AGPL-3.0），仅供学习研究</div>';
  el.innerHTML=html;
}

/* ================= v2.14.9 车辆页（监控 + 车控扩展 + 信息中心） ================= */
let VH={accIdx:0,vin:"",cp:"",lockType:"1",bs:null};
// v2.16.6 每车独立电池设置：存储结构 { "<vin>": {ah,vFull,vEmpty} }；旧版扁平格式在读取/保存时迁移到传入的 vin
function rideBattCfg(vin){try{const s=JSON.parse(localStorage.getItem("zh_batt_cfg")||"{}")||{};if(typeof s.ah!=="undefined"||typeof s.vFull!=="undefined"||typeof s.vEmpty!=="undefined"){const m={};if(vin)m[vin]={ah:Number(s.ah||0),vFull:Number(s.vFull||0),vEmpty:Number(s.vEmpty||0)};localStorage.setItem("zh_batt_cfg",JSON.stringify(m));return m[vin]||{};}return (vin&&s[vin])||{};}catch(e){return{}}}
function saveBattCfg(){
  const vin=VH.vin||"";if(!vin){toast("请先选择车辆再保存","err");return;}
  const ah=Number((document.getElementById("vh_batt_ah")||{}).value||0);
  const vFull=Number((document.getElementById("vh_batt_vfull")||{}).value||0);
  let s;try{s=JSON.parse(localStorage.getItem("zh_batt_cfg")||"{}")||{}}catch(e){s={}}
  const map=(typeof s.ah!=="undefined"||typeof s.vFull!=="undefined"||typeof s.vEmpty!=="undefined")?{}:s;
  const cur=map[vin]||{};
  map[vin]={ah:ah>0?ah:0,vFull:vFull>0?vFull:0,vEmpty:cur.vEmpty||0};
  localStorage.setItem("zh_batt_cfg",JSON.stringify(map));
  toast("电池设置已保存（绑定当前车辆）","ok");renderVehiclePage();
}
async function renderVehiclePage(){
  const el=document.getElementById("pageVehicle");if(!el)return;
  const list=ptAccounts();
  if(!list.length){el.innerHTML='<div class="empty"><h3>暂无账号</h3><p>请先在首页加载数据或在设置页添加账号</p></div>';return}
  if(VH.accIdx>=list.length)VH.accIdx=0;
  const acc=list[VH.accIdx];
  if(!acc.userId){el.innerHTML=accChipsHtml("vh")+'<div class="empty"><h3>该账号缺少用户ID</h3></div>';return}
  el.innerHTML=accChipsHtml("vh")+'<div class="empty" style="padding:40px 20px"><p style="color:var(--txt3)">加载车辆数据中…</p></div>';
  let mon=await Backend.vehicleMonitor(acc.userId,"");
  const vehList=(mon&&Array.isArray(mon.vehicles))?mon.vehicles:[];
  if(VH.vin&&mon&&mon.ok&&mon.snapshot&&mon.snapshot.vin!==VH.vin){
    const mon2=await Backend.vehicleMonitor(acc.userId,VH.vin);
    if(mon2&&mon2.ok){mon2.vehicles=vehList;mon=mon2}
  }
  const [opts,info,bs]=await Promise.all([
    Backend.vehicleControlExt({action:"options",userId:acc.userId,vin:VH.vin||""}),
    Backend.infoCenter(acc.userId,VH.vin||""),
    Backend.batteryState(acc.userId,VH.vin||"")
  ]);
  VH.bs=(bs&&bs.ok)?bs:null;
  let html=accChipsHtml("vh");
  // 当前展示车辆（v2.16.6：电池设置按此 vin 独立保存；单车账号 VH.vin 恒为空，需回填）
  const curVin=VH.vin||(mon&&mon.snapshot?mon.snapshot.vin:(vehList[0]||{}).vinNo)||"";
  VH.vin=curVin;
  // 车辆选择（多车）
  if(vehList.length>1){
    html+='<div class="opt-row">'+vehList.map(v=>'<button class="opt-chip '+(curVin===v.vinNo?'on':'')+'" onclick="VH.vin=\''+esc(v.vinNo)+'\';renderVehiclePage()">'+esc(v.vehicleType||v.vehicleName||v.vinNo)+'</button>').join("")+'</div>';
  }
  // 状态监控卡
  html+='<div class="panel-card"><div class="pc-head"><h4>'+I.car+'车辆状态</h4><span style="display:flex;gap:6px"><button class="btn sm" onclick="showVehicleDetail('+VH.accIdx+')">详情</button><button class="btn sm" onclick="renderVehiclePage()">刷新</button></span></div>';
  if(mon&&mon.ok&&mon.snapshot){
    const sn=mon.snapshot;
    const socCol=sn.soc<=20?"var(--err)":sn.soc<=50?"var(--warn)":"var(--ok)";
    html+='<div class="mon-row"><span class="k">剩余电量</span><span class="v num" style="color:'+socCol+'">'+(sn.soc!=null?sn.soc+"%":"--")+'</span></div>';
    html+='<div class="mon-row"><span class="k">剩余续航</span><span class="v num">'+(sn.range!=null?sn.range+" km":"--")+'</span></div>';
    html+='<div class="mon-row"><span class="k">龙头锁</span><span class="v">'+(sn.headLock==="1"?"已锁":"未锁")+'</span></div>';
    html+='<div class="mon-row"><span class="k">在线状态</span><span class="v" style="color:'+(sn.offline?"var(--err)":"var(--ok)")+'">'+(sn.offline?"离线（>30分钟未上报）":"在线")+'</span></div>';
    html+='<div class="mon-row"><span class="k">最后上报</span><span class="v" style="font-size:12px;color:var(--txt2)">'+esc(sn.refreshTime||"--")+'</span></div>';
  }else{
    html+='<div style="color:var(--txt3);font-size:12px">'+esc((mon&&(mon.error||mon.message))||"快照获取失败")+'</div>';
  }
  html+='</div>';
  // 车辆控制卡（从首页迁移过来）
  html+='<div class="panel-card"><div class="pc-head"><h4>'+I.zap+'车辆控制</h4></div>'
    +'<div class="ctrl-grid">'
    +'<button class="ctrl-btn" data-act="find" onclick="ctrlAct('+VH.accIdx+',\'find\',this)">'+I.bell+'寻车</button>'
    +'<button class="ctrl-btn" data-act="loudFind" onclick="ctrlAct('+VH.accIdx+',\'loudFind\',this)">'+I.vol+'鸣笛</button>'
    +'<button class="ctrl-btn" data-act="cushion" onclick="ctrlAct('+VH.accIdx+',\'cushion\',this)">'+I.seat+'坐垫</button>'
    +'<button class="ctrl-btn unlock" data-act="unlock" onclick="ctrlAct('+VH.accIdx+',\'unlock\',this)">'+I.unlock+'开锁</button>'
    +'<button class="ctrl-btn lock" data-act="lock" onclick="ctrlAct('+VH.accIdx+',\'lock\',this)">'+I.lock+'关锁</button>'
    +'</div></div>';
  // 车控扩展卡
  html+='<div class="panel-card"><div class="pc-head"><h4>'+I.zap+'车控扩展</h4></div>';
  const cps=(opts&&Array.isArray(opts.chargePower))?opts.chargePower:[];
  if(cps.length){
    html+='<div style="font-size:12px;font-weight:700;color:var(--txt2);margin-bottom:4px">充电功率（W）</div><div class="opt-row">'
      +cps.map(o=>'<button class="opt-chip '+(VH.cp===o.key?'on':'')+'" onclick="VH.cp=\''+esc(o.key)+'\';renderVehiclePage()">'+(o.key==="1200"?"无限制":esc(o.key))+'</button>').join("")
      +'<button class="btn sm primary" onclick="extSet(\'chargePower\')">设置</button></div>';
  }
  // v2.16.5 充电剩余时间（充电中且已设容量才显示）+ 电池设置（v2.16.6 按 vin 独立）
  const bc=rideBattCfg(curVin);
  if(VH.bs&&VH.bs.charging&&Number(bc.ah)>0&&VH.bs.soc>0&&VH.bs.soc<100&&VH.bs.current>0.5){
    const remainMin=Math.max(1,Math.round(Number(bc.ah)*(100-VH.bs.soc)/100/VH.bs.current*60));
    const hh=Math.floor(remainMin/60),mm=remainMin%60;
    const offTxt=(VH.bs.fullChargeTimeSecond>0)?(" · 官方约 "+Math.round(VH.bs.fullChargeTimeSecond/60)+" 分"):"";
    html+='<div class="mon-row"><span class="k">⏱ 充电剩余</span><span class="v num" style="color:var(--brand)">约 '+((hh>0?hh+" 时 ":"")+mm+" 分")+'</span></div>'
      +'<div class="hint" style="margin-top:2px">估算 '+VH.bs.current.toFixed(1)+'A · '+VH.bs.soc+'% → '+(bc.vFull>0?bc.vFull+"V":"充满")+offTxt+'</div>';
  }
  html+='<div style="display:flex;gap:6px;align-items:center;margin-top:8px;flex-wrap:wrap"><span style="font-size:12px;color:var(--txt2)">电池设置</span>'
    +'<input id="vh_batt_ah" type="number" inputmode="decimal" placeholder="容量 Ah" value="'+(bc.ah||"")+'" style="width:86px;background:var(--card2);border:1px solid var(--line);border-radius:8px;color:var(--txt);padding:6px 8px;font-size:12px">'
    +'<input id="vh_batt_vfull" type="number" inputmode="decimal" placeholder="满电 V" value="'+(bc.vFull||"")+'" style="width:86px;background:var(--card2);border:1px solid var(--line);border-radius:8px;color:var(--txt);padding:6px 8px;font-size:12px">'
    +'<button class="btn sm" onclick="saveBattCfg()">保存</button></div>'
    +'<div class="hint" style="margin-top:4px">设置容量后，充电中自动估算「充电剩余」（容量×(100−电量%)/100÷充电电流）；每车独立保存，未设置不显示</div>';
  // v2.14.21 删除限速档位设置
  html+='</div>';
  // 信息中心卡
  html+='<div class="panel-card"><div class="pc-head"><h4>'+I.bell+'信息中心</h4></div>';
  if(info&&info.ok){
    const un=info.unread!=null?deepPick(info.unread,["total","count","unReadCount","num"],3):"";
    if(un!=="")html+='<div class="mon-row"><span class="k">未读消息</span><span class="v num" style="color:var(--brand)">'+esc(un)+'</span></div>';
    const prizes=(info.prizeRecords&&(info.prizeRecords.records||info.prizeRecords.list||info.prizeRecords))||[];
    if(Array.isArray(prizes)&&prizes.length){
      html+='<div style="font-size:12px;font-weight:700;color:var(--txt2);margin:8px 0 4px">盲盒/中奖记录</div>';
      html+=prizes.slice(0,5).map(p=>'<div class="flow-item"><div><div class="nm">'+esc(p.prizesName||p.name||"奖品")+'</div><div class="tm">'+esc(p.createTime||p.createDate||"")+'</div></div><div class="sc plus" style="font-size:12px">'+esc(p.integral?("+"+p.integral):"")+'</div></div>').join("");
    }
    const coupons=(info.coupons&&(info.coupons.records||info.coupons.list||info.coupons))||[];
    if(Array.isArray(coupons)&&coupons.length)html+='<div class="mon-row"><span class="k">优惠券</span><span class="v num">'+coupons.length+' 张</span></div>';
    if(info.ota!=null)html+='<div class="mon-row"><span class="k">OTA 升级</span><span class="v" style="font-size:12px">'+(Array.isArray(info.ota)&&info.ota.length?"有新版本":"已是最新")+'</span></div>';
  }else{
    html+='<div style="color:var(--txt3);font-size:12px">'+esc((info&&(info.error||info.message))||"信息中心加载失败")+'</div>';
  }
  html+='</div>';
  html+='<div class="foot">车控扩展指令经云端下发，响应可能较慢</div>';
  el.innerHTML=html;
}

async function extSet(action){
  const list=ptAccounts();const acc=list[VH.accIdx];if(!acc||!acc.userId)return;
  const body={action:action,userId:acc.userId,vin:VH.vin||""};
  if(action==="chargePower"){if(!VH.cp){toast("请先选择充电功率","err");return}body.value=VH.cp}
  toast("指令下发中…","info");
  const d=await Backend.vehicleControlExt(body);
  toast((d&&d.message)||((d&&d.ok)?"指令已下发":"指令失败"),(d&&d.ok)?"ok":"err");
}

function init(){
  applyTheme();applyCustomBg();mountSigninFab();
  renderCfg();
  if(location.search.indexOf("demo")>=0){
    STATE.data=DEMO_DATA;STATE.tsText=fmtTime(new Date().toISOString());STATE.proxy=false;
    renderHome();hideSplash();return;
  }
  startAutoRefresh();refreshAll(false);
  // v2.15.6 版本检测：首屏渲染后静默检查一次（有新版本才提示）
  if(!isDemo())setTimeout(()=>checkVersion(false),1500);
  // 兜底：极端情况下请求长时间无响应，闪屏也不能一直挡住界面
  setTimeout(hideSplash,12000);
}
init();
</script>
<!--__JS5__-->
"; function __appDecodeUtf8(b64){ const bin = atob(b64); const out = []; let i = 0; while (i < bin.length) { const c1 = bin.charCodeAt(i++) & 0xff; if (c1 < 0x80) { out.push(String.fromCharCode(c1)); continue; } const c2 = bin.charCodeAt(i++) & 0xff; if ((c1 & 0xe0) === 0xc0) { out.push(String.fromCharCode(((c1 & 0x1f) << 6) | (c2 & 0x3f))); continue; } const c3 = bin.charCodeAt(i++) & 0xff; if ((c1 & 0xf0) === 0xe0) { out.push(String.fromCharCode(((c1 & 0x0f) << 12) | ((c2 & 0x3f) << 6) | (c3 & 0x3f))); continue; } const c4 = bin.charCodeAt(i++) & 0xff; const cp = ((c1 & 0x07) << 18) | ((c2 & 0x3f) << 12) | ((c3 & 0x3f) << 6) | (c4 & 0x3f); const u = cp - 0x10000; out.push(String.fromCharCode(0xD800 + (u >> 10), 0xDC00 + (u & 0x3ff))); } return out.join(""); } function __APP_HTML(){ return __appDecodeUtf8(__APP_HTML_B64); } // 批量执行签到：逐账号签到 + 写运行日志 + 每账号独立 Bark 推送 + 失败重试队列 + 汇总本地通知（v2.14.9） async function runSigninBatch(targets, cfg, opts) { opts = opts || {}; const results = []; for (const acc of targets) { const r = await runSigninForAccount(acc, cfg); results.push(r); // 写入日志 const _d = new Date(); const _ds = _d.getFullYear() + "-" + String(_d.getMonth()+1).padStart(2,"0") + "-" + String(_d.getDate()).padStart(2,"0"); addLog({ time: _d.toLocaleString("zh-CN", { hour12: false }), date: _ds, type: "signin", userName: r.userName, userId: r.userId, success: r.success, totalGain: r.totalGain, signinScore: r.signinScore, blindBoxScore: r.blindBoxScore, interactScore: r.interactScore, continueDays: r.continueDays, error: r.error, steps: r.steps }); // 每账号独立 Bark：仅签到成功且该账号填了 Bark Key 时推送 if (r.success && acc.barkKey && String(acc.barkKey).trim()) { try { const _bt = "极核签到成功 · " + (r.userName || ""); const _bScore = r.blindBoxScore || 0; const _bDay = (r.continueDays || 0) === 0 ? 0 : (((r.continueDays || 0) - 1) % 30) + 1; const _bRemain = 30 - _bDay; const _bbTxt = _bScore >= 10 ? "盲盒" + _bScore : "距盲盒" + _bRemain + "天"; const _bb = "今日获得 " + r.totalGain + " 分（签到" + r.signinScore + " / " + _bbTxt + " / 互动" + r.interactScore + "），连签 " + r.continueDays + " 天"; await barkPush(acc.barkKey, _bt, _bb); } catch(e) {} } } // v2.14.9 失败自动重试：记录失败账号队列，下次打开面板/触发签到时若已过间隔则自动补一轮 try { const failedIds = []; results.forEach((r, i) => { if (!r.success && targets[i]) failedIds.push(String(targets[i].userId || "")); }); const cleanIds = failedIds.filter(Boolean); if (cleanIds.length) { $.setdata(JSON.stringify({ time: Date.now(), userIds: cleanIds }), "zeeho_retry_queue"); console.log("[重试] " + cleanIds.length + " 个账号签到失败，已入延迟重试队列"); } else { $.setdata("", "zeeho_retry_queue"); } } catch(e) {} // v2.14.9 汇总通知（原生本地通知优先，回退全局 Bark） if (opts.notify !== false && results.length) { try { const okN = results.filter(r => r.success).length; const failN = results.length - okN; const gain = results.reduce((sum, r) => sum + (r.totalGain || 0), 0); const t = failN ? "极核签到部分失败" : "极核签到完成"; const b = results.length + " 个账号：" + okN + " 成功" + (failN ? " / " + failN + " 失败（稍后自动重试）" : "") + "，共 +" + gain + " 积分"; notifyPush(t, b, cfg); } catch(e) {} } return results; } // v2.14.9 失败重试队列检查：距入队已过间隔（默认2分钟）则自动重签一轮（打开面板补签模型） async function checkRetryQueue(cfg) { try { const raw = $.getdata("zeeho_retry_queue"); if (!raw) return null; const q = JSON.parse(raw); if (!q || !Array.isArray(q.userIds) || !q.userIds.length) return null; const delayMs = 2 * 60 * 1000; if (Date.now() - (Number(q.time) || 0) < delayMs) return null; $.setdata("", "zeeho_retry_queue"); const accounts = getAccounts(); const targets = accounts.filter(a => q.userIds.indexOf(String(a.userId)) >= 0); if (!targets.length) return null; console.log("[重试] 自动重试 " + targets.length + " 个失败账号"); return await runSigninBatch(targets, cfg, { notify: true }); } catch(e) { return null; } } // ========== v2.14.9 车辆快照（轻量：SOC/续航/龙头锁/离线判断） ========== async function fetchVehicleSnapshots(acc, cfg, vin) { try { const query = "vinNo=" + encodeURIComponent(vin); const res = await httpGet("https://tapi.zeehoev.com/v1.0/app/cfmotoserverapp/app/vehicles/properties/snapshots?" + query, appQueryGetHeaders(acc, query, cfg)); if (res.code != "10000" || !res.data) return null; const props = res.data.iotProperties || []; const pick = (id) => props.find(p => String(p.identify || "").toLowerCase() === id.toLowerCase()) || null; const socIt = pick("BMSSOC"), mileIt = pick("HMIRidableMile"), lockIt = pick("HeadLockState"); // 取全部属性中的最新时间戳判断在线（单一属性可能滞后，避免误判离线） let ts = 0; for (const p of props) { const t = Number(p.time) || 0; if (t > ts) ts = t; } return { vin: vin, soc: socIt ? Number(socIt.value) : null, range: mileIt ? Number(mileIt.value) : null, headLock: lockIt ? String(lockIt.value) : "", ts: ts, refreshTime: res.data.refreshTime || "", offline: ts > 0 ? (Date.now() - ts > 30 * 60 * 1000) : false }; } catch(e) { return null; } } // v2.14.13 监控离线判断：以官方在线状态（TBOX 网络连接状态）为准，而非属性上报时间戳。 // 修复：停放后 TBOX 休眠、属性停报，时间戳很快"过期"，按时间戳判断会在 30 分钟后误报离线（车辆其实正常）。 // - 官方状态在线 / 停放休眠（sleep/休眠）→ 不离线（停放是正常状态） // - 官方状态明确断开（offline/disconnect）→ 离线 // - 官方状态未知 → 回退属性时间戳但阈值放宽到 2 小时，宁可少报不误报 function isMonitorOffline(onlineStr, ts) { const s = String(onlineStr || "").toLowerCase().trim(); const onVals = ["1", "on", "online", "true", "在线", "已在线", "connected", "normal", "sleep", "休眠"]; const offVals = ["0", "off", "offline", "false", "离线", "未在线", "已离线", "disconnect", "disconnected"]; if (s) { if (onVals.includes(s)) return false; if (offVals.includes(s)) return true; } // 官方状态未知：回退属性时间戳，阈值放宽到 2 小时，避免停放误报 if (ts > 0) return (Date.now() - ts) > 120 * 60 * 1000; return false; } // v2.14.9 车辆监控引擎（打开面板补查模型）：充满/离线状态变化时本地通知，状态记录去重 async function checkVehicleMonitor(cfg) { if (!cfg.vehicleMonitor) return; try { const accounts = getAccounts(); if (!accounts.length) return; let state = {}; try { state = JSON.parse($.getdata("zeeho_vehmon_state") || "{}"); } catch(e) {} for (const acc of accounts) { try { const list = await fetchVehicleList(acc, cfg); if (!list || !list.length) continue; const veh = list[0]; const snap = await fetchVehicleSnapshots(acc, cfg, veh.vinNo); if (!snap) continue; // 官方在线状态（TBOX）：widgets 接口，取不到则空串，回退时间戳逻辑 let onlineStr = ""; try { const w = await fetchVehicleWidgets(acc, cfg, veh.vinNo); if (w) onlineStr = w.online || ""; } catch(e) {} const offline = isMonitorOffline(onlineStr, snap.ts); const key = String(acc.userId || "") + ":" + veh.vinNo; const prev = state[key] || {}; const name = (acc.userName || "") + " · " + (veh.name || veh.vehicleName || veh.vinNo); if (snap.soc >= 100 && prev.socFull !== true) { // 官方续航字段充满时常为 0/空，兜底按满电 150km 估算 const fullRange = snap.range || Math.round(snap.soc * 1.5); notifyPush("车辆已充满", name + " 电量 " + snap.soc + "%，续航 " + fullRange + " km", cfg); state[key] = Object.assign({}, prev, { socFull: true }); } else if (snap.soc !== null && snap.soc < 100 && prev.socFull === true) { state[key] = Object.assign({}, prev, { socFull: false }); } if (offline && prev.offline !== true) { notifyPush("车辆离线", name + " TBOX 网络断开（停放休眠不算离线）", cfg); state[key] = Object.assign({}, prev, { offline: true }); } else if (!offline && prev.offline === true) { state[key] = Object.assign({}, prev, { offline: false }); } } catch(e) {} } $.setdata(JSON.stringify(state), "zeeho_vehmon_state"); } catch(e) {} } // v2.14.9 通用：按 userId 找账号（找不到兜底第一个） function findAccByUserId(userId) { const accounts = getAccounts(); let acc = accounts.find(a => String(a.userId) === String(userId)); if (!acc && accounts.length) acc = accounts[0]; return acc || null; } // v2.14.9 通用：账号基础请求头 function accHeaders(acc, signH) { const h = { "Authorization": "Bearer " + cleanToken(acc.token), "Content-Type": "application/json;charset=UTF-8", "interfaceversion": "2", ...signH }; if (acc.userId) h["user_id"] = String(acc.userId); return h; } // v2.15.5 面板打开维护（响应后后台执行，不阻塞首屏）： // 定时签到（打开面板补签引擎）+ 失败重试队列 + 车辆监控。 // iOS 原生 App 在「原生直出面板页」后调 /api/panel-open 触发，语义与「打开面板」一致。 async function runPanelOpenMaintenance() { if (runPanelOpenMaintenance._running) return; runPanelOpenMaintenance._running = true; // 定时签到（补签引擎）：设置页开启后，每天首次打开面板且已过设定时间 → 全账号签到一次（日期标记去重） try { const _cfg0 = getConfig(); if (_cfg0.autoSignin) { const _now = new Date(); const _today = _now.getFullYear() + "-" + String(_now.getMonth()+1).padStart(2,"0") + "-" + String(_now.getDate()).padStart(2,"0"); const _hm = String(_now.getHours()).padStart(2,"0") + ":" + String(_now.getMinutes()).padStart(2,"0"); const _last = ($.getdata("zeeho_autosign_lastdate") || ""); if (_hm >= _cfg0.autoSigninTime && _last !== _today) { $.setdata(_today, "zeeho_autosign_lastdate"); const _accs = getAccounts(); if (_accs.length) { console.log("[定时签到] 已过 " + _cfg0.autoSigninTime + "，自动补签 " + _accs.length + " 个账号"); await runSigninBatch(_accs, _cfg0); } } } } catch(e) { console.log("[定时签到] 异常: " + e); } try { await checkRetryQueue(getConfig()); } catch(e) {} try { await checkVehicleMonitor(getConfig()); } catch(e) {} runPanelOpenMaintenance._running = false; } // ========== v2.15.6 软件版本检测 ========== // 上游版本清单：jsDelivr 优先（国内可达），GitHub raw 兜底；本地缓存 6 小时避免频繁请求。 const VERSION_JSON_URLS = [ "https://cdn.jsdelivr.net/gh/cluck798/ZEEHO@main/repo/version.json", "https://raw.githubusercontent.com/cluck798/ZEEHO/main/repo/version.json" ]; const VERSION_CK = "zeeho_vercheck"; const VERSION_CACHE_MS = 6 * 3600 * 1000; function verNum(s) { const m = String(s || "").match(/(\d+)\.(\d+)\.(\d+)/); return m ? (Number(m[1]) * 1000000 + Number(m[2]) * 1000 + Number(m[3])) : 0; } async function fetchLatestVersion(force) { if (!force) { try { const cached = $.getdata(VERSION_CK); if (cached) { const o = JSON.parse(cached); if (o && o.ts && (Date.now() - o.ts) < VERSION_CACHE_MS && o.latest && o.latest.script) { return { latest: o.latest, cached: true }; } } } catch(e) {} } // v2.16.2 加固：jsDelivr 对 @main 分支文件有最长约 12 小时缓存（曾出现其仍返回 2.15.6， // 导致“检查更新”误判为已是最新）。改为两源并发拉取、取版本号更高者： // raw 约 5 分钟级更新（新版本发布后能立刻探测到），jsDelivr 兜底国内网络可达性。 const fetched = await Promise.all(VERSION_JSON_URLS.map(async (u) => { try { const res = await httpGet(u + "?t=" + Math.floor(Date.now() / 300000), {}); let o = null; if (res && res.script) o = res; else if (res && typeof res.raw === "string") { try { o = JSON.parse(res.raw); } catch(e) {} } return (o && o.script) ? o : null; } catch(e) { return null; } })); let best = null; for (const o of fetched) { if (o && (!best || verNum(o.script) > verNum(best.script))) best = o; } if (best) { try { $.setdata(JSON.stringify({ ts: Date.now(), latest: best }), VERSION_CK); } catch(e) {} return { latest: best, cached: false }; } return { latest: null, cached: false, error: "版本信息获取失败（网络不可达）" }; } !(async () => { if (typeof $request === "undefined" || !$request) { $.log("极核看板增强版：请通过重写规则访问 http://zeeho.box"); $done(); return; } const url = $request.url || ""; // 自动识别当前入口域名：Loon=http://zeeho.box，QX=http://www.example.com try { const _u = new URL(url); PANEL_HOST = _u.origin; } catch (e) {} // 极核API请求由前面的autoCapture处理，主入口跳过，避免$done调用两次 if (url.includes('zeehoev.com')) { console.log('[主入口] 跳过非面板请求: ' + url.substring(0, 80)); return; // autoCapture会调用$done } const method = ($request.method || "GET").toUpperCase(); let path = "/"; try { const u = new URL(url); path = u.pathname || "/"; } catch(e) { path = "/"; } // ========== 定时签到（补签引擎） ========== // 代理脚本无常驻进程，采用"打开面板补签"模型：设置页开启后， // 每天首次打开面板且当前时间已过设定时间 → 自动为全部账号执行一次签到（写日志+推Bark，与手动一致）。 // 以 store 里的日期标记去重，同一天只补一次。 if (method === "GET" && (path === "/" || path === "")) { try { const _cfg0 = getConfig(); if (_cfg0.autoSignin) { const _now = new Date(); const _today = _now.getFullYear() + "-" + String(_now.getMonth()+1).padStart(2,"0") + "-" + String(_now.getDate()).padStart(2,"0"); const _hm = String(_now.getHours()).padStart(2,"0") + ":" + String(_now.getMinutes()).padStart(2,"0"); const _last = ($.getdata("zeeho_autosign_lastdate") || ""); if (_hm >= _cfg0.autoSigninTime && _last !== _today) { // 先写标记防并发重复触发 $.setdata(_today, "zeeho_autosign_lastdate"); const _accs = getAccounts(); if (_accs.length) { console.log("[定时签到] 已过 " + _cfg0.autoSigninTime + "，自动补签 " + _accs.length + " 个账号"); await runSigninBatch(_accs, _cfg0); } } } } catch(e) { console.log("[定时签到] 异常: " + e); } } // ========== v2.14.9 打开面板时：失败重试队列 + 车辆监控 ========== if (method === "GET" && (path === "/" || path === "")) { try { await checkRetryQueue(getConfig()); } catch(e) {} try { await checkVehicleMonitor(getConfig()); } catch(e) {} } // ========== v2.15.5 原生 App 快路径：面板 HTML 由原生直出，用它触发同一套「打开面板」维护 ========== // 先立即响应，维护改到响应后后台执行（不再 await 网络任务挡在首屏前面） if (method === "GET" && path === "/api/panel-open") { sendResp(200, { "Content-Type": "application/json", "Cache-Control": "no-cache" }, '{"ok":true}'); setTimeout(function(){ runPanelOpenMaintenance(); }, 0); return; } // ========== v2.15.6 API: 软件版本检测（/api/version-check?fresh=1 强制刷新） ========== if (method === "GET" && path === "/api/version-check") { const force = /fresh=1/.test(url); const vr = await fetchLatestVersion(force); const cur = SCRIPT_VERSION.replace(/^v/, ""); const latest = vr.latest || null; sendResp(200, { "Content-Type": "application/json;charset=utf-8", "Cache-Control": "no-cache" }, JSON.stringify({ ok: !!latest, error: vr.error || "", cached: !!vr.cached, current: cur, latest: latest, hasUpdate: latest ? verNum(latest.script) > verNum(cur) : false })); return; } // API: 保存配置 if (method === "POST" && path === "/api/save-config") { const body = parseBody($request); // v2.16.9 设置页表单不含 pics，保存其它配置时保留车辆图片替换配置 try { if (body && body.pics === undefined) { const _p = JSON.parse($.getdata(CK_CONFIG) || "{}"); if (_p && _p.pics) body.pics = _p.pics; } } catch(e) {} const ok = saveConfig(body); sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: ok })); return; } // API: 验证用户ID与Token是否匹配 if (method === "POST" && path === "/api/verify-account") { const body = parseBody($request); const userId = String(body.userId || ""); const token = cleanToken(body.token || ""); const cfg = getConfig(); let valid = false; let message = ""; let returnedId = ""; if (!userId || !token) { message = "用户ID和Token不能为空"; } else { try { const signH = getSign("app", {}, '', cfg); const res = await httpGet(`https://tapi.zeehoev.com/v1.0/mine/cfmotoservermine/setting/${userId}`, { "Authorization": `Bearer ${token}`, "Content-Type": "application/json;charset=UTF-8", "interfaceversion": "2", "user_id": userId, ...signH }); if (res.code == "10000" && res.data) { returnedId = String(res.data.id || res.data.userId || ""); if (returnedId === userId) { valid = true; message = "验证通过，Token与用户ID匹配"; } else { valid = false; message = `Token不匹配！该Token属于用户ID: ${returnedId || "未知"}，不是 ${userId}`; } } else if (res.code == "40001" || res.code == 401) { valid = false; message = "Token已过期，请重新获取"; } else { valid = false; message = "验证失败: " + (res.message || res.code || "未知错误"); } } catch(e) { valid = false; message = "验证异常: " + String(e); } } sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ valid: valid, message: message, returnedId: returnedId })); return; } // API: 根据Token自动获取用户ID if (method === "POST" && path === "/api/get-userid") { const body = parseBody($request); const token = cleanToken(body.token || ""); const cfg = getConfig(); let userId = ""; let userName = ""; let error = null; if (!token) { error = "请先输入Token"; } else { const baseHeaders = { "Authorization": `Bearer ${token}`, "Content-Type": "application/json;charset=UTF-8", "interfaceversion": "2" }; // 递归搜索对象中的 userId 字段 const findUserId = (obj, depth = 0) => { if (!obj || depth > 5) return ""; if (typeof obj === "string" || typeof obj === "number") return ""; for (const key of Object.keys(obj)) { const val = obj[key]; if (/user.?id|uid|create.?by|owner.?id/i.test(key) && val && typeof val !== "object") { const s = String(val); if (s.length >= 10 && /^\d+$/.test(s)) return s; } if (val && typeof val === "object") { const found = findUserId(val, depth + 1); if (found) return found; } } return ""; }; // 方式0（最优先，最可靠）：调用 H5 端 baseInfo 接口，不需要 user_id，从 token 直接获取用户信息 try { const signH0 = getSign("h5", { server_name: "SMART" }, '', cfg); const res0 = await httpGet("https://h5.zeehoev.com/cfmotoservermine/baseInfo?server_name=SMART", { ...baseHeaders, ...signH0 }); if (res0 && String(res0.code) === "10000" && res0.data) { userId = String(res0.data.id || ""); userName = String(res0.data.nickName || ""); } } catch(e) {} // 方式1：调用 /setting（不带userId）获取当前用户信息 if (!userId) { try { const signH = getSign("app", {}, '', cfg); const res = await httpGet("https://tapi.zeehoev.com/v1.0/mine/cfmotoservermine/setting", { ...baseHeaders, ...signH }); if (res.code == "10000" && res.data) { userId = String(res.data.id || res.data.userId || ""); userName = String(res.data.nickName || ""); } if (!userId && res.data) userId = findUserId(res.data); } catch(e) {} } // 方式2：调用积分接口获取用户信息 if (!userId) { try { const signH = getSign("app", {}, '', cfg); const res = await httpGet("https://tapi.zeehoev.com/v1.0/mine/cfmotoservermine/integral/adjustByShare", { ...baseHeaders, ...signH }); if (res && res.data) userId = findUserId(res.data); } catch(e) {} } // 方式3：从 vehicle/list 响应中递归搜索 userId if (!userId) { try { const signH = getSign("app", {}, '', cfg); const res = await httpGet("https://tapi.zeehoev.com/v1.0/app/cfmotoserverapp/vehicle/list", { ...baseHeaders, ...signH }); if (res && res.data) userId = findUserId(res.data); // 也搜索整个响应 if (!userId && res) userId = findUserId(res); } catch(e) {} } // 方式4：调用 homeRideInfo（需要先获取车辆VIN） if (!userId) { try { const signH = getSign("app", {}, '', cfg); const listRes = await httpGet("https://tapi.zeehoev.com/v1.0/app/cfmotoserverapp/vehicle/list", { ...baseHeaders, ...signH }); let vinNo = ""; const d = listRes?.data; if (Array.isArray(d)) vinNo = d[0]?.vinNo || d[0]?.frameNo || ""; else if (Array.isArray(d?.list)) vinNo = d.list[0]?.vinNo || ""; else if (Array.isArray(d?.records)) vinNo = d.records[0]?.vinNo || ""; if (vinNo) { const qRide = `vinNo=${encodeURIComponent(vinNo)}`; const rideRes = await httpGet(`https://tapi.zeehoev.com/v1.0/app/cfmotoserverapp/homeRideInfo?${qRide}`, appQueryGetHeaders({ token: token, userId: "" }, qRide, cfg)); if (rideRes && rideRes.data) userId = findUserId(rideRes.data); } } catch(e) {} } // 方式5：社区接口（粉丝列表/关注列表/用户信息），这些接口响应中通常包含 userId if (!userId) { const socialUrls = [ "https://tapi.zeehoev.com/v1.0/social/cfmotoserversocial/fans/list?page=1&pageSize=1", "https://tapi.zeehoev.com/v1.0/social/cfmotoserversocial/follower/list?page=1&pageSize=1", "https://tapi.zeehoev.com/v1.0/social/cfmotoserversocial/user/fans?page=1&pageSize=1", "https://tapi.zeehoev.com/v1.0/social/cfmotoserversocial/my/fans?page=1&pageSize=1", "https://tapi.zeehoev.com/v1.0/social/cfmotoserversocial/community/fans?page=1&pageSize=1", "https://tapi.zeehoev.com/v1.0/social/cfmotoserversocial/fans/myFans?page=1&pageSize=1", "https://tapi.zeehoev.com/v1.0/social/cfmotoserversocial/user/info", "https://tapi.zeehoev.com/v1.0/social/cfmotoserversocial/my/info", "https://tapi.zeehoev.com/v1.0/social/cfmotoserversocial/community/userInfo" ]; for (const url of socialUrls) { if (userId) break; try { const qSoc = url.split("?")[1] || ""; const res = await httpGet(url, appQueryGetHeaders({ token: token, userId: "" }, qSoc, cfg)); if (res && res.data) { userId = findUserId(res.data); if (!userId && res) userId = findUserId(res); // 尝试从昵称中获取 userName if (!userName && res.data) { const findName = (obj, depth = 0) => { if (!obj || depth > 4) return ""; for (const key of Object.keys(obj)) { if (/nick.?name|user.?name|name/i.test(key) && obj[key] && typeof obj[key] === "string") return obj[key]; if (obj[key] && typeof obj[key] === "object") { const n = findName(obj[key], depth + 1); if (n) return n; } } return ""; }; userName = findName(res.data); } } } catch(e) {} } } if (!userId) error = "自动获取失败，请手动填写用户ID（或打开极核App-我的页面自动捕获）"; } sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: !!userId, userId: userId, userName: userName, error: error })); return; } // API: 快速保存（客户端通过 zeeho.box 链接直接保存，GET请求，参数在query里） // API: 发送短信验证码（手机号登录，免抓包）——走 App 网关，与登录同验证码池 if (method === "POST" && path === "/api/send-code") { const body = parseBody($request); const phone = String(body.phone || "").trim(); if (!/^1\d{10}$/.test(phone)) { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: false, message: "手机号格式不正确（应为11位）" })); return; } const cfg = getConfig(); // 发码走 App 网关（与 loginByPhone 同一验证码池；签名按 GET 风格，URL入签） // 曾误以为"App 网关旧 GET 已废弃返回 permit error"，实为签名风格错误所致，勿改回 H5（H5 发的码登录侧取不到） const url = `https://tapi.zeehoev.com/v1.0/mine/cfmotoservermine/authCode/${encodeURIComponent(phone)}`; const signH = appGatewaySign(url, "GET", {}, '', cfg); const res = await httpGet(url, { "Content-Type": "application/json;charset=UTF-8", "User-Agent": "okhttp/4.9.2", ...signH }); if (res && String(res.code) === "10000") { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: true, message: "验证码已发送，请查收短信" })); } else { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: false, message: "发送失败: " + ((res && (res.message || res.msg)) || "未知错误") })); } return; } // API: 手机号 + 短信验证码登录（免抓包），成功后自动写入账号列表 if (method === "POST" && path === "/api/phone-login") { const body = parseBody($request); const phone = String(body.phone || "").trim(); const code = String(body.code || "").trim(); if (!/^1\d{10}$/.test(phone)) { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: false, message: "手机号格式不正确（应为11位）" })); return; } if (!code) { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: false, message: "请填写短信验证码" })); return; } const cfg = getConfig(); // 登录请求体与参考实现（HomeAssistant zeeho 集成，实测可用）完全一致：phone + authCode const payload = { phone: phone, authCode: code }; // 登录必须带 OAuth2 Basic 凭据（逆向自极核 App，固定 mck:123456 → base64 bWNrOjEyMzQ1Ng==） // 留空则用内置默认值；用户抓包发现变化时可在面板输入框覆盖 const basicAuth = String((body && body.basicAuth) || cfg.basicAuth || "bWNrOjEyMzQ1Ng==").trim().replace(/^Basic\s+/i, ""); // 走 App 网关（与发码同一验证码池） const loginUrl = "https://tapi.zeehoev.com/v1.0/mine/cfmotoservermine/user/loginByPhone"; // ⚠️ 虽然是 POST，签名必须按 GET 风格（URL入签、body 不入签，与参考实现一致）： // 用 POST 风格签名(query+body) 服务端签名校验不过，返回"验证码有误或已过期" const signH = appGatewaySign(loginUrl, "GET", {}, '', cfg); const loginHeaders = { "Content-Type": "application/json;charset=UTF-8", "User-Agent": "okhttp/4.9.2", ...signH }; if (basicAuth) loginHeaders["Authorization"] = "Basic " + basicAuth; const loginRes = await httpPost( loginUrl, loginHeaders, payload, 20000 ); const tokenInfo = loginRes && loginRes.data && loginRes.data.tokenInfo; const accessToken = tokenInfo && String(tokenInfo.access_token || ""); if (!loginRes || String(loginRes.code) !== "10000" || !accessToken) { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: false, message: "登录失败: " + ((loginRes && (loginRes.message || loginRes.msg)) || "验证码有误或已过期"), detail: loginRes })); return; } // 用登录 Token 自动获取用户ID与昵称（H5 baseInfo，与「获取ID」一致） // 用户ID与昵称：优先用登录响应自带字段（App loginByPhone 响应 data 直接返回 id/phone/nickName），失败再查 H5 baseInfo let userId = String((loginRes.data && (loginRes.data.id || loginRes.data.userId)) || "").trim(); let userName = String((loginRes.data && (loginRes.data.nickName || loginRes.data.username)) || "").trim(); if (!userId) { try { const signH0 = getSign("h5", { server_name: "SMART" }, '', cfg); const infoRes = await httpGet("https://h5.zeehoev.com/cfmotoservermine/baseInfo?server_name=SMART", { "Authorization": "Bearer " + accessToken, "Content-Type": "application/json;charset=UTF-8", "interfaceversion": "2", ...signH0 }); if (infoRes && String(infoRes.code) === "10000" && infoRes.data) { userId = String(infoRes.data.id || ""); userName = String(infoRes.data.nickName || ""); } } catch(e) {} } // 追加/更新账号：同一 Token 或同一用户ID视为同一账号（刷新Token），否则新增 const list = getAccounts(); let replaced = false; for (let i = 0; i < list.length; i++) { if (list[i] && (String(list[i].token || "") === accessToken || (list[i].userId && userId && String(list[i].userId) === userId))) { list[i].token = accessToken; if (userId) list[i].userId = userId; if (userName) list[i].userName = userName; replaced = true; break; } } const newAcc = { userName: userName || phone, userId: userId, token: accessToken, barkKey: "", userAgent: "" }; if (!replaced) list.push(newAcc); saveAccounts(list); sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: true, message: replaced ? "登录成功，已更新该账号" : "登录成功，已添加账号", account: newAcc })); return; } if (path === "/api/quick-save" || path === "/quick-save") { try { const u = new URL(url); const qName = u.searchParams.get('name') || ''; const qToken = cleanToken(u.searchParams.get('token') || ''); if (!qToken) { sendResp(200, { "Content-Type": "text/html; charset=utf-8" }, '

保存失败

Token为空

返回配置'); return; } const cfg = getConfig(); // 自动获取用户ID let qUid = ''; let qNick = qName; let fetchErr = ''; try { const signHeaders = getSign('h5', { server_name: 'SMART' }, '', cfg); const res = await httpGet('https://h5.zeehoev.com/cfmotoservermine/baseInfo?server_name=SMART', { 'Content-Type': 'application/json;charset=UTF-8', 'Authorization': 'Bearer ' + qToken, ...signHeaders }); if (res && String(res.code) === '10000' && res.data) { qUid = String(res.data.id || ''); qNick = res.data.nickName || qName; } else { fetchErr = res?.message || res?.msg || '获取用户ID失败'; } } catch(e) { fetchErr = String(e); } // 获取失败用临时ID if (!qUid) qUid = 'temp_' + qToken.substring(0, 8); // 保存到账号列表 let accounts = getAccounts(); const idx = accounts.findIndex(a => String(a.userId) === String(qUid) || cleanToken(a.token) === qToken); const acc = { userName: qNick || ('账号' + (accounts.length + 1)), userId: qUid, token: qToken }; if (idx >= 0) accounts[idx] = Object.assign({}, accounts[idx], acc); else accounts.push(acc); saveAccounts(accounts); console.log('[快速保存] 账号已保存: ' + acc.userName + ' (' + qUid + ')' + (fetchErr ? ' [获取ID失败: '+fetchErr+']' : '')); // 返回成功页面 const okHtml = '配置已保存
✓
配置保存成功
昵称：' + (acc.userName) + '
用户ID：' + qUid + '' + (fetchErr ? '
⚠️ 自动获取用户ID失败（'+fetchErr+'），已用临时ID保存，可在配置页点「获取ID」重试
' : '') + '
查看面板 配置页
'; sendResp(200, { "Content-Type": "text/html; charset=utf-8" }, okHtml); } catch(e) { sendResp(200, { "Content-Type": "text/html; charset=utf-8" }, '

保存异常

' + String(e) + '

'); } return; } // API: 保存账号 if (method === "POST" && path === "/api/save-accounts") { const body = parseBody($request); const rawList = Array.isArray(body.accounts) ? body.accounts : []; // 存盘前统一剥离 Bearer 前缀，仅保留 Token 本体；其余字段（含每账号 barkKey）原样保留 const list = rawList.map(function(a) { return Object.assign({}, a, { token: cleanToken(a.token || ""), barkKey: cleanBarkKey(a.barkKey || "") }); }); const ok = saveAccounts(list); sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: ok, count: list.length })); return; } // API: 获取全部数据（账号+车辆+配置） if (method === "GET" && path === "/api/data") { const cfg = getConfig(); const accounts = getAccounts(); // 并发3路拉取（原串行逐个等待，多账号时明显卡顿） const data = await fetchAllAccounts(accounts, cfg, 3); sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ accounts: data, config: { appId: cfg.app.appId, h5AppId: cfg.h5.appId, community: cfg.community }, timestamp: new Date().toISOString(), total: accounts.length })); return; } // API: 多车切换 - 获取指定账号指定车辆数据 if (method === "GET" && path === "/api/vehicle") { try { const _u = new URL(url); const userId = String(_u.searchParams.get("userId") || ""); const vin = String(_u.searchParams.get("vin") || ""); const cfg = getConfig(); const accounts = getAccounts(); const acc = accounts.find(a => String(a.userId) === String(userId)); if (!acc || !vin) { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: false, error: "参数错误" })); return; } const result = await fetchAccountData(acc, cfg, vin); sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: true, result: result })); } catch (e) { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: false, error: String(e) })); } return; } // ========== v2.16.0 API: 隐藏骑行数据 · 月度汇总（myRideInfo 透传，面板「骑行」页用） ========== if (method === "GET" && path === "/api/ride-month") { try { const _u = new URL(url); const acc = findAccByUserId(_u.searchParams.get("userId") || ""); if (!acc) { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: false, error: "未找到账号" })); return; } const r = await fetchRideMonth(acc, getConfig(), String(_u.searchParams.get("month") || ""), String(_u.searchParams.get("vin") || "")); sendResp(200, { "Content-Type": "application/json" }, JSON.stringify(r)); } catch(e) { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: false, error: String(e) })); } return; } // ========== v2.16.0 API: 隐藏骑行数据 · 轨迹分页（ridetrack_v2 透传，面板「扫描轨迹」用） ========== if (method === "GET" && path === "/api/ride-track") { try { const _u = new URL(url); const acc = findAccByUserId(_u.searchParams.get("userId") || ""); if (!acc) { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: false, error: "未找到账号" })); return; } const r = await fetchRideTrackPage(acc, getConfig(), _u.searchParams.get("page"), _u.searchParams.get("pageSize"), String(_u.searchParams.get("vin") || ""), String(_u.searchParams.get("month") || "")); sendResp(200, { "Content-Type": "application/json" }, JSON.stringify(r)); } catch(e) { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: false, error: String(e) })); } return; } // API: 获取完整配置（面板模式设置页回填账号密钥用） if (method === "GET" && path === "/api/config") { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: true, config: getConfig() })); return; } // API: 获取完整账号列表（含 Token / Bark Key，设置页回填用） if (method === "GET" && path === "/api/accounts") { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: true, accounts: getAccounts() })); return; } // API: 获取运行日志 if (method === "GET" && path === "/api/get-logs") { const logs = getLogs(); sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ logs: logs })); return; } // API: 清空运行日志 if (method === "POST" && path === "/api/clear-logs") { const ok = clearLogs(); sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: ok })); return; } // API: 手动执行签到 if (method === "POST" && path === "/api/run-signin") { const body = parseBody($request); const cfg = getConfig(); const accounts = getAccounts(); const targets = body.all ? accounts : accounts.filter(a => String(a.userId) === String(body.userId)); const results = await runSigninBatch(targets, cfg); sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: true, results: results })); return; } // API: 车辆远程控制（find寻车 / loudFind鸣笛闪灯 / cushion开坐垫 / unlock开锁 / lock关锁） if (method === "POST" && path === "/api/vehicle-control") { const body = parseBody($request); const action = String(body.action || ""); const cfg = getConfig(); const accounts = getAccounts(); // 按 userId 定位账号；找不到时兜底取第一个 let acc = accounts.find(a => String(a.userId) === String(body.userId)); if (!acc && body.userId) acc = accounts[0]; if (!acc && accounts.length) acc = accounts[0]; if (!acc) { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: false, message: "未找到账号，请先在配置页添加" })); return; } if (!VEHICLE_ACTION_TEXT[action]) { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: false, message: "非法操作类型" })); return; } // 2026-09-20 修复：支持传入指定 VIN，切换车辆后控车操作对应选中车辆而非默认第一台 const customVin = String(body.vin || "").trim(); const r = await vehicleControl(acc, action, cfg, customVin); console.log(`[车辆控制] ${acc.userName} ${VEHICLE_ACTION_TEXT[action]} => ${r.ok ? "成功" : "失败:" + r.message}`); // 控车操作写入运行日志（type=vehicle，日志页可按“控车”筛选） try { const _vd = new Date(); const _vds = _vd.getFullYear() + "-" + String(_vd.getMonth()+1).padStart(2,"0") + "-" + String(_vd.getDate()).padStart(2,"0"); addLog({ time: _vd.toLocaleString("zh-CN", { hour12: false }), date: _vds, type: "vehicle", action: action, actionText: VEHICLE_ACTION_TEXT[action] || "车辆控制", userName: acc.userName || "未知", userId: acc.userId, success: !!r.ok, message: r.message || "", error: r.ok ? "" : (r.message || "指令失败") }); } catch(e) {} sendResp(200, { "Content-Type": "application/json" }, JSON.stringify(r)); return; } // ========== v2.14.9 API: 积分全家桶（流水/总积分/过期/签到统计） ========== if (method === "GET" && path === "/api/integral") { try { const _u = new URL(url); const acc = findAccByUserId(_u.searchParams.get("userId") || ""); if (!acc) { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: false, error: "未找到账号" })); return; } const cfg = getConfig(); const page = Number(_u.searchParams.get("page")) || 1; const pageSize = Number(_u.searchParams.get("pageSize")) || 20; const T = "https://tapi.zeehoev.com/v1.0/mine/cfmotoservermine"; const [dt, tot, exp, cnt] = await Promise.all([ httpGet(T + "/integral/detail?page=" + page + "&pageSize=" + pageSize, appQueryGetHeaders(acc, "page=" + page + "&pageSize=" + pageSize, cfg)), httpGet(T + "/integral/totalIntegral", accHeaders(acc, getSign("app", {}, '', cfg))), httpGet(T + "/integral/expire", accHeaders(acc, getSign("app", {}, '', cfg))), httpGet(T + "/signin/count", accHeaders(acc, getSign("app", {}, '', cfg))) ]); // v2.14.20 防御：官方 /integral/detail 的 data 可能为数组或 {records/list/rows}，统一归一为数组 let detailArr = []; if (dt && dt.code == "10000") { const dd = dt.data; if (Array.isArray(dd)) detailArr = dd; else if (dd && Array.isArray(dd.records)) detailArr = dd.records; else if (dd && Array.isArray(dd.list)) detailArr = dd.list; else if (dd && Array.isArray(dd.rows)) detailArr = dd.rows; else if (dd && Array.isArray(dd.detail)) detailArr = dd.detail; } sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: true, detail: detailArr, detailError: dt && dt.code != "10000" ? (dt.message || "") : "", total: (tot && tot.code == "10000") ? tot.data : null, expire: (exp && exp.code == "10000") ? (exp.data || []) : [], signinCount: (cnt && cnt.code == "10000") ? cnt.data : null })); } catch(e) { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: false, error: String(e) })); } return; } // ========== v2.14.9 API: 积分补签（补签卡数/日历/连签/兑换/使用补签卡） ========== if (path === "/api/supplement") { try { const _u = new URL(url); const body = method === "POST" ? parseBody($request) : {}; const acc = findAccByUserId(_u.searchParams.get("userId") || body.userId || ""); if (!acc) { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: false, error: "未找到账号" })); return; } const cfg = getConfig(); const action = String(_u.searchParams.get("action") || body.action || "count"); const dateTime = String(_u.searchParams.get("dateTime") || body.dateTime || ""); // 2026-10-13 路径修复：consume（补签）/ gain（积分兑换）必须走官方新路径（含 /H5/）， // 旧路径 /cfmotoservermine/signInSupplement/* 已被 WAF 拦为 430/30125 permit error const H = "https://h5.zeehoev.com/cfmotoservermine/H5/signInSupplement"; let res = null; if (action === "count") { // 2026-10-12 HAR 实证：官方 POST /count 的签名把 body "{}" 纳入（md5(sha1("{}"+param+secret)) 与官方样本逐位一致）； // 不签 body 会被 WAF 判 430/30121 permit error（补签卡数量/补签流程因此报错） res = await httpPost(H + "/count", accHeaders(acc, getSign("h5", {}, "{}", cfg)), "{}"); } else if (action === "page") { // 2026-09-27: 官方已将 /page 改为 POST，分页参数放 body 内（GET 返回 40000） const page = Number(_u.searchParams.get("page")) || 1, pageSize = Number(_u.searchParams.get("pageSize")) || 10; const pageBody = JSON.stringify({ page: page, pageSize: pageSize }); res = await httpPost(H + "/page", accHeaders(acc, getSign("h5", {}, pageBody, cfg)), pageBody); } else if (action === "continuity") { res = await httpGet(H + "/continuity?dateTime=" + encodeURIComponent(dateTime), accHeaders(acc, getSign("h5", { dateTime: dateTime }, '', cfg))); } else if (action === "detail") { res = await httpGet(H + "/detail?dateTime=" + encodeURIComponent(dateTime), accHeaders(acc, getSign("h5", { dateTime: dateTime }, '', cfg))); } else if (action === "month") { // 整月签到日历：YYYY-MM，返回 nowSignDetailVos（补签日历渲染用） const month = String(_u.searchParams.get("month") || ""); if (!/^\d{4}-\d{2}$/.test(month)) { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: false, error: "月份格式应为 YYYY-MM" })); return; } res = await httpGet("https://h5.zeehoev.com/cfmotoservermine/H5/signin/info?month=" + encodeURIComponent(month), accHeaders(acc, getSign("h5", { month: month }, '', cfg))); } else if (action === "gain") { // 积分兑换补签卡：sourceType 1=积分兑换 2=盲盒 3=赠送 4=活动 res = await httpGet(H + "/gain?sourceType=1", accHeaders(acc, getSign("h5", { sourceType: 1 }, '', cfg))); } else if (action === "consume") { if (!/^\d{4}-\d{2}-\d{2}$/.test(dateTime)) { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: false, error: "日期格式应为 YYYY-MM-DD" })); return; } res = await httpGet(H + "/consume?dateTime=" + encodeURIComponent(dateTime), accHeaders(acc, getSign("h5", { dateTime: dateTime }, '', cfg))); } else { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: false, error: "未知 action" })); return; } const okFlag = res && res.code == "10000"; console.log("[补签] " + action + " => " + (res ? res.code + " " + (res.message || "") : "无响应")); sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: !!okFlag, code: res ? res.code : "", message: res ? (res.message || "") : "无响应", data: res ? res.data : null })); } catch(e) { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: false, error: String(e) })); } return; } // ========== v2.16.9 API: 车辆图片替换配置 ========== if (path === "/api/pic-cfg") { if (method === "GET") { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: true, pics: getConfig().pics || {} })); return; } if (method === "POST") { let r = { ok: false }; try { const body = JSON.parse($request.body || "{}"); let c = {}; try { c = JSON.parse($.getdata(CK_CONFIG) || "{}") || {}; } catch(e) {} const next = {}; const src = (body.pics && typeof body.pics === "object") ? body.pics : {}; for (const k of Object.keys(src)) { const u = String(src[k] || "").trim(); if (/^https?:\/\//.test(u)) next[String(k).trim()] = u; } c.pics = next; saveConfig(c); r = { ok: true, count: Object.keys(next).length }; } catch(e) { r = { ok: false, error: String(e) }; } sendResp(200, { "Content-Type": "application/json" }, JSON.stringify(r)); return; } } // ========== v2.16.5 API: 电池/充电状态（充电剩余时间估算用：电流/电量/电压/充电中） ========== if (method === "GET" && path === "/api/battery-state") { try { const _u = new URL(url); const acc = findAccByUserId(_u.searchParams.get("userId") || ""); if (!acc) { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: false, error: "未找到账号" })); return; } const cfg = getConfig(); let vin = String(_u.searchParams.get("vin") || "").trim(); if (!vin) { const list = await fetchVehicleList(acc, cfg) || []; const vehicles = list.filter(x => !/模拟/.test(String(x.name || "") + " " + String(x.vehicleType || ""))); if (!vehicles.length) { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: false, error: "未获取到绑定车辆" })); return; } vin = vehicles[0].vinNo; } const b = await fetchBatteryChargeState(acc, cfg, vin); sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: true, vinNo: vin, charging: /充电/.test(String(b.chargeState || "")), current: b.current, soc: b.soc, voltage: b.voltage, chargeState: b.chargeState, fullChargeTime: b.fullChargeTime, fullChargeTimeSecond: b.fullChargeTimeSecond })); } catch(e) { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: false, error: String(e) })); } return; } // ========== v2.14.9 API: 车辆状态监控（快照 + 离线判断） ========== if (method === "GET" && path === "/api/vehicle-monitor") { try { const _u = new URL(url); const acc = findAccByUserId(_u.searchParams.get("userId") || ""); if (!acc) { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: false, error: "未找到账号" })); return; } const cfg = getConfig(); let vin = String(_u.searchParams.get("vin") || "").trim(); let vehicles = []; if (!vin) { vehicles = await fetchVehicleList(acc, cfg) || []; if (!vehicles.length) { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: false, error: "未获取到绑定车辆" })); return; } vin = vehicles[0].vinNo; } const snap = await fetchVehicleSnapshots(acc, cfg, vin); if (!snap) { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: false, error: "快照获取失败" })); return; } sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: true, snapshot: snap, vehicles: vehicles })); } catch(e) { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: false, error: String(e) })); } return; } // ========== v2.14.12 API: 后台监控 tick（原生定时器周期调用，跑充满/离线去重检查并本地通知） ========== if (method === "GET" && path === "/api/vehicle-monitor-tick") { try { await checkVehicleMonitor(getConfig()); } catch(e) {} sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: true })); return; } // ========== v2.14.21 API: 小组件快照（iOS WidgetKit 读取；主 App 周期调用并写入 App Group 共享目录） ========== if (method === "GET" && path === "/api/widget-snapshot") { try { const cfg = getConfig(); const accounts = getAccounts(); if (!accounts.length) { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: false, error: "暂无账号" })); return; } // 小组件显示车辆：cfg.widgetVehicle = "userId|vin"，未配置取第一个账号第一台车 let userId = "", vin = ""; const wv = String(cfg.widgetVehicle || ""); if (wv.indexOf("|") > 0) { const p = wv.split("|"); userId = p[0] || ""; vin = p[1] || ""; } let acc = userId ? accounts.find(a => String(a.userId) === String(userId)) : null; if (!acc) acc = accounts[0]; const data = await fetchAccountData(acc, cfg, vin || undefined); const v = data.vehicle || {}; sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: true, ts: new Date().toISOString(), accountName: data.userName || "", userId: data.userId || "", vehicleName: v.vehicleName || "", vehicleModel: v.vehicleModel || "", hasVehicle: !!v.hasVehicle, soc: v.batteryPercent || 0, range: v.residualRangeKm || 0, rangeEstimated: !!v.rangeEstimated, voltage: v.voltage || 0, current: v.current || 0, chargeState: v.chargeState || "未充电", online: v.online || "", score: data.score || 0, continueDays: data.continueDays || 0, todayScore: data.todayScore || 0, signedToday: !!data.signedToday, todayDistance: v.todayDistance || 0, totalMileage: v.totalMileage || 0 })); } catch(e) { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: false, error: String(e) })); } return; } // ========== v2.14.9 API: 车控扩展（充电功率/限速档位/防盗/音效/储物箱） ========== if (method === "POST" && path === "/api/vehicle-control-ext") { try { const body = parseBody($request); const cfg = getConfig(); const acc = findAccByUserId(body.userId || ""); if (!acc) { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: false, message: "未找到账号" })); return; } const action = String(body.action || ""); let vin = String(body.vin || "").trim(); let deviceName = ""; const list = await fetchVehicleList(acc, cfg) || []; if (!vin && list.length) vin = list[0].vinNo; const veh = list.find(v => v.vinNo === vin) || list[0] || {}; deviceName = veh.deviceName || ""; if (!vin) { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: false, message: "未获取到绑定车辆" })); return; } // 2026-09-27: 官方已将 vehicleSet 写操作迁移到新协议 addVehicleSet。 // 旧端点 /vehicleSet/chargePower 在 OAuth 层直接返回 401 invalid_token（token 实际有效），面板曾误报"token已失效"。 // 新协议需官方协议头（appid + 官方UA + 含body签名），即 socialHeaders 同款（HAR 抓包 1:1 复刻，实测 code 10000）。 const base = accHeaders(acc, {}); const T = "https://tapi.zeehoev.com/v1.0/app/cfmotoserverapp"; let res = null, okMsg = "指令已下发"; if (action === "options") { // 充电功率选项必须带 flag=1 才返回新档位 200-1200（不带返回旧档 350-1900），且需官方协议头 const cpQuery = "vinNo=" + encodeURIComponent(vin) + "&flag=1"; const cp = await httpGet(T + "/vehicleSet/chargePower/options?" + cpQuery, socialHeaders(cleanToken(acc.token), acc.userId, cpQuery, '', cfg)); sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: true, chargePower: cp && cp.code == "10000" ? cp.data : [] })); return; } else if (action === "chargePower") { // 新协议 addVehicleSet：serviceCode 603980102 = CHARGING_POWER_STANDARD（200-1200，步长100） const val = String(body.value || ""); const payload = JSON.stringify({ serviceCode: 603980102, commandParam: val, flag: true, vin: vin, vehicleSetEnum: "CHARGING_POWER_STANDARD", message: 0 }); res = await httpPost(T + "/vehicleSet/addVehicleSet", socialHeaders(cleanToken(acc.token), acc.userId, '', payload, cfg), payload); // v2.16.5：1200 档实际语义为「无限制」，文案修正（下发值不变） okMsg = "充电功率已设为 " + (val === "1200" ? "无限制" : val + "W"); } else if (action === "vcuStealControl") { // 防盗：需 vinNo + lockType + 云端设备号(deviceName) + 手机号 const payload = JSON.stringify({ vinNo: vin, lockType: String(body.lockType || ""), deviceName: deviceName, phone: String(body.phone || acc.phone || "") }); res = await httpPost(T + "/vehicleSet/vcuStealControl", { ...base, ...getSign("app", {}, payload, cfg) }, payload); okMsg = "防盗指令已下发"; } else if (action === "soundEffect") { const payload = JSON.stringify({ vinNo: vin, deviceName: deviceName, soundStatus: String(body.value || "") }); res = await httpPost(T + "/vehicleSet/setSoundStatus", { ...base, ...getSign("app", {}, payload, cfg) }, payload); okMsg = "音效指令已下发"; } else if (action === "storageBox") { const payload = JSON.stringify({ vinNo: vin }); res = await httpPost(T + "/vehicleSet/storageBox/dismantle", { ...base, ...getSign("app", {}, payload, cfg) }, payload); okMsg = "储物箱指令已下发（需VIP）"; } else { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: false, message: "未知操作类型" })); return; } const chk = vehicleCheckRes(res, okMsg); // 其余旧端点（限速/音效/防盗/储物箱）若也被官方迁移，会返回 invalid_token，不一定真是 token 失效，避免误报 if (!chk.ok && /token已失效/.test(String(chk.message || ""))) chk.message = "官方接口调用失败（接口可能已变更，请先在首页确认 token 是否有效）"; console.log("[车控扩展] " + action + " => " + (chk.ok ? "成功" : "失败:" + chk.message)); try { const _vd = new Date(); addLog({ time: _vd.toLocaleString("zh-CN", { hour12: false }), date: _vd.getFullYear() + "-" + String(_vd.getMonth()+1).padStart(2,"0") + "-" + String(_vd.getDate()).padStart(2,"0"), type: "vehicle", action: "ext:" + action, actionText: "车控扩展·" + action, userName: acc.userName || "未知", userId: acc.userId, success: !!chk.ok, message: chk.message || "", error: chk.ok ? "" : (chk.message || "指令失败") }); } catch(e) {} sendResp(200, { "Content-Type": "application/json" }, JSON.stringify(chk)); } catch(e) { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: false, message: String(e) })); } return; } // ========== v2.14.9 API: 信息聚合中心（未读消息/活动/优惠券/OTA/盲盒记录/骑行排行） ========== if (method === "GET" && path === "/api/info-center") { try { const _u = new URL(url); const acc = findAccByUserId(_u.searchParams.get("userId") || ""); if (!acc) { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: false, error: "未找到账号" })); return; } const cfg = getConfig(); const hd = (query) => appQueryGetHeaders(acc, query, cfg); let vin = String(_u.searchParams.get("vin") || "").trim(); const out = { ok: true }; const tasks = [ httpGet("https://tapi.zeehoev.com/v1.0/mine/cfmotoservermine/app/Message/allUnRead", hd("")).then(r => { out.unread = r && r.code == "10000" ? r.data : null; }), httpGet("https://tapi.zeehoev.com/v1.0/mall/cfmotoservermall/app/coupon/myCoupons?page=1&pageSize=10", hd("page=1&pageSize=10")).then(r => { out.coupons = r && r.code == "10000" ? r.data : null; }), httpGet("https://tapi.zeehoev.com/v1.0/mine/cfmotoservermine/activityPrizeRecord/app/page?page=1&pageSize=10", hd("page=1&pageSize=10")).then(r => { out.prizeRecords = r && r.code == "10000" ? r.data : null; }), httpGet("https://tapi.zeehoev.com/v1.0/app/cfmotoserverapp/riderank", hd("")).then(r => { out.riderank = r && r.code == "10000" ? r.data : null; }) ]; if (!vin) { try { const list = await fetchVehicleList(acc, cfg) || []; if (list.length) vin = list[0].vinNo; } catch(e) {} } if (vin) { tasks.push(httpGet("https://tapi.zeehoev.com/v1.0/app/cfmotoserverapp/ota/list?vinNo=" + encodeURIComponent(vin), hd("vinNo=" + encodeURIComponent(vin))).then(r => { out.ota = r && r.code == "10000" ? r.data : null; })); } await Promise.all(tasks); sendResp(200, { "Content-Type": "application/json" }, JSON.stringify(out)); } catch(e) { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: false, error: String(e) })); } return; } // API: 当前安装信息（iOS 签名方式检测 / 运行环境） if (method === "GET" && path === "/api/app-install-info") { let env = "unknown"; if (typeof module !== "undefined" && module.exports) env = "desktop"; else if (typeof $task !== "undefined") env = "quantumultx"; else if (typeof $rocket !== "undefined") env = "shadowrocket"; else if (typeof $loon !== "undefined") env = "loon"; else if (typeof $environment !== "undefined" && $environment["surge-version"]) env = "surge"; else if (typeof $environment !== "undefined" && $environment["stash-version"]) env = "stash"; const info = { env: env, ios: false, signMethod: "", hasProvision: false, expiration: "", expirationUnix: 0, daysRemain: 0, teamId: "", teamName: "", provisionsAllDevices: false, deviceCount: 0 }; if (env === "loon" && typeof $appInstallInfo === "function") { try { const ni = $appInstallInfo(); if (ni && typeof ni === "object") Object.assign(info, ni, { ios: true, env: "ios" }); } catch (e) {} } sendResp(200, { "Content-Type": "application/json" }, JSON.stringify(info)); return; } // API: 一键备份全部账号+面板配置 if (method === "GET" && path === "/api/backup") { const payload = { ok: true, app: "极核ZEEHO", type: "zeeho_backup", version: SCRIPT_VERSION, time: new Date().toLocaleString("zh-CN", { hour12: false }), accounts: getAccounts(), config: getConfig() }; sendResp(200, { "Content-Type": "application/json" }, JSON.stringify(payload)); return; } // API: 导入恢复备份（body.json 为完整备份 JSON 字符串，或 body.data 为备份对象） if (method === "POST" && path === "/api/import") { const body = parseBody($request); let bk = null; try { bk = typeof body.json === "string" && body.json.trim() ? JSON.parse(body.json) : (body.data || body); } catch(e) { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: false, error: "备份内容不是有效JSON" })); return; } if (!bk || (bk.type !== "zeeho_backup" && !Array.isArray(bk.accounts))) { sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: false, error: "备份格式不正确" })); return; } // 恢复账号：统一清洗 Token / BarkKey（与保存账号同一逻辑） const list = (Array.isArray(bk.accounts) ? bk.accounts : []).map(a => Object.assign({}, a, { token: cleanToken(a.token || ""), barkKey: cleanBarkKey(a.barkKey || "") })); const accOk = saveAccounts(list); // 恢复配置：缺失字段沿用当前值 let cfgOk = true; if (bk.config && typeof bk.config === "object") { try { const cur = getConfig(); const next = { app: { appId: bk.config.app?.appId || cur.app.appId, appSecret: bk.config.app?.appSecret || cur.app.appSecret }, h5: { appId: bk.config.h5?.appId || cur.h5.appId, appSecret: bk.config.h5?.appSecret || cur.h5.appSecret }, community: { enablePost: bk.config.community?.enablePost !== false, enableLike: bk.config.community?.enableLike !== false, enableComment: bk.config.community?.enableComment !== false, enableShare: bk.config.community?.enableShare !== false, enableDelete: bk.config.community?.enableDelete !== false }, vehicleAesKey: String(bk.config.vehicleAesKey || "").trim(), autoRefreshSec: normalizeRefreshSec(bk.config.autoRefreshSec) }; cfgOk = saveConfig(next); } catch(e) { cfgOk = false; } } console.log(`[备份恢复] 账号 ${list.length} 个，配置${cfgOk ? "已" : "未"}恢复 (${SCRIPT_VERSION})`); sendResp(200, { "Content-Type": "application/json" }, JSON.stringify({ ok: accOk, count: list.length, configOk: cfgOk })); return; } // 配置页 if (path === "/config") { const cfg = getConfig(); const accounts = getAccounts(); const html = renderConfig(accounts, cfg); sendResp(200, { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-cache" }, html); return; } // 看板页（默认）→ 输出整合后的 LITE 轻应用界面（数据走本机 /api/*，前端自动进入面板模式） sendResp(200, { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-cache" }, '