feat(permissions,clients,ai,system,server,web,client,shared)!: 权限组 + 客户端设备远控与自动更新 + 大模型助手 + 系统诊断(1.3.0)

功能级准入改为「权限键」,`requireRole` 退成默认模板。

权限组
- 权限目录(39 键:键 / 中文名 / 分类 / 默认角色)收口到 shared,路由挂 requirePermission / requireAnyPermission
- 有效权限每请求实时算,改完分组立刻生效:ADMIN 全集且 permission:manage、system:manage 不可剥夺;
  CLASS_DEVICE 空集(不受分组影响);有分组 = 并集(因此也能用来**收回**权限);无分组 = 角色默认模板
- 新增「权限组」页:组增删改、成员分配、生效权限预览
- 班级维度的科目规则(assertCanManageSubjectContent)故意不可被权限组覆盖

客户端设备(ClassHelper 桌面端)
- 设备身份是 deviceKey(首次启动生成的 UUID,saveConfig 拒绝改写、退出登录也保留)
- 心跳走「DB 记状态 + 客户端定时拉」,不引入新的长连接:30 秒一次,在线窗口 90 秒
- 远控命令 shutdown / restart / logoff / lock:服务端有效期 10 分钟,客户端弹默认选中「取消」的对话框、
  60 秒未确认按取消处理,执行后必须回执(重复回执幂等),同一台机器同一条命令只弹一次
- 新增「客户端设备」页:版本一览、一键推送更新、下发远控

客户端安装包由服务端下载并缓存(教室机常常没有外网,浏览器也受 CSP 限制)
- POST /api/update/client/fetch 由服务端下载到 data/client-releases/<版本>/ 并登记 sha256 + size
- 自动安装三条护栏:没有 sha256 就拒收、必须等到非上课且主窗口隐藏满 5 分钟、冒烟模式永不安装

大模型助手:只解析、不落库
- POST /api/ai/interpret 返回**待确认**的结构化动作(建作业 / 发通知 / 叫人),
  真正落库仍调既有端点 —— 权限断言、上课时段紧急通知保护、ClassIsland 推送全部自动复用
- 模型给的 params 用与手动入口**同一份** zod 再校验(模型输出不可信)
- API Key 走 AES-256-GCM(密钥由 JWT_SECRET 经 scrypt 派生)加密存 AppSetting,只进不出
- provider=mock 是离线确定性解析,自动化验收一律用它;每次解析写一条 AiAudit(不含密钥)

系统与运维
- 开发者模式(服务端内存缓存开关,热路径不查库;开启后 500 才附 error.stack)、运行诊断(绝不回传密钥)
- 开机自启动运行期可改:Windows 改 HKCU\...\Run、Linux systemctl enable/disable,
  **非安装形态一律返回 supported:false**,不往开发机的注册表里写自启项
- 服务端侧栏折叠只用 CSS 收拢(不重建 DOM),关怀模式只放大字号与控件、不动任何几何令牌

客户端
- 崩溃自愈:渲染进程挂掉 / 超 10 秒无响应先静默重建主窗口(10 分钟最多 3 次),
  未捕获异常只在「没在上课、没人看着」时才重启进程;冒烟模式绝不重启(会杀掉验证实例)
- 上线补弹离线期间收到的消息只做一次:起点只在「可达 → 不可达」的边界写,恢复时取最近 5 条按时间升序推

发布内容批量
- POST /notifications/bulk、POST /homeworks/bulk:**单班失败不影响整批**,逐班返回结果
- 作业的科目名跨班**按名匹配**已有课程,找不到就整班记失败,绝不自动建课
  (自动建课会把创建者写成任课老师,等于越权改任教关系)
- 通知与作业同口径按「所属日期」归档,新增 /notifications/days 与 /notifications/creators

BREAKING CHANGE: 能不能做某件事不再看角色名,而是看权限键(GET /api/permissions/me)。
未分组的账号按角色默认模板生效,行为与 1.2.0 一致;分组之后生效集合只由组的并集决定。
服务端首次启动会自动应用 1 个数据库迁移(权限组 3 表 / AppSetting / 客户端设备·命令·安装包 /
AiAudit / Notification.assignDate / User.careMode,历史通知按本地日期回填),升级前请先备份。
This commit is contained in:
LoveChengke committed 2026-10-11 11:49:32 +08:00
1 parent e51879667a
commit 817af02357
131 files changed
+12995 -538

No files matched your search

@@ -4,6 +4,7 @@ import { useRouter } from 'vue-router';
import { ElButton, ElNotification } from 'element-plus';
import type { UpdateInfo } from '@classhelper/shared';
import {
replayMissedNotifications,
startIslandBridge,
stopIslandBridge,
subscribeIslandMarkAllRead,
@@ -72,6 +73,20 @@ function showUpdateAvailable(info: UpdateInfo): void {
});
}
/**
* 上线补弹「离线期间收到的消息」(需求 11)。
*
* **为什么订阅放在 App.vue**:与 `onUpdateAvailable` 同一条理由 —— App.vue 整个应用生命周期
* 只挂载一次,而 `ClientLayout` 会随"登出 → 登录"反复挂载。而且恢复事件本身是"可达性由不可达
* 变为可达"的那一刻,一次会话里可能发生多次,处理器必须是**幂等**的(`replayMissedNotifications`
* 推完就清掉离线起点,重复触发时第二次读到空值、直接返回 0)。
*
* 处理器是具名函数:`stores/app.ts` 的订阅表按函数引用 off,匿名箭头函数在 onUnmounted 里摘不掉。
*/
function handleServerRecovered(): void {
void replayMissedNotifications();
}
/**
* 启动流程:
* 1) 从主进程配置恢复服务器地址与登录令牌
@@ -107,6 +122,9 @@ onMounted(async () => {
subscribeIslandMarkRead();
subscribeIslandMarkAllRead();
// 离线期间收到的消息:可达性恢复的那一刻补弹到灵动岛(App.vue 常驻,所以每次恢复只跑一次)
appStore.onServerRecovered(handleServerRecovered);
// 启动自动检查发现新版本时由主进程推过来(订阅只挂一次,理由见 showUpdateAvailable)
window.desktop?.onUpdateAvailable?.(showUpdateAvailable);
@@ -129,6 +147,7 @@ onMounted(async () => {
});
onUnmounted(() => {
appStore.offServerRecovered(handleServerRecovered);
stopIslandBridge();
});
</script>
@@ -1048,6 +1048,15 @@ export async function layoutChromeSelfTest(): Promise<SmokeCheckResult> {
// 2.2) 导轨必须"一眼看全":先把设置组展开(11 行图标 = 最坏情况),再断言菜单区没有纵向溢出。
// 折叠态页脚必须把**高度**也收成 0 —— 只淡出不留高度的话,那 ~70px 会把最后两个图标
// 顶出可视区,用户就得上下滑动(反馈原话:"菜单图标无法完全显示需要上下滑动")。
//
// ⚠️ 量之前必须等页脚真的收成 0 高:宽度到 64px 与页脚收拢各有一条 260ms 过渡,
// 而 `--nav-ease`(Material 曲线)在 74% 处就越过"宽度 ≤ 80px"这个等待条件,
// 此时页脚还剩十几像素 —— 直接量 `.menu` 会读出"溢出 16px"的**假红**
// (实测出现过一次:同一份产物上一次全绿、下一次红)。这里等的是**稳态几何**,
// 与这条断言本来的意图一致(CSS 里那句"量到的是稳态")。
const railFooter = document.querySelector<HTMLElement>('.aside-footer');
await waitUntil(() => (railFooter?.offsetHeight ?? 0) <= 1, 2000);
const settingsItem = Array.from(
document.querySelectorAll<HTMLElement>('.aside .el-sub-menu .el-menu-item'),
).find((element) =>
@@ -6,9 +6,9 @@ import {
type NotificationDto,
type ScheduleDto,
} from '@classhelper/shared';
import { scheduleApi } from '../api/index.js';
import { notificationApi, scheduleApi } from '../api/index.js';
import { fetchWithCache } from '../cache/index.js';
import { useAppStore } from '../stores/app.js';
import { clearOfflineSince, readOfflineSince, useAppStore } from '../stores/app.js';
import { useAuthStore } from '../stores/auth.js';
import { useNotificationStore } from '../stores/notifications.js';
import { useRealtimeStore } from '../stores/realtime.js';
@@ -190,6 +190,81 @@ export function pushCallToIsland(call: NotificationDto): void {
});
}
/* ------------------------------------------------------------ 补弹离线期间收到的消息(需求 11) */
/**
* 补弹条数上限。
*
* 灵动岛的多条通知列表默认只显示 `ISLAND_LIST_METRICS.defaultVisibleRows`(3)条 +
* 「展开更多(还有 N 条)」。所以一条不补、和一次补十几条,都是同样的阅读体验 ——
* 封顶 5 条 = 3 条可见 + 2 条藏在"展开更多"里,正好是打开就能读完的量;
* 补太多只会让"展开更多"变成一个没有意义的按钮。
*/
const REPLAY_MAX_COUNT = 5;
/**
* 上线后补弹「离线期间收到的消息」(需求 11)。
*
* 调用时机:`App.vue` 订阅 `useAppStore().onServerRecovered`,也就是**可达性由不可达变为可达**
* 的那一刻(断网期间的实时通道是断的,那些通知既没弹过、也没进过用户的视野)。
*
* 数据来源复用既有的通知接口(`notificationApi.list({ unreadOnly: true })`):
* 客户端本来就是离线优先的(`fetchWithCache` 会把数据落 IndexedDB),**不为此新建数据源** ——
* 补弹只需要"服务端现在有哪些未读",而通知列表本来就是这个问题的答案。
*
* 实现上有四条约定:
* 1. **没有离线起点就直接返回 0**(首次启动 / 一直在线):离线起点只由
* `stores/app.ts` 在"由可达变不可达"的那一刻写入,没有它就说明这段时间根本没断过网,
* 此时补弹等于把**历史未读**全弹一遍,那不是「离线期间收到的」。
* 2. **只补离线起点之后创建的**(`createdAt > offlineSince`),并且在服务端排序之外再排一次
* **按时间升序**投递 —— 顺序投递才能让灵动岛的队列保持时间顺序。
* 3. **取最近的 5 条**(升序列表的尾部):断网一天可能积压几十条,取最早的那 5 条等于
* 让用户先看最旧的、最新的反而被"展开更多"挡住。取最近的 5 条更符合"我刚错过了什么"。
* 4. **推完就清掉离线起点**:同一次离线只补一次,否则每次可达性抖动都会重复弹同一批。
*
* @returns 实际补弹的条数(0 = 没补)
*/
export async function replayMissedNotifications(): Promise<number> {
// 冒烟保护:`verify:desktop` / `verify:packaged` 有一条「灵动岛队列」的断言链
// (100+ 条断言量的是卡片的条数、顺序、高度与"展开更多"的分页),
// 冒烟脚本会反复断开/恢复网络,注入的合成通知与这里的补弹会互相打乱队列,
// 让那些断言随机变红。冒烟模式下**直接跳过补弹**(也不动离线起点),
// 补弹本身由人工/单元路径覆盖,不进冒烟。
if (window.desktop?.smokeTest === true) return 0;
const offlineSince = readOfflineSince();
if (!offlineSince) return 0;
const sinceMs = Date.parse(offlineSince);
if (Number.isNaN(sinceMs)) {
// 存储里是坏值(手工改过 / 旧版本写入格式不同):清掉,别让它永远挡住补弹
clearOfflineSince();
return 0;
}
let unread: NotificationDto[];
try {
unread = await notificationApi.list({ unreadOnly: true });
} catch {
// 刚恢复就又断了(或服务端还没真正就绪):保留离线起点,等下一次恢复再补
return 0;
}
const missed = unread
.filter((item) => {
const at = Date.parse(item.createdAt);
return !Number.isNaN(at) && at > sinceMs;
})
.sort((a, b) => Date.parse(a.createdAt) - Date.parse(b.createdAt));
const picked = missed.slice(-REPLAY_MAX_COUNT);
for (const item of picked) pushNotificationToIsland(item);
// 无论补到几条都清掉:这一轮离线已经被处理过了
clearOfflineSince();
console.info(`[离线补弹] 补弹离线消息 ${picked.length} 条(离线起点 ${offlineSince})`);
return picked.length;
}
/**
* 灵动岛点了"标为已读" → 在通知中心里也标记已读(并刷新未读红点)。
* 由 App.vue 在挂载时订阅一次。
@@ -25,9 +25,9 @@ const ui = useUiStore();
*
* - **一级项**:课表 / 作业 / 通知 / 成绩 —— 直接铺在侧栏上,**不再套「学习」分组**。
* 分组标题白占一行、还得多点一次展开,折叠成图标导轨时尤其明显(用户要求拆掉)。
* - **分组**:只剩「设置」(通用 / 外观 / 灵动岛 / 提醒 / 账号 / 关于,各自是独立路由)。
* 6 个子项平铺太长,保留分组与"默认只展开当前路由所在分组"。折叠后是图标导轨,
* 分组子项与一级项一样以图标列出(见 styles/index.css 的折叠态规则)。
* - **分组**:只剩「设置」(通用 / 外观 / 灵动岛 / 提醒 / 账号 / 关于,各自是独立路由;
* 开发者模式下再多一个「开发者」)。6 个子项平铺太长,保留分组与"默认只展开当前路由所在分组"。
* 折叠后是图标导轨,分组子项与一级项一样以图标列出(见 styles/index.css 的折叠态规则)。
*
* 顶栏左侧汉堡按钮把整栏收成图标导轨(状态持久化在主进程配置里)。
*/
@@ -38,20 +38,38 @@ const primaryItems = [
{ path: '/grades', title: '成绩', icon: 'Trophy' },
];
const menuGroups = [
/** 「设置」分组的常规子项(顺序即侧栏顺序) */
const settingItems = [
{ path: '/settings/general', title: '通用', icon: 'Tools' },
{ path: '/settings/appearance', title: '外观', icon: 'Brush' },
{ path: '/settings/island', title: '灵动岛', icon: 'MagicStick' },
{ path: '/settings/reminder', title: '提醒', icon: 'AlarmClock' },
{ path: '/settings/account', title: '账号', icon: 'UserFilled' },
{ path: '/settings/about', title: '关于', icon: 'InfoFilled' },
];
/**
* 菜单分组(**computed**:子项随开发者模式变化,见下)。
*
* 「开发者」(需求 10)只在 `ui.developerMode === true` 时出现 —— 它是个排查问题的入口
* (版本/日志/更新/DevTools),常驻只会让教室机器上的使用者点进一个看不懂的页面。
*
* 图标用 `Connection`:新增图标必须同时进 `renderer/icons.ts` 的注册表,
* 而那是本任务范围外的文件 —— 所以**只用已注册图标**(`scripts/check-icons.mjs`
* 会在构建前拦下未注册的名字)。
*
* 折叠成图标导轨后多一行图标:开启开发者模式是用户自己的选择,默认关闭 ⇒
* 冒烟(默认配置)里的导轨几何与"不出现滚动条"断言不受影响。
*/
const menuGroups = computed(() => [
{
title: '设置',
icon: 'Setting',
items: [
{ path: '/settings/general', title: '通用', icon: 'Tools' },
{ path: '/settings/appearance', title: '外观', icon: 'Brush' },
{ path: '/settings/island', title: '灵动岛', icon: 'MagicStick' },
{ path: '/settings/reminder', title: '提醒', icon: 'AlarmClock' },
{ path: '/settings/account', title: '账号', icon: 'UserFilled' },
{ path: '/settings/about', title: '关于', icon: 'InfoFilled' },
],
items: ui.developerMode
? [...settingItems, { path: '/settings/developer', title: '开发者', icon: 'Connection' }]
: settingItems,
},
];
]);
/* -------------------------------------------------------------- 导航指示器 */
@@ -70,18 +88,46 @@ const menuGroups = [
*/
const indicator = ref({ x: 0, y: 0, width: 0, height: 0, visible: false });
/**
* 底片的**裁剪框**:与 `.menu` 的滚动视口逐像素重合。
*
* 底片挂在 `.aside` 上,而菜单项是在 `.menu` 里滚动的(`.menu` 是 `flex:1 + min-height:0 +
* overflow-y:auto`,设置组展开时内容约 606px 会超过窗口高度)。激活项被滚出视口时,
* 底片会跟着它跑到品牌区或页脚上 —— 套一层视口大小的 `overflow:hidden`,
* 就是让底片"只在菜单看得见的地方存在"。
*/
const clipStyle = ref<Record<string, string>>({
top: '0px',
left: '0px',
width: '0px',
height: '0px',
});
function syncIndicator(): void {
const aside = document.querySelector<HTMLElement>('.aside.ch-nav');
const active = aside?.querySelector<HTMLElement>('.el-menu-item.is-active');
if (!aside || !active) {
const scroller = aside?.querySelector<HTMLElement>('.menu') ?? null;
if (!aside || !scroller) {
indicator.value = { ...indicator.value, visible: false };
return;
}
const asideRect = aside.getBoundingClientRect();
const boxRect = scroller.getBoundingClientRect();
// 底片的坐标一律相对「菜单视口」,不再相对 `.aside` —— 裁剪框把两者的原点对齐了
clipStyle.value = {
top: `${boxRect.top - asideRect.top}px`,
left: `${boxRect.left - asideRect.left}px`,
width: `${boxRect.width}px`,
height: `${boxRect.height}px`,
};
const active = scroller.querySelector<HTMLElement>('.el-menu-item.is-active');
if (!active) {
indicator.value = { ...indicator.value, visible: false };
return;
}
const rect = active.getBoundingClientRect();
indicator.value = {
x: rect.left - asideRect.left,
y: rect.top - asideRect.top,
x: rect.left - boxRect.left,
y: rect.top - boxRect.top,
width: rect.width,
height: rect.height,
visible: rect.width > 0 && rect.height > 0,
@@ -114,6 +160,32 @@ function scheduleIndicatorSync(): void {
});
}
/**
* 菜单内部滚动:底片要**当帧**跟上,而且这一路上不能走过渡动画。
*
* 两点都和"滚动是连续手势"有关:
* 1. 不能用 `scheduleIndicatorSync()`(rAF 推后一帧)—— 快速滚动时底片会肉眼可见地落后;
* 滚动事件本身在布局之后派发,在这里同步量一次不会再插入一次强制布局。
* 2. 不能走 `.nav-indicator` 的 LAYOUT 弹簧(397ms)—— 那是"切换菜单项"的动画参数,
* 用在滚动上就成了"底片慢吞吞地追菜单项"。所以滚动期间挂 `is-following` 关掉过渡,
* 停手 140ms 后恢复,下一次点菜单项照样有滑动动画。
*/
const SCROLL_SETTLE_MS = 140;
let menuScroller: HTMLElement | null = null;
let scrollSettleTimer = 0;
const indicatorFollowing = ref(false);
function handleMenuScroll(): void {
if (!indicatorFollowing.value) indicatorFollowing.value = true;
if (scrollSettleTimer) window.clearTimeout(scrollSettleTimer);
scrollSettleTimer = window.setTimeout(() => {
scrollSettleTimer = 0;
indicatorFollowing.value = false;
}, SCROLL_SETTLE_MS);
syncIndicator();
}
/**
* 首次测量放在 `onMounted`:子组件先于父组件挂载完成,此刻 `.el-menu-item.is-active`
* 已在文档里,量完再让浏览器首帧绘制 —— 指示器第一次出现就是正确位置,不会从左上角滑过去。
@@ -125,6 +197,11 @@ function scheduleIndicatorSync(): void {
onMounted(() => {
syncIndicator();
const aside = document.querySelector<HTMLElement>('.aside.ch-nav');
if (aside) {
// 菜单自己的滚动容器:翻菜单时底片必须跟着走(用户反馈的「上下滑动时项目选择块不移动」)
menuScroller = aside.querySelector<HTMLElement>('.menu');
menuScroller?.addEventListener('scroll', handleMenuScroll, { passive: true });
}
if (aside && typeof ResizeObserver !== 'undefined') {
asideObserver = new ResizeObserver(scheduleIndicatorSync);
asideObserver.observe(aside);
@@ -134,6 +211,10 @@ onMounted(() => {
onUnmounted(() => {
if (indicatorFrame) cancelAnimationFrame(indicatorFrame);
indicatorFrame = 0;
if (scrollSettleTimer) window.clearTimeout(scrollSettleTimer);
scrollSettleTimer = 0;
menuScroller?.removeEventListener('scroll', handleMenuScroll);
menuScroller = null;
asideObserver?.disconnect();
asideObserver = null;
});
@@ -172,7 +253,7 @@ const activeMenu = computed(() => route.path);
/** 当前路由所属的分组标题(用于"只默认展开所在分组",与 ClassIsland 一致) */
const activeGroupTitle = computed(() => {
const group = menuGroups.find((item) => item.items.some((entry) => route.path === entry.path));
const group = menuGroups.value.find((item) => item.items.some((entry) => route.path === entry.path));
// 落在**一级项**(课表/作业/通知/成绩)上没有所属分组 —— 返回 null,别拿某个组的名字顶上去
return group?.title ?? null;
});
@@ -190,7 +271,7 @@ const openedGroups = ref<string[]>(activeGroupTitle.value ? [activeGroupTitle.va
watch(
() => route.path,
async (path) => {
const group = menuGroups.find((item) => item.items.some((entry) => path === entry.path));
const group = menuGroups.value.find((item) => item.items.some((entry) => path === entry.path));
if (!group) return;
// 展开当前组(不主动关闭用户已展开的其它组)
await nextTick();
@@ -215,7 +296,7 @@ function go(name: string): void {
/** 开发期自检:菜单路径必须存在于路由表中 */
if (import.meta.env.DEV) {
const knownPaths = new Set(router.getRoutes().map((item) => item.path));
for (const group of menuGroups) {
for (const group of menuGroups.value) {
for (const item of group.items) {
if (!knownPaths.has(item.path)) {
console.error(`[ClientLayout] 菜单项未注册对应路由:${item.path}`);
@@ -301,8 +382,16 @@ onUnmounted(() => {
<span class="brand-text">ClassHelper</span>
</div>
<!-- 激活项的滑动指示器:单个底片在菜单项之间平移,位置由 syncIndicator() 量出来。
pointer-events:none 是必需的 —— 它盖在菜单项上,否则会把点击吃掉。 -->
<div class="nav-indicator" :style="indicatorStyle" aria-hidden="true" />
外层 .nav-indicator-clip 与 .menu 的视口重合(overflow:hidden),
把"跟着菜单滚出视口"的底片裁掉,不让它盖到品牌区/页脚上。
两层都 pointer-events:none —— 底片盖在菜单项上,否则会把点击吃掉。 -->
<div class="nav-indicator-clip" :style="clipStyle" aria-hidden="true">
<div
class="nav-indicator"
:class="{ 'is-following': indicatorFollowing }"
:style="indicatorStyle"
/>
</div>
<el-menu
ref="menuRef"
:default-active="activeMenu"
@@ -444,6 +533,18 @@ onUnmounted(() => {
position: relative;
}
/*
* 指示器的裁剪框:位置与尺寸每帧由 syncIndicator() 量成"与 .menu 视口重合"。
* 少了它,激活项被滚出菜单视口时底片会跑到品牌区/页脚上(用户反馈「上下滑动时
* 项目选择块不移动」的那次修复里一起加的)。
*/
.nav-indicator-clip {
position: absolute;
z-index: 0;
overflow: hidden;
pointer-events: none;
}
/*
* 导航指示器:一个跟着激活项平移的底片,承载了原先"激活项底色 + 左侧强调条"两件事。
*
@@ -459,7 +560,6 @@ onUnmounted(() => {
position: absolute;
top: 0;
left: 0;
z-index: 0;
border-radius: var(--ch-radius-control);
background: var(--ch-accent-soft);
/* 必须穿透:它盖在菜单项上,否则点击会被它吃掉 */
@@ -472,6 +572,14 @@ onUnmounted(() => {
opacity var(--ch-dur-fast) var(--ch-ease-out);
}
/*
* 菜单滚动期间(含停手后的 140ms)关掉过渡:滚动是连续手势,底片要"贴在"菜单项上一起走,
* 而不是每帧都启动一次 397ms 的弹簧去追。松手后恢复,点菜单项照样有滑动动画。
*/
.nav-indicator.is-following {
transition: none;
}
/* 左侧强调条(原有观感,现在跟着底片一起滑) */
.nav-indicator::before {
content: '';
@@ -1,5 +1,6 @@
import { createRouter, createWebHashHistory, type RouteRecordRaw } from 'vue-router';
import { useAuthStore } from '../stores/auth.js';
import { useUiStore } from '../stores/ui.js';
/**
* Electron 生产环境通过 file:// 加载页面,无法使用 history 模式,
@@ -82,6 +83,18 @@ const routes: RouteRecordRaw[] = [
component: () => import('../views/settings/AboutView.vue'),
meta: { title: '关于' },
},
{
/**
* 开发者(需求 10)。入口只在 `config.developerMode === true` 时出现在侧栏上,
* 但**路由始终注册**:关掉开关后侧栏项消失,已打开的页面靠一条守卫弹回「通用」,
* 不做成条件注册 —— 条件注册会让 `router.getRoutes()` 随配置变化,
* ClientLayout 的开发期自检与直接输 URL 的行为都会变得难以预期。
*/
path: 'settings/developer',
name: 'settings-developer',
component: () => import('../views/settings/DeveloperSettingsView.vue'),
meta: { title: '开发者' },
},
],
},
{ path: '/:pathMatch(.*)*', redirect: '/schedule' },
@@ -99,6 +112,16 @@ router.beforeEach((to) => {
return true;
}
if (!auth.isAuthenticated) return { name: 'login' };
/**
* 开发者页(需求 10)只在开发者模式开启时可进:侧栏项本身也是条件显示的,
* 但配置可能是在**停留在这个页面时**被关掉的(「通用」页的开关),
* 所以需要这条守卫把它弹回「通用」,不让用户在看一个"已经不该存在"的页面。
*
* 这里读的是 ui store 里的状态(由 `ui.init()` 在首屏前从主进程配置恢复),
* 不额外调 `window.desktop.getConfig()` —— 导航守卫是同步高频路径,
* 每次跳转都跨一次 contextBridge 不值得。
*/
if (to.name === 'settings-developer' && !useUiStore().developerMode) return { name: 'settings-general' };
return true;
});
@@ -13,6 +13,51 @@ import { DEFAULT_SERVER, normalizeServerUrl } from '../config.js';
type RecoveryHandler = () => void;
/**
* 「本次离线从什么时候开始」的本地时间戳键(需求 11)。
*
* 为什么用 localStorage 而不是主进程配置(config.json):
* 它是一个**瞬时状态**,只描述"当前这一轮断网",一旦补弹完成(或进程重启后重新联网)就作废,
* 不需要跨进程读、也不需要跟着设备身份走。放 localStorage 有三点好处:
* - 写入发生在每次请求的**可达性回调**里(高频路径),localStorage 是同步内存写,
* 不会像 saveConfig 那样排一次主进程 IPC + 120ms 合并窗口;
* - 它是**渲染进程自己**的读-改-清闭环(bridge.ts 读它 → 补弹 → 清掉),不跨越 contextBridge;
* - 跨重启也够用:网页存储随 profile 持久化,补弹窗口本来就只关心"最近一次离线"。
*/
const OFFLINE_SINCE_KEY = 'classhelper.offlineSince';
/**
* 记下"本次离线从什么时候开始"(ISO 字符串)。
* 读不到 / 写不进(隐私模式、存储被清)时静默跳过 —— 补弹只是锦上添花,不该影响可达性上报。
*/
function markOfflineSince(): void {
try {
const now = new Date().toISOString();
localStorage.setItem(OFFLINE_SINCE_KEY, now);
console.info(`[离线] 已记录本次离线起点:${now}`);
} catch {
// 存储不可用:这次不补弹,但联网后的恢复流程照常
}
}
/** 读本次离线起点(ISO 字符串);没有记录(首次启动 / 一直在线)返回 null */
export function readOfflineSince(): string | null {
try {
return localStorage.getItem(OFFLINE_SINCE_KEY);
} catch {
return null;
}
}
/** 清掉离线起点:补弹完成后调用,避免同一次离线被重复补弹 */
export function clearOfflineSince(): void {
try {
localStorage.removeItem(OFFLINE_SINCE_KEY);
} catch {
// 清不掉也不影响功能:下一次"由可达变不可达"会覆盖它
}
}
/**
* 应用级状态:服务器地址、可达性、离线缓存统计、同步时间。
* 「联网后自动同步」的触发点就在 ping() 里:不可达 -> 可达 时通知所有订阅者刷新数据。
@@ -48,13 +93,22 @@ export const useAppStore = defineStore('app', () => {
recoveryHandlers.delete(handler);
}
/** 请求拦截器会把每次请求的结果回报过来,这里据此维护可达性 */
/**
* 请求拦截器会把每次请求的结果回报过来,这里据此维护可达性。
*
* 「由可达变不可达」的那一刻顺手记下离线起点(需求 11 的补弹基准):
* 只在**边界**上写,不在"一直不可达"的每次请求上重复覆盖,否则补弹窗口会被不停地
* 推迟到"最后一次失败",离线期间收到的通知就永远落在窗口之外了。
*/
setReachabilityReporter((reachable) => {
if (reachable && !serverReachable.value && initialized.value) {
serverReachable.value = true;
notifyRecovered();
return;
}
if (!reachable && serverReachable.value && initialized.value) {
markOfflineSince();
}
serverReachable.value = reachable;
});
@@ -68,6 +122,9 @@ export const useAppStore = defineStore('app', () => {
if (!serverReachable.value && initialized.value) notifyRecovered();
serverReachable.value = true;
} else {
// 健康探针是机器**空闲时唯一**的可达性信号(没有任何业务请求在跑),
// 所以这条路径也要记离线起点,否则空闲断网期间收到的通知补不回来。
if (serverReachable.value && initialized.value) markOfflineSince();
serverReachable.value = false;
}
}
@@ -3,24 +3,47 @@ import { defineStore } from 'pinia';
import type { DesktopStoredConfig } from '../../types/desktop.js';
/**
* 界面偏好(主题 / 侧边栏折叠)。
* 界面偏好(主题 / 侧边栏折叠 / 关怀模式)。
*
* 持久化在主进程配置(DesktopStoredConfig.theme / sidebarCollapsed)里,
* 持久化在主进程配置(DesktopStoredConfig.theme / sidebarCollapsed / careMode)里,
* 与灵动岛外观等设置同一套落盘机制;浏览器调试(无 window.desktop)回落 localStorage。
* 深色主题 = 在 <html> 上挂 .dark 类(Element Plus dark css-vars + styles/index.css 的
* html.dark 品牌变量),应用主题的全部入口都必须走 setTheme,保证类名与配置同步。
*
* 关怀模式 = 在 <html> 上挂 .care-mode 类(styles/index.css 末尾那个集中覆盖块),
* 只放大正文与控件字号,不动任何几何令牌 —— 理由写在那个块的注释里。
*/
const THEME_KEY = 'classhelper.theme';
const SIDEBAR_KEY = 'classhelper.sidebarCollapsed';
const CARE_MODE_KEY = 'classhelper.careMode';
const DEVELOPER_MODE_KEY = 'classhelper.developerMode';
function applyThemeClass(theme: 'light' | 'dark'): void {
document.documentElement.classList.toggle('dark', theme === 'dark');
}
/**
* 关怀模式的类名开关。**只碰这一个类**:放大规则全在 CSS 里,
* JS 侧不逐个元素改字号(那样既漏元素又把主题与字号耦合在一起)。
*/
function applyCareModeClass(enabled: boolean): void {
document.documentElement.classList.toggle('care-mode', enabled);
}
export const useUiStore = defineStore('ui', () => {
const theme = ref<'light' | 'dark'>('light');
const sidebarCollapsed = ref(false);
const careMode = ref(false);
/**
* 开发者模式(需求 10)。
*
* 它既是主进程配置(`config.developerMode`,决定日志级别),也是**侧栏的一项** ——
* 所以必须放在 store 里:关掉开关时「开发者」菜单项要立刻消失、路由守卫也要立刻生效,
* 而「通用」页与 `ClientLayout.vue` 是两个不同的组件,靠各自的本地 ref 是传不过去的
* (此前"改完设置要重启客户端才看到"多半就是这个原因)。
*/
const developerMode = ref(false);
/** 启动时从主进程配置恢复(App.vue 的 boot 流程里调用,早于首屏渲染) */
async function init(): Promise<void> {
@@ -29,10 +52,14 @@ export const useUiStore = defineStore('ui', () => {
if (config) {
theme.value = config.theme === 'dark' ? 'dark' : 'light';
sidebarCollapsed.value = config.sidebarCollapsed === true;
applyCareMode(config.careMode === true);
developerMode.value = config.developerMode === true;
}
} else {
theme.value = localStorage.getItem(THEME_KEY) === 'dark' ? 'dark' : 'light';
sidebarCollapsed.value = localStorage.getItem(SIDEBAR_KEY) === '1';
applyCareMode(localStorage.getItem(CARE_MODE_KEY) === '1');
developerMode.value = localStorage.getItem(DEVELOPER_MODE_KEY) === '1';
}
applyThemeClass(theme.value);
}
@@ -66,8 +93,64 @@ export const useUiStore = defineStore('ui', () => {
void setSidebarCollapsed(!sidebarCollapsed.value);
}
return { theme, sidebarCollapsed, init, setTheme, toggleTheme, setSidebarCollapsed, toggleSidebar };
/**
* 应用关怀模式(需求 14):只挂类名 + 记状态,**不落盘**。
* 启动时由 `init()` 在首屏渲染前调用,所以刷新页面不会看到"先正常、后放大"的跳变。
*/
function applyCareMode(enabled: boolean): void {
careMode.value = enabled;
applyCareModeClass(enabled);
}
/**
* 切换关怀模式(「通用」设置页的开关):立刻生效并写回配置。
*
* 注意:用户明确开启时**不放大侧栏导轨**(见 styles/index.css 的 care-mode 块),
* 也**不做**任何 AI 助手按钮的联动 —— 本客户端目前没有助手入口,那条联动只存在于
* Web 管理端;这里不为了"看起来对称"去造一个入口。
*/
async function setCareMode(enabled: boolean): Promise<void> {
applyCareMode(enabled);
if (window.desktop) {
await window.desktop.saveConfig({ careMode: enabled }).catch(() => undefined);
} else {
localStorage.setItem(CARE_MODE_KEY, enabled ? '1' : '0');
}
}
/**
* 切换开发者模式(「通用」设置页的开关):立刻生效并写回配置。
*
* 打开之后有三件事同时发生,这里只负责**状态与落盘**:
* 1. 侧栏「设置」分组里出现「开发者」项(`ClientLayout.vue` 按 `ui.developerMode` 渲染);
* 2. `main/index.ts` 在下次启动时把日志级别调到 debug(`logger.setVerbose`)——
* 本次会话的日志级别**不重开**,避免开着日志复现问题时把级别改来改去;
* 3. 「通用」页上给出"debug 级日志已开启"的提示。
*/
async function setDeveloperMode(enabled: boolean): Promise<void> {
developerMode.value = enabled;
if (window.desktop) {
await window.desktop.saveConfig({ developerMode: enabled }).catch(() => undefined);
} else {
localStorage.setItem(DEVELOPER_MODE_KEY, enabled ? '1' : '0');
}
}
return {
theme,
sidebarCollapsed,
careMode,
developerMode,
init,
setTheme,
toggleTheme,
setSidebarCollapsed,
toggleSidebar,
applyCareMode,
setCareMode,
setDeveloperMode,
};
});
/** 供类型检查使用(仅引用类型) */
export type UiConfig = Pick<DesktopStoredConfig, 'theme' | 'sidebarCollapsed'>;
export type UiConfig = Pick<DesktopStoredConfig, 'theme' | 'sidebarCollapsed' | 'careMode' | 'developerMode'>;
@@ -95,6 +95,12 @@
--el-border-color-lighter: rgba(0, 0, 0, 0.05);
--el-fill-color-blank: transparent;
--el-font-size-base: 13px;
/* 关怀模式的字号倍率(需求 14)。
* 平时恒为 1:它只作为「当前有没有放大」的单一事实来源,方便 JS 侧读取与断言,
* 真正的放大规则集中在文件末尾的 `html.care-mode` 块里(那里才是覆盖点,
* 且**刻意只动字号**——圆角 / 阴影 / 侧栏宽度等几何令牌一律不碰)。 */
--ch-font-scale: 1;
}
/* ---------------------------------------------------------------- 深色主题 */
@@ -946,3 +952,61 @@ textarea {
::view-transition-new(root) {
z-index: 2;
}
/* ------------------------------------------------------------ 关怀模式(需求 14)
*
* 给视力不佳的用户把**正文与控件**整体放大一档(约 +15%)。由 `stores/ui.ts` 的
* `applyCareMode()` 在首屏渲染前按 `config.careMode` 给 `<html>` 挂/摘 `.care-mode` 类。
*
* 三条刻意的边界,改这个块之前先读:
*
* 1. **只放大字号,不动几何。** 圆角(`--ch-radius-*`)、阴影(`--ch-shadow-*`)、
* 卡片内边距、侧栏宽度一律不碰 —— 放大字号已经会让文字换行,再动几何就是"另一个主题",
* 而且 `verify:desktop` 的多条断言量的是像素几何。
* 2. **侧栏导轨(`.ch-nav`)的条目字号不在这里放大。** §5 第 49 条那套"折叠成图标导轨"
* 的硬要求(导轨宽度、条目高度、折叠态文字必须既无宽度又透明)是按固定几何量出来的,
* 动导航条目字号会让折叠态文字重新占宽而断言变红。导航的可见标签保持原字号。
* 3. **用 `html.care-mode` 而不是 `:root`**:特异性 (0,1,1) 高于普通类选择器,
* 能稳定压过上面那些 `.page-title` / `.el-card__header` 等单类规则,不必写 `!important`。
* 深色主题无关 —— 这里一条颜色都没写。
*/
html.care-mode {
/* 放大倍率放在这里,下面的覆盖全部由它算出来 —— 想再调一档只改这一个数 */
--ch-font-scale: 1.15;
/* 覆盖 Element Plus 的基准字号:按钮、输入框、下拉、分页、消息框等控件都跟着它走
(基准值是 :root 里的 13px,见上面的 Element Plus 变量对齐) */
--el-font-size-base: calc(13px * var(--ch-font-scale));
}
/* 页面标题与副标题(`views/*` 的通用页头) */
html.care-mode .page-title {
font-size: calc(20px * var(--ch-font-scale));
}
html.care-mode .page-subtitle {
font-size: calc(12.5px * var(--ch-font-scale));
}
/* 卡片标题 / 折叠面板标题(这两处在上面被显式写成 13.5px,必须逐条覆盖) */
html.care-mode .el-card__header,
html.care-mode .el-collapse-item__header {
font-size: calc(13.5px * var(--ch-font-scale));
}
/* 表格:表头与单元格一起放大,行高由内容自然撑开(不设固定 height) */
html.care-mode .el-table {
font-size: calc(13px * var(--ch-font-scale));
}
html.care-mode .el-table th.el-table__cell {
font-size: calc(12.5px * var(--ch-font-scale));
}
/* 表单里 Element Plus 自己的标签/说明文字(默认跟着 --el-font-size-base,
* 但 `.el-form-item__label` 在部分页面被行内样式压过,这里统一一档更稳) */
html.care-mode .el-form-item__label,
html.care-mode .el-descriptions__label,
html.care-mode .el-descriptions__content,
html.care-mode .el-message-box__message {
font-size: calc(13px * var(--ch-font-scale));
}
@@ -2,10 +2,13 @@
import { computed, onMounted, onUnmounted, ref } from 'vue';
import { ElMessage } from 'element-plus';
import {
NOTIFICATION_PRIORITIES,
PRIORITY_LABELS,
PRIORITY_TAG_TYPES,
dayKeyLocal,
formatDate,
relativeTime,
shiftDayKey,
type NotificationDto,
type NotificationPriority,
} from '@classhelper/shared';
@@ -24,6 +27,85 @@ const visibleItems = computed(() =>
filter.value === 'unread' ? store.items.filter((item) => !item.read) : store.items,
);
/* ------------------------------------------------------- 按天归档 / 按发布人 / 按类型 */
/**
* 三个筛选都在**已加载的列表**上做,不再请求服务端:
* 客户端是离线优先的(AGENTS.md §5 第 10 条),断网回退缓存时归档功能必须照常可用。
* 口径与服务端一致:按 `assignDate`(本地日期)分组 —— 用 createdAt 的 UTC 切片会把晚上
* 发出来的通知算到第二天(AGENTS.md §5 第 19 条)。
*/
const dayFilter = ref('');
const creatorFilter = ref('');
const priorityFilter = ref('');
/**
* 一条通知归到哪一天。
* `assignDate` 是服务端新加的字段,但**离线缓存里可能还留着加字段之前的旧数据**,
* 所以这里按 createdAt 的本地日期兜底,避免分组头显示成 "undefined"。
*/
function assignDay(item: NotificationDto): string {
return item.assignDate || dayKeyLocal(new Date(item.createdAt));
}
const dayOptions = computed(() => {
const map = new Map<string, number>();
for (const item of store.items) {
const day = assignDay(item);
map.set(day, (map.get(day) ?? 0) + 1);
}
return [...map.entries()]
.sort((a, b) => b[0].localeCompare(a[0]))
.map(([date, count]) => ({ date, count }));
});
const creatorOptions = computed(() => {
const map = new Map<string, { name: string; count: number }>();
for (const item of store.items) {
const previous = map.get(item.createdBy);
map.set(item.createdBy, {
name: item.creator?.name ?? '未知',
count: (previous?.count ?? 0) + 1,
});
}
return [...map.entries()].map(([id, value]) => ({ id, ...value }));
});
const hasFilter = computed(() => Boolean(dayFilter.value || creatorFilter.value || priorityFilter.value));
const filteredItems = computed(() =>
visibleItems.value.filter(
(item) =>
(!dayFilter.value || assignDay(item) === dayFilter.value) &&
(!creatorFilter.value || item.createdBy === creatorFilter.value) &&
(!priorityFilter.value || item.priority === priorityFilter.value),
),
);
/** 按所属日期分块(同一天一块,块头显示"今天/昨天 + 日期 + 条数") */
const groupedItems = computed(() => {
const groups = new Map<string, NotificationDto[]>();
for (const item of filteredItems.value) {
const day = assignDay(item);
const list = groups.get(day);
if (list) list.push(item);
else groups.set(day, [item]);
}
return [...groups.entries()].map(([date, items]) => ({ date, items }));
});
function dayLabel(date: string): string {
const today = dayKeyLocal(new Date());
if (date === today) return '今天';
if (date === shiftDayKey(today, -1)) return '昨天';
return date;
}
function resetFilters(): void {
dayFilter.value = '';
creatorFilter.value = '';
priorityFilter.value = '';
}
async function openDetail(item: NotificationDto): Promise<void> {
current.value = item;
detailVisible.value = true;
@@ -76,6 +158,7 @@ onUnmounted(() => {
<h2 class="page-title">通知</h2>
<p class="page-subtitle">
共 {{ store.items.length }} 条 · 未读 {{ store.unreadCount }} 条
<span v-if="hasFilter">· 筛选后 {{ filteredItems.length }} 条</span>
<el-tag v-if="store.fromCache" size="small" type="warning" effect="plain">离线缓存</el-tag>
</p>
</div>
@@ -92,37 +175,88 @@ onUnmounted(() => {
</div>
<el-card v-loading="store.loading" shadow="never">
<el-empty v-if="visibleItems.length === 0" description="暂无通知" />
<ul v-else class="notice-list">
<li
v-for="item in visibleItems"
:key="item.id"
class="notice-item"
:class="{ unread: !item.read }"
@click="openDetail(item)"
<!-- 按天归档 + 按发布人 + 按类型;都在本地已加载的列表上筛(离线也能用) -->
<div class="notice-filters">
<el-select v-model="dayFilter" placeholder="按天归档" clearable size="small" style="width: 150px">
<el-option
v-for="item in dayOptions"
:key="item.date"
:label="`${item.date}(${item.count})`"
:value="item.date"
/>
</el-select>
<el-select
v-model="creatorFilter"
placeholder="全部发布人"
clearable
size="small"
style="width: 150px"
>
<div class="notice-main">
<div class="notice-title">
<span v-if="!item.read" class="unread-dot"></span>
<el-tag
:type="PRIORITY_TAG_TYPES[item.priority as NotificationPriority]"
size="small"
effect="light"
>
{{ PRIORITY_LABELS[item.priority as NotificationPriority] }}
</el-tag>
<span class="title-text">{{ item.title }}</span>
</div>
<div class="notice-content">{{ item.content }}</div>
<el-option
v-for="item in creatorOptions"
:key="item.id"
:label="`${item.name}(${item.count})`"
:value="item.id"
/>
</el-select>
<el-select
v-model="priorityFilter"
placeholder="全部类型"
clearable
size="small"
style="width: 130px"
>
<el-option
v-for="item in NOTIFICATION_PRIORITIES"
:key="item"
:label="PRIORITY_LABELS[item]"
:value="item"
/>
</el-select>
<el-button v-if="hasFilter" link type="primary" size="small" @click="resetFilters">
清除筛选
</el-button>
</div>
<el-empty v-if="filteredItems.length === 0" description="暂无通知" />
<div v-else class="notice-groups">
<section v-for="group in groupedItems" :key="group.date" class="notice-group">
<div class="notice-group__header">
<span>{{ dayLabel(group.date) }}</span>
<span class="text-muted">{{ group.date }} · {{ group.items.length }} 条</span>
</div>
<div class="notice-meta">
<div>{{ relativeTime(item.createdAt) }}</div>
<div class="text-muted">{{ formatDate(item.createdAt, true) }}</div>
<el-tag v-if="item.read" size="small" type="info" effect="plain">已读</el-tag>
<el-tag v-else size="small" type="danger" effect="plain">未读</el-tag>
</div>
</li>
</ul>
<ul class="notice-list">
<li
v-for="item in group.items"
:key="item.id"
class="notice-item"
:class="{ unread: !item.read }"
@click="openDetail(item)"
>
<div class="notice-main">
<div class="notice-title">
<span v-if="!item.read" class="unread-dot"></span>
<el-tag
:type="PRIORITY_TAG_TYPES[item.priority as NotificationPriority]"
size="small"
effect="light"
>
{{ PRIORITY_LABELS[item.priority as NotificationPriority] }}
</el-tag>
<span class="title-text">{{ item.title }}</span>
</div>
<div class="notice-content">{{ item.content }}</div>
</div>
<div class="notice-meta">
<div>{{ relativeTime(item.createdAt) }}</div>
<div class="text-muted">{{ formatDate(item.createdAt, true) }}</div>
<el-tag v-if="item.read" size="small" type="info" effect="plain">已读</el-tag>
<el-tag v-else size="small" type="danger" effect="plain">未读</el-tag>
</div>
</li>
</ul>
</section>
</div>
</el-card>
<el-drawer v-model="detailVisible" size="46%" :title="current?.title ?? '通知详情'">
@@ -147,6 +281,30 @@ onUnmounted(() => {
</template>
<style scoped>
.notice-filters {
display: flex;
flex-wrap: wrap;
align-items: center;
gap: 8px;
margin-bottom: 12px;
}
.notice-group + .notice-group {
margin-top: 10px;
}
.notice-group__header {
display: flex;
align-items: center;
justify-content: space-between;
gap: 8px;
padding: 6px 6px 4px;
font-size: 12px;
font-weight: 600;
color: var(--ch-text-secondary);
border-bottom: 1px solid var(--ch-border);
}
.notice-list {
list-style: none;
margin: 0;
@@ -0,0 +1,450 @@
<script setup lang="ts">
import { computed, onMounted, ref } from 'vue';
import { ElMessage, ElMessageBox } from 'element-plus';
import { formatDate, relativeTime, type UpdateInfo } from '@classhelper/shared';
import type { ClientAgentStatus, DesktopAppInfo } from '../../../types/desktop.js';
import { useAppStore } from '../../stores/app.js';
import { useUiStore } from '../../stores/ui.js';
/**
* 开发者(需求 10)。
*
* 入口只在 `config.developerMode === true` 时出现在侧栏「设置」分组里(`ClientLayout.vue`),
* 路由守卫也会把"关掉开关后仍停留在这个页面"的用户弹回「通用」。
*
* 本页的定位是**把排查问题时需要的现场集中到一处**,所以刻意不做成"可操作的调试台":
* 每一项都是只读状态 + 一两个既有桥上的动作,数据全部来自 `window.desktop.*`
* 与既有 store,**不新增任何数据源、也不新增文件读写**。
*
* 几条取舍写在各区块的注释里,统一的原则是:
* 「关于」页面向的是所有用户(干净、能截图给管理员),本页面向维护者(原始值、路径、内部开关)。
*/
const appStore = useAppStore();
const ui = useUiStore();
const loading = ref(false);
const appInfo = ref<DesktopAppInfo | null>(null);
const agent = ref<ClientAgentStatus | null>(null);
/* ------------------------------------------------------------ 版本与平台 */
/** 版本、运行时与两个关键路径(用户数据目录 / 配置文件),排查"配置写哪去了"必看 */
async function loadAppInfo(): Promise<void> {
if (!window.desktop?.getAppInfo) return;
appInfo.value = await window.desktop.getAppInfo().catch(() => null);
}
/** 一次性把本页的所有状态拉新(刷新按钮与首次进页面共用) */
async function loadAll(): Promise<void> {
if (!window.desktop) return;
loading.value = true;
try {
await loadAppInfo();
await refreshAgent();
await loadIgnoredVersion();
await appStore.refreshCacheStats();
} finally {
loading.value = false;
}
}
/* ------------------------------------------------------------ 设备与上报 */
/**
* 服务端联动状态:设备尾号 / 最近上报 / 最近错误 / 目标版本 / 待安装版本 / 在线。
*
* 这一块与「通用」页的「服务端联动状态」是同一份数据 —— 有意保留的重叠:
* 排查上报问题时人在「通用」页看现象、在「开发者」页看原因(最近错误原文 + 设备尾号),
* 跳来跳去比重复几个字段更烦。
*/
const beating = ref(false);
const lastHeartbeatText = computed(() => {
const value = agent.value?.lastHeartbeatAt;
return value ? relativeTime(value) : '还没有上报过';
});
const lastErrorText = computed(() => agent.value?.lastError?.trim() || '无');
async function refreshAgent(): Promise<void> {
if (!window.desktop?.getClientAgentStatus) return;
agent.value = await window.desktop.getClientAgentStatus().catch(() => null);
}
async function beatNow(): Promise<void> {
if (!window.desktop?.beatClientNow) return;
beating.value = true;
try {
// 手动上报是"立刻打一次",成功/失败都刷新状态,失败原因展示在「最近错误」里
agent.value = await window.desktop.beatClientNow();
if (agent.value?.lastError) ElMessage.warning(`上报未成功:${agent.value.lastError}`);
else ElMessage.success('已向服务端上报本机状态');
} catch (error) {
ElMessage.error(error instanceof Error ? error.message : '上报失败,请检查网络与登录状态');
} finally {
beating.value = false;
}
}
/* ------------------------------------------------------------ 日志 */
/**
* 日志文件路径。
*
* 桥上没有"读日志内容"的接口(有意不加:日志是主进程的文件,给渲染进程一个读任意文件的
* 入口在安全边界上没有必要),所以这里只**提示路径** + 一个「打开日志目录」。
* 路径由用户数据目录拼出来:主进程的 logger 固定写在 `<userData>/logs/main.log`,
* 单文件 1MB 轮转(写满即改名为 main.old.log),所以"日志丢了"通常是轮转覆盖,不是没写。
*/
const logPathText = computed(() => {
const base = appInfo.value?.userDataPath;
if (!base) return 'logs/main.log(用户数据目录下)';
const sep = (appInfo.value?.platform ?? '').startsWith('win') ? '\\' : '/';
return `${base}${sep}logs${sep}main.log`;
});
async function openLogDir(): Promise<void> {
if (!window.desktop?.openLogDir) return;
const ok = await window.desktop.openLogDir();
if (!ok) ElMessage.warning('打开日志目录失败,请按上面的路径手动前往');
}
/* ------------------------------------------------------------ 更新 */
/**
* 更新检查。
*
* 「立即检查」走 `checkForUpdates(true)`:**强制绕过主进程那 30 分钟缓存**。
* 这是本页与「关于」页的区别 —— 那边用户点检查也可能是缓存结果(省流量),
* 这边维护者要的是"现在到底拿得到什么",所以按钮默认就是强制的。
*/
const checking = ref(false);
const updateInfo = ref<UpdateInfo | null>(null);
const ignoredUpdateVersion = ref('');
async function checkUpdate(force: boolean): Promise<void> {
if (!window.desktop?.checkForUpdates) return;
checking.value = true;
try {
updateInfo.value = await window.desktop.checkForUpdates(force);
} finally {
checking.value = false;
}
}
async function loadIgnoredVersion(): Promise<void> {
if (!window.desktop?.getConfig) return;
const stored = await window.desktop.getConfig().catch(() => null);
ignoredUpdateVersion.value = stored?.ignoredUpdateVersion ?? '';
}
async function ignoreVersion(): Promise<void> {
const version = updateInfo.value?.latestVersion;
if (!version || !window.desktop?.ignoreUpdateVersion) return;
await window.desktop.ignoreUpdateVersion(version);
ignoredUpdateVersion.value = version;
ElMessage.success(`已忽略 v${version}:启动时的自动检查不再提示它`);
}
/** 忽略是可逆的(排查线上"用户说不再提示"时经常要把它清掉),顺手给一个恢复入口 */
async function clearIgnoredVersion(): Promise<void> {
if (!window.desktop?.saveConfig) return;
const saved = await window.desktop.saveConfig({ ignoredUpdateVersion: '' });
ignoredUpdateVersion.value = saved.ignoredUpdateVersion;
ElMessage.success('已恢复该版本的更新提示');
}
/* ------------------------------------------------------------ 调试工具 */
const openingDevTools = ref(false);
/**
* 打开 DevTools(主进程 detached 独立窗口)。
* 冒烟验证模式下主进程会拒绝(多一个窗口会把自动化断言打乱),返回 false —— 这里如实提示。
*/
async function openDevTools(): Promise<void> {
if (!window.desktop?.openDevTools) return;
openingDevTools.value = true;
try {
const ok = await window.desktop.openDevTools();
if (ok) ElMessage.success('已在独立窗口打开开发者工具');
else ElMessage.warning('当前是冒烟验证模式,主进程不允许打开 DevTools');
} catch (error) {
ElMessage.error(error instanceof Error ? error.message : '打开开发者工具失败');
} finally {
openingDevTools.value = false;
}
}
/* ------------------------------------------------------------ 离线缓存 */
/** 与「通用」页同一份缓存统计(这里再看一遍是为了"刷新/清空"不用跳页) */
const storeLabels: Record<string, string> = {
profile: '登录资料',
classes: '班级 / 学期',
schedules: '课表',
homeworks: '作业',
notifications: '通知',
grades: '成绩',
};
const cacheRows = computed(() =>
appStore.cacheStoreStats.map((item) => ({
label: storeLabels[item.store] ?? item.store,
store: item.store,
count: item.count,
updatedAt: item.updatedAt ? formatDate(item.updatedAt, true) : '—',
})),
);
async function clearCache(): Promise<void> {
await ElMessageBox.confirm('清空后离线时将无法查看历史数据,确认继续?', '清空离线缓存', {
type: 'warning',
});
await appStore.clearCache();
ElMessage.success('离线缓存已清空');
}
onMounted(async () => {
await loadAll();
// 带出启动自动检查的结果(这次命中主进程缓存,不会真的再发一次请求)
void checkUpdate(false);
});
</script>
<template>
<div class="page">
<div class="page-header">
<div>
<h2 class="page-title">开发者</h2>
<p class="page-subtitle">版本与平台、设备上报、日志、更新与调试工具</p>
</div>
<el-button :loading="loading" data-test="dev-refresh" @click="loadAll">
<el-icon><Refresh /></el-icon>
刷新
</el-button>
</div>
<el-alert
class="mb-12"
type="warning"
:closable="false"
show-icon
title="仅供排查问题"
description="这一页显示的是原始状态与内部路径,不需要给日常使用者看。关闭「通用 → 开发者模式」后它就会从侧栏消失。"
/>
<el-row :gutter="12">
<el-col :xs="24" :md="12">
<!-- 版本与平台 -->
<el-card shadow="never">
<template #header><span>版本与平台</span></template>
<el-descriptions :column="1" border size="small">
<el-descriptions-item label="客户端版本">
{{ appInfo?.appVersion ?? '—' }}
</el-descriptions-item>
<el-descriptions-item label="运行时">
Electron {{ appInfo?.electron ?? '—' }} · Chromium {{ appInfo?.chrome ?? '—' }} · Node
{{ appInfo?.node ?? '—' }}
</el-descriptions-item>
<el-descriptions-item label="平台">{{ appInfo?.platform ?? '—' }}</el-descriptions-item>
<el-descriptions-item label="用户数据目录">
<span class="mono">{{ appInfo?.userDataPath ?? '—' }}</span>
</el-descriptions-item>
<el-descriptions-item label="配置文件">
<span class="mono">{{ appInfo?.configPath ?? '—' }}</span>
</el-descriptions-item>
<el-descriptions-item label="冒烟验证模式">
<el-tag :type="appInfo?.smokeTest ? 'warning' : 'info'" size="small" effect="plain">
{{ appInfo?.smokeTest ? '是(自动化验证中)' : '否' }}
</el-tag>
</el-descriptions-item>
</el-descriptions>
</el-card>
<!-- 设备与上报 -->
<el-card shadow="never" class="mt-12">
<template #header><span>设备与上报</span></template>
<el-descriptions :column="1" border size="small">
<el-descriptions-item label="连接状态">
<el-tag :type="agent?.online ? 'success' : 'info'" size="small">
{{ agent?.online ? '在线(近期上报成功)' : '离线(等待上报)' }}
</el-tag>
</el-descriptions-item>
<el-descriptions-item label="设备标识尾号">
<span class="mono">{{ agent?.deviceKeyTail || '—' }}</span>
</el-descriptions-item>
<el-descriptions-item label="最近上报">{{ lastHeartbeatText }}</el-descriptions-item>
<el-descriptions-item label="服务端目标版本">
{{ agent?.updateTargetVersion || '无(保持当前版本)' }}
</el-descriptions-item>
<el-descriptions-item label="待安装版本">
{{ agent?.pendingUpdateVersion || '无' }}
</el-descriptions-item>
<el-descriptions-item label="最近错误">
<span :class="{ 'text-danger': lastErrorText !== '无' }">{{ lastErrorText }}</span>
</el-descriptions-item>
</el-descriptions>
<div class="toolbar mt-12">
<el-button type="primary" :loading="beating" data-test="dev-beat-now" @click="beatNow">
立即上报
</el-button>
<el-button :loading="loading" @click="loadAll">刷新状态</el-button>
</div>
</el-card>
</el-col>
<el-col :xs="24" :md="12">
<!-- 日志 -->
<el-card shadow="never">
<template #header><span>日志</span></template>
<el-descriptions :column="1" border size="small">
<el-descriptions-item label="日志文件">
<span class="mono">{{ logPathText }}</span>
</el-descriptions-item>
<el-descriptions-item label="日志级别">
<el-tag :type="ui.developerMode ? 'success' : 'info'" size="small" effect="plain">
{{ ui.developerMode ? 'debug(开发者模式)' : 'info' }}
</el-tag>
</el-descriptions-item>
</el-descriptions>
<p class="text-muted mt-12">
单个日志文件 1MB 轮转:写满后改名为 main.old.log,新内容写进 main.log。
所以"日志里找不到某次崩溃"多半是被轮转覆盖了,不是没写。
</p>
<!-- 不在这里用 <strong> 强调:中文整行的显示宽度是字符数的两倍,
而 Vue 模板里夹了行内元素的长句会被 Prettier 折行并插入空格,
渲染出来句子中间就多一个空格。要强调就单独起一行文字。 -->
<p v-if="ui.developerMode" class="text-muted">
debug 级日志已开启:级别在主进程启动时读取,改完开关后需重启客户端才生效。
</p>
<div class="toolbar mt-12">
<el-button data-test="dev-open-log-dir" @click="openLogDir">打开日志目录</el-button>
</div>
</el-card>
<!-- 更新 -->
<el-card shadow="never" class="mt-12">
<template #header><span>更新</span></template>
<div class="toolbar">
<el-button :loading="checking" data-test="dev-check-update" @click="checkUpdate(true)">
强制检查更新
</el-button>
<span class="text-muted">绕过主进程 30 分钟缓存,直接问 GitHub</span>
</div>
<el-descriptions :column="1" border size="small" class="mt-12">
<el-descriptions-item label="本次结果">
<template v-if="checking">正在检查…</template>
<template v-else-if="!updateInfo">尚未检查</template>
<template v-else-if="!updateInfo.ok">
<span class="text-muted">{{ updateInfo.error ?? '暂时无法检查更新' }}</span>
</template>
<template v-else-if="updateInfo.hasUpdate">
<el-tag size="small" type="success" effect="light">
有新版本 v{{ updateInfo.latestVersion }}
</el-tag>
<span class="text-muted">当前 v{{ updateInfo.currentVersion }}</span>
</template>
<template v-else>
<el-tag size="small" type="info" effect="plain">已是最新版本</el-tag>
<span class="text-muted">v{{ updateInfo.currentVersion }}</span>
</template>
</el-descriptions-item>
<el-descriptions-item label="检查时间">
{{ updateInfo?.checkedAt ? formatDate(updateInfo.checkedAt, true) : '—' }}
</el-descriptions-item>
<el-descriptions-item label="已忽略的版本">
<template v-if="ignoredUpdateVersion">
<span class="mono">v{{ ignoredUpdateVersion }}</span>
<el-button link type="primary" size="small" @click="clearIgnoredVersion">恢复提示</el-button>
</template>
<span v-else class="text-muted">无</span>
</el-descriptions-item>
</el-descriptions>
<div class="toolbar mt-12">
<el-button
:disabled="!updateInfo?.latestVersion"
data-test="dev-ignore-version"
@click="ignoreVersion"
>
不再提示该版本
</el-button>
<span class="text-muted">写入配置后,启动时的自动检查会跳过它</span>
</div>
</el-card>
<!-- 调试工具 -->
<el-card shadow="never" class="mt-12">
<template #header><span>调试工具</span></template>
<div class="toolbar">
<el-button :loading="openingDevTools" data-test="dev-open-devtools" @click="openDevTools">
打开 DevTools
</el-button>
<span class="text-muted">独立窗口;冒烟验证模式下不允许打开</span>
</div>
<el-alert class="mt-12" type="info" :closable="false" show-icon title="灵动岛诊断(命令行)">
<template #default>
<p class="diag-copy">灵动岛开合"闪一下"这类问题要的是整屏逐帧取证,界面上给不出这个按钮。</p>
<p class="diag-copy">跑冒烟时带上环境变量即可:</p>
<p class="diag-copy mono">ELECTRON_SMOKE_ISLAND_DIAG=1 pnpm verify:desktop</p>
<p class="diag-copy">它会在常规断言之外,对触摸/鼠标两种模式各跑一次收回动画的逐帧取证,</p>
<p class="diag-copy">帧图与逐帧数据落在 `.cache/island-closing-frames/`。</p>
</template>
</el-alert>
</el-card>
<!-- 离线缓存 -->
<el-card shadow="never" class="mt-12">
<template #header><span>离线缓存(IndexedDB)</span></template>
<el-table :data="cacheRows" size="small" empty-text="暂无缓存数据">
<el-table-column prop="label" label="数据类型" width="130" />
<el-table-column label="条目数" width="90">
<template #default="{ row }">{{ row.count }}</template>
</el-table-column>
<el-table-column label="最近更新" min-width="150">
<template #default="{ row }">{{ row.updatedAt }}</template>
</el-table-column>
</el-table>
<div class="toolbar mt-12">
<el-button @click="appStore.refreshCacheStats()">刷新统计</el-button>
<el-button type="danger" plain @click="clearCache">清空缓存</el-button>
</div>
</el-card>
</el-col>
</el-row>
</div>
</template>
<style scoped>
/*
* 路径与版本号这类"要抄下来发给别人"的值统一用等宽字体(避免 0/O、1/l 看混),
* 并单独放开文本选中 —— body 上关掉了整页选中(更像原生应用),
* 但这一页的路径就是要让人复制的。
*
* 字体栈写死而不新建 `--ch-font-mono` 令牌:全局只有这一处在用,
* 为它加一个主题令牌(还得在 html.dark 里镜像一份)不划算。
*/
.mono {
font-family: 'Cascadia Mono', Consolas, 'Courier New', monospace;
font-size: 12.5px;
word-break: break-all;
user-select: text;
}
.mb-12 {
margin-bottom: 12px;
}
.text-danger {
color: var(--el-color-danger);
}
.diag-copy {
margin: 0 0 6px;
line-height: 1.6;
}
.diag-copy:last-child {
margin-bottom: 0;
}
</style>
@@ -1,12 +1,14 @@
<script setup lang="ts">
import { computed, onMounted, ref } from 'vue';
import { computed, onBeforeUnmount, onMounted, ref } from 'vue';
import { ElMessage, ElMessageBox } from 'element-plus';
import {
HOMEWORK_PHRASE_DEFAULTS,
HOMEWORK_PHRASE_MAX_COUNT,
HOMEWORK_PHRASE_MAX_LENGTH,
formatDate,
relativeTime,
} from '@classhelper/shared';
import type { ClientAgentStatus } from '../../../types/desktop.js';
import { pingHealth, setApiBaseUrl } from '../../api/http.js';
import { normalizeServerUrl } from '../../config.js';
import { useAppStore } from '../../stores/app.js';
@@ -14,6 +16,7 @@ import { useAuthStore } from '../../stores/auth.js';
import { useNotificationStore } from '../../stores/notifications.js';
import { useOnboardingStore } from '../../stores/onboarding.js';
import { useRealtimeStore } from '../../stores/realtime.js';
import { useUiStore } from '../../stores/ui.js';
/**
* 通用设置:服务器连接、离线缓存与作业录入短语。
@@ -24,6 +27,7 @@ const auth = useAuthStore();
const onboarding = useOnboardingStore();
const realtime = useRealtimeStore();
const notifications = useNotificationStore();
const ui = useUiStore();
const serverInput = ref(appStore.serverUrl);
const testing = ref(false);
@@ -153,9 +157,193 @@ async function resetPhrases(): Promise<void> {
ElMessage.success('已恢复默认');
}
/* ------------------------------------------------------------ 启动与更新 / 服务端联动 */
/**
* 开机自启与自动更新。
*
* 开机自启的"是否生效"以**系统登录项**为准(新增的 `getAutoLaunch` 桥读的是
* `app.getLoginItemSettings()`,不是配置文件里的值)—— 用户可能在任务管理器的「启动」页
* 里手动禁用了它,这时候配置写着 true 也不该显示成已开启。
*/
const autoLaunch = ref(false);
const autoUpdate = ref(true);
const savingLaunch = ref(false);
const savingUpdate = ref(false);
/** 服务端联动状态(心跳上报 / 目标版本 / 待安装版本) */
const agent = ref<ClientAgentStatus | null>(null);
const agentLoading = ref(false);
/** 本机客户端版本(与服务端下发的目标版本对照着看) */
const appVersion = ref('—');
/** 最近上报时间的相对描述(没有上报过就显示占位符) */
const lastHeartbeatText = computed(() => {
const value = agent.value?.lastHeartbeatAt;
if (!value) return '还没有上报过';
return relativeTime(value);
});
/** 服务端对本机版本的期望:空串表示"不需要更新" */
const updateTargetText = computed(() => {
const target = agent.value?.updateTargetVersion ?? '';
if (!target) return '无(保持当前版本)';
return target;
});
const pendingUpdateText = computed(() => {
const pending = agent.value?.pendingUpdateVersion ?? '';
if (!pending) return '无';
return `${pending}(已下载,空闲时自动安装)`;
});
const lastErrorText = computed(() => agent.value?.lastError?.trim() || '无');
async function loadLaunchSettings(): Promise<void> {
if (!window.desktop?.getConfig) return;
const config = await window.desktop.getConfig();
autoUpdate.value = config.autoUpdate !== false;
autoLaunch.value = (await window.desktop.getAutoLaunch?.()) ?? config.autoLaunch === true;
const info = await window.desktop.getAppInfo?.().catch(() => null);
if (info?.appVersion) appVersion.value = info.appVersion;
}
async function toggleAutoLaunch(value: string | number | boolean): Promise<void> {
if (!window.desktop?.setAutoLaunch) return;
const wanted = value === true;
autoLaunch.value = wanted;
savingLaunch.value = true;
try {
const effective = await window.desktop.setAutoLaunch(wanted);
// 以系统实际生效值为准:写注册表失败时会与用户点的不一致,必须回显真实状态
autoLaunch.value = effective;
if (effective !== wanted) ElMessage.warning('系统未接受开机自启设置,请检查任务管理器里的启动项');
else ElMessage.success(wanted ? '已开启开机自启' : '已关闭开机自启');
} catch (error) {
autoLaunch.value = !wanted;
ElMessage.error(error instanceof Error ? error.message : '设置开机自启失败');
} finally {
savingLaunch.value = false;
}
}
async function toggleAutoUpdate(value: string | number | boolean): Promise<void> {
if (!window.desktop?.saveConfig) return;
const wanted = value === true;
autoUpdate.value = wanted;
savingUpdate.value = true;
try {
// 注意:必须传纯布尔值 —— 跨 contextBridge 传响应式对象会在进入 preload 前就被结构化克隆拒绝
const saved = await window.desktop.saveConfig({ autoUpdate: wanted });
autoUpdate.value = saved.autoUpdate !== false;
ElMessage.success(wanted ? '已开启自动更新' : '已关闭自动更新(仍可在「关于」页手动更新)');
} catch (error) {
autoUpdate.value = !wanted;
ElMessage.error(error instanceof Error ? error.message : '保存自动更新设置失败');
} finally {
savingUpdate.value = false;
}
}
/* ------------------------------------------------------------ 关怀模式 / 开发者模式 */
/**
* 关怀模式(需求 14):放大**正文与控件**字号。
*
* 这里只挂 `<html>.care-mode` 类并落盘,放大规则全在 `styles/index.css` 末尾那个集中覆盖块里
* (`--ch-font-scale` + 少数几个常用类),不在 JS 里逐个元素改字号。
*
* 开关直接读 ui store 的状态,**不用本地 ref 复制一份**:侧栏、路由守卫、主题页读的都是它,
* 复制就会出现"两个开关各说各话"。`ui.init()` 在首屏渲染前已从主进程配置恢复过。
*
* 关于"与助手联动":开启关怀模式会放大 AI 助手的按钮 —— 这条联动**只存在于 Web 管理端**,
* 本客户端目前没有助手入口,所以这里不放大任何按钮,也不为了"看起来对称"去造一个入口。
*/
const savingCareMode = ref(false);
async function toggleCareMode(value: string | number | boolean): Promise<void> {
const wanted = value === true;
savingCareMode.value = true;
try {
await ui.setCareMode(wanted);
ElMessage.success(wanted ? '已开启关怀模式:正文与控件字号已放大' : '已关闭关怀模式');
} catch (error) {
ElMessage.error(error instanceof Error ? error.message : '保存关怀模式设置失败');
} finally {
savingCareMode.value = false;
}
}
/**
* 开发者模式(需求 10):显示调试页面与详细日志,仅排查问题时打开。
*
* 打开后侧栏「设置」分组里**立刻**多出「开发者」页(`ClientLayout.vue` 读的是同一个
* ui store 状态),下次启动时主进程会把日志级别调到 debug。
*/
const savingDeveloperMode = ref(false);
async function toggleDeveloperMode(value: string | number | boolean): Promise<void> {
const wanted = value === true;
savingDeveloperMode.value = true;
try {
await ui.setDeveloperMode(wanted);
ElMessage.success(wanted ? '已开启开发者模式:侧栏出现「开发者」页' : '已关闭开发者模式');
} catch (error) {
ElMessage.error(error instanceof Error ? error.message : '保存开发者模式设置失败');
} finally {
savingDeveloperMode.value = false;
}
}
async function refreshAgentStatus(): Promise<void> {
if (!window.desktop?.getClientAgentStatus) return;
agentLoading.value = true;
try {
agent.value = await window.desktop.getClientAgentStatus();
} finally {
agentLoading.value = false;
}
}
async function beatNow(): Promise<void> {
if (!window.desktop?.beatClientNow) return;
agentLoading.value = true;
try {
// 手动上报是"立刻打一次",成功/失败都刷新状态,失败原因展示在「最近错误」里
agent.value = await window.desktop.beatClientNow();
if (agent.value?.lastError) ElMessage.warning(`上报未成功:${agent.value.lastError}`);
else ElMessage.success('已向服务端上报本机状态');
} catch (error) {
ElMessage.error(error instanceof Error ? error.message : '上报失败,请检查网络与登录状态');
} finally {
agentLoading.value = false;
}
}
async function openLogDir(): Promise<void> {
if (!window.desktop?.openLogDir) return;
const ok = await window.desktop.openLogDir();
if (!ok) ElMessage.warning('打开日志目录失败,可在「关于」页复制诊断信息');
}
/** 状态里的相对时间要跟着走,否则挂着的页面会一直显示"刚刚" */
let statusTimer: ReturnType<typeof setInterval> | null = null;
onMounted(async () => {
await appStore.refreshCacheStats();
await loadPhrases();
await loadLaunchSettings();
await refreshAgentStatus();
statusTimer = setInterval(() => {
void refreshAgentStatus();
}, 30_000);
});
onBeforeUnmount(() => {
if (statusTimer !== null) {
clearInterval(statusTimer);
statusTimer = null;
}
});
</script>
@@ -238,6 +426,77 @@ onMounted(async () => {
<el-button @click="resetPhrases">恢复默认</el-button>
</div>
</el-card>
<el-card shadow="never" class="mt-12">
<template #header><span>启动与更新</span></template>
<div class="switch-row">
<div class="switch-main">
<span>开机自启</span>
<p class="text-muted">登录 Windows 后自动启动 ClassHelper;教室机器建议打开。</p>
</div>
<el-switch
:model-value="autoLaunch"
:loading="savingLaunch"
@update:model-value="toggleAutoLaunch"
/>
</div>
<div class="switch-row">
<div class="switch-main">
<span>自动更新</span>
<p class="text-muted">
安装只在
<strong>不上课且窗口已隐藏 5 分钟后</strong>
进行,下载随时可能发生。
</p>
<p class="text-muted">服务端可以统一要求更新,关掉它只会把安装推迟到手动处理。</p>
</div>
<el-switch
:model-value="autoUpdate"
:loading="savingUpdate"
@update:model-value="toggleAutoUpdate"
/>
</div>
<div class="toolbar mt-12">
<el-button @click="openLogDir">打开日志目录</el-button>
<span class="text-muted">日志文件 main.log,排查问题时可发给管理员</span>
</div>
</el-card>
<el-card shadow="never" class="mt-12">
<template #header><span>显示与调试</span></template>
<div class="switch-row">
<div class="switch-main">
<span>关怀模式</span>
<p class="text-muted">
放大正文与控件字号(页面标题、表格、表单、卡片标题一起变大);圆角、投影与侧栏宽度等几何尺寸保持原样,侧栏图标导轨也不放大。
</p>
<p class="text-muted">
「开启后同时放大 AI 助手按钮」这一条只在 Web 管理端生效 —— 本客户端目前没有助手入口。
</p>
</div>
<el-switch
:model-value="ui.careMode"
:loading="savingCareMode"
data-test="care-mode-switch"
@update:model-value="toggleCareMode"
/>
</div>
<div class="switch-row">
<div class="switch-main">
<span>开发者模式</span>
<p class="text-muted">显示调试页面与详细日志,仅排查问题时打开。</p>
<p v-if="ui.developerMode" class="text-muted">
debug 级日志已开启;侧栏「设置 → 开发者」可查看版本、设备上报、更新检查、日志目录与 DevTools。
</p>
</div>
<el-switch
:model-value="ui.developerMode"
:loading="savingDeveloperMode"
data-test="developer-mode-switch"
@update:model-value="toggleDeveloperMode"
/>
</div>
</el-card>
</el-col>
<el-col :xs="24" :md="12">
@@ -265,6 +524,35 @@ onMounted(async () => {
description="断网后课表、作业、通知、成绩都会从本地缓存读取;恢复网络后自动向服务器同步最新数据。"
/>
</el-card>
<el-card shadow="never" class="mt-12">
<template #header><span>服务端联动状态</span></template>
<p class="text-muted">
本机每 30 秒向服务端上报一次状态(是否在上课、当前版本、已下载的更新),
服务端据此下发统一更新与远控命令。本机标识尾号用于在服务端设备列表里核对这台电脑。
</p>
<el-descriptions class="mt-12" :column="1" border size="small">
<el-descriptions-item label="连接状态">
<el-tag :type="agent?.online ? 'success' : 'info'" size="small">
{{ agent?.online ? '已连接(近期上报成功)' : '未连接(等待上报)' }}
</el-tag>
</el-descriptions-item>
<el-descriptions-item label="本机版本">
{{ appVersion }}
</el-descriptions-item>
<el-descriptions-item label="设备标识尾号">
{{ agent?.deviceKeyTail || '—' }}
</el-descriptions-item>
<el-descriptions-item label="最近上报">{{ lastHeartbeatText }}</el-descriptions-item>
<el-descriptions-item label="服务端目标版本">{{ updateTargetText }}</el-descriptions-item>
<el-descriptions-item label="已下载待安装">{{ pendingUpdateText }}</el-descriptions-item>
<el-descriptions-item label="最近错误">{{ lastErrorText }}</el-descriptions-item>
</el-descriptions>
<div class="toolbar mt-12">
<el-button type="primary" :loading="agentLoading" @click="beatNow">立即上报</el-button>
<el-button :loading="agentLoading" @click="refreshAgentStatus">刷新状态</el-button>
</div>
</el-card>
</el-col>
</el-row>
</div>
@@ -282,4 +570,29 @@ onMounted(async () => {
.ml-8 {
margin-left: 8px;
}
/* 开关行:左说明右开关,说明长时自动换行(「自动更新」的提示是两行) */
.switch-row {
display: flex;
align-items: flex-start;
justify-content: space-between;
gap: 16px;
padding: 8px 0;
}
.switch-row + .switch-row {
border-top: 1px solid var(--ch-border);
}
.switch-main {
display: flex;
flex-direction: column;
gap: 2px;
}
.switch-main p {
margin: 0;
font-size: 12.5px;
line-height: 1.5;
}
</style>