9 Commits
Author SHA1 Message Date
LoveChengke 9a38f86cd3 feat(server,web,desktop,shared,deploy,docs): Linux 一键安装与 classhelper 运维命令、更新检查、图表去 echarts,版本统一 1.1.0
Linux 交付链(新增)
- deploy/install.sh:一键安装器(CLASSHELPER 大字 TUI、native/docker 双形态、向导选安装目录/
  端口/数据库/初始管理员密码);识别 apt/yum/dnf 只补缺的依赖、建独立系统用户、下载内置 Node
  运行时(glibc < 2.28 的 CentOS 7 自动改用 unofficial-builds 的 glibc-217 构建)、幂等覆盖安装
  (保留 config.env 与 data/,不重置密钥)、全程写 /var/log/classhelper/install.log;
  `--check` 只体检(不需要 root)、`--yes` 无人值守、`--package` 支持内网离线分发。
- deploy/classhelper:运维命令 —— status / doctor / password / backup(list,restore,schedule) /
  upgrade / rollback / start|stop|restart|reload / logs / config / port / key rotate / uninstall /
  completion / help。特权操作一律校验 EUID,关键动作写 /var/log/classhelper/audit.log。
- deploy/tools/admin-cli.mjs:离线账号工具(改密、列账号、VACUUM INTO 一致性快照、哈希回滚),
  直连数据库 —— 服务停机也能救急,不需要先有一个能登录的账号。
- deploy/{classhelper.service,profile.d,logrotate.d,systemd}/ 模板 + Dockerfile.linux-package。
- scripts/dist-server.mjs 增加 --platform linux(根脚本 `pnpm dist:server:linux`),产物
  classhelper-server-linux-x64-<版本>.tar.gz + 同名 .sha256;新增 GitHub Actions workflow 在
  ubuntu runner 上构建并挂 Release(@libsql/linux-* 这类平台相关依赖只能在 Linux 上装)。
- docs/linux-deploy.md:安装 / 运维命令 / 升级回滚 / 备份恢复 / 排障 / 安全清单 /
  Ubuntu 22.04 与 Rocky 9 的验收清单。deploy/install-linux.sh 改为转发壳,不留两份实现。

三处必须知道的取舍(已写进 AGENTS.md §5 第 59 条)
- 配置真身在 /etc/classhelper/config.env,安装目录里的 .env 是指向它的软链:Web 端
  「数据库管理 → 一键切换」改写的是 <安装目录>/.env,而 systemd 注入的是同一份配置 ——
  两处不是同一个文件时,切换会「看起来成功、重启后又连回旧库」。classhelper doctor 有专门断言。
- 升级/回滚替换程序文件用「改名 + 就位」而不是 rm+cp:升级时正在运行的就是 bin/classhelper
  自己,直接删掉同名文件会让 bash 读到半个脚本。
- 交叉构建(在非 Linux 机器上打 Linux 包)会在包内写 .cross-built 标记、doctor 据此提示:
  已核对 @libsql/linux-x64-gnu 与 -musl 就位且无 win32 残留,但 prisma CLI 的原生 schema engine
  是宿主平台的,Web 端「数据库一键切换」那一步存疑;正式产物一律走 CI。

更新检查(此前只在工作区,本次一并提交)
- 服务端 modules/update:由服务端转发 GitHub Releases(Web 端 CSP 不允许直连),离线/限流/超时
  一律收敛成 ok:false + 一句人话,失败结果同样进缓存;?force=1 只对管理员生效(避免刷爆匿名限流)。
- 版本比较放 @classhelper/shared(compareVersions / isNewerVersion),三端共用;服务端版本号
  改由 lib/version.ts 读 package.json,不再在 app.ts 里写字面量。
- Web 端顶栏「检查更新」弹窗、客户端「关于」页的检查更新与诊断信息。

Web 端 / 客户端
- 成绩图表改用自包含的轻量组件(ScoreBarChart / ScoreLineChart),不再全量引入 echarts
  (原先 echarts 占桌面端渲染产物 1.12MB、Web 端 1.13MB);柱状图是纯 HTML/CSS,折线图是
  viewBox SVG,均无 resize 监听。
- Element Plus 图标改为按需注册(两端各一份 icons.ts),新增 scripts/check-icons.mjs 静态门禁
  并挂进两端 build —— 漏注册的后果是界面静默渲染空白,只在控制台一条 warning。

版本号统一 1.1.0
- 5 份 package.json、deploy/package.runtime.json、.env.example 的 APP_VERSION、
  docker-compose 与两个 Dockerfile 的镜像标签、Linux 安装包名示例、README 首页版本;
- ClassIsland 插件 manifest.yml 与 BridgeService.PluginVersion 同步(verify:classisland-plugin
  有 manifest ↔ code 的一致性断言);
- 刻意保持不变的是**历史性表述与举例**:docs/mysql.md 的「自 v1.0.0 起内置 MySQL 适配器」、
  shared/utils.ts 讲版本比较用的 1.0.0 / 1.0.0-fix、README 验收表里的实测记录。
2026-10-05 16:39:38 +08:00
LoveChengke aad22df4fd docs: 重写 README —— 按 1.0.0 现状重排为「产品说明书 + 验收对照表」
结构重排:组成部分 → 交付产物与部署形态 → 快速开始 → 功能说明(Web 端 / 客户端 / 灵动岛 / 作业 /
叫人 / 上课时段 / 导入 / ClassIsland 联动 / 数据库管理)→ 技术参考(目录结构 / 技术栈 / REST API /
WebSocket / RBAC / 模块化 / 数据库与迁移)→ 验收 → 打包与交付 → 常见问题 → 后续增强。
1594 行 → 1236 行,去掉的是与 AGENTS.md 重复的踩坑叙述与「按阶段的交付清单」文件流水(后者改由目录结构
与 git 历史承载)。

修正过期内容:
- 迁移数 9 → 10(补回 add_schedule_source),迁移清单同步
- verify:e2e 173 项 → 186 项;verify:web 30/31、verify:desktop 99/102、插件静态契约 68/68 按最近一次实测重写
- 删掉两条与现状相反的验收行(「客户端设置页提供修改密码」),改为「客户端有意不提供改密入口」,
  与 AGENTS.md §5 第 31 条、冒烟断言「改密入口存在=false」一致
- 服务端安装包体积口径统一为 ~71MB(切库依赖内置后);插件版本 1.0.0.0;正文标注当前版本 1.0.0

新增与加强:
- 补 1.0.0 的内容:数据库管理(仅管理员)、新手引导(Web 端 el-tour + 客户端六步向导)、
  设置拆 6 个子路由、深色模式、客户端主窗口与 ClassIsland 对齐(1242x582)、
  课表 source 字段与「幽灵行清理」口径
- 6.3「已知的时序 / 环境相关用例」:写明 verify:desktop 那 3 项在「当前正在上课」时必然失败的原因,
  并给出各验证脚本覆盖凭据的方式(ELECTRON_SMOKE_* / UI_SMOKE_* 支持环境变量,verify:e2e 不支持)

验证(2026-10-02 本机):verify:e2e 186/186;verify:web 30/31(1 项为既有脆弱用例);
verify:desktop 99/102(3 项时序相关);verify:classisland-plugin 68/68;typecheck 与 lint 通过。
2026-10-02 11:24:31 +08:00
LoveChengke 572295c297 feat(server,web,desktop,shared,deploy,plugin): 数据库管理模块 + 客户端深色模式/设置拆子路由/首启引导,版本统一 1.0.0
- 服务端新增 database 模块(/api/database/*,仅 ADMIN):全库 JSON 快照(备份 / 恢复 / 导入导出 / 定时备份
  共用同一格式,14 张表按拓扑序导出、恢复时关外键检查)、连接测试与目标库校验、一键 SQLite ⇄ MySQL 切换
  (备份 → 导出 → 测试连接 → 校验空库 → 改 schema → 子进程 generate / tsc / db push → 写数据,全部成功才改写
  .env,中途失败回滚 schema);XML 快照与 SQLite 数据文件均可下载;打包形态随包带上 prisma CLI 与 typescript
  (prisma-client 生成物是 .ts,需再编进 dist/generated,安装包因之变大)
- Web 管理端新增「数据库管理」页(仅管理员),并加首次登录新手引导(el-tour,可跳过、可随时重看,版本号写
  localStorage,改版后老用户会再收到一次)
- 客户端设置改版:侧边栏改为分组折叠菜单,设置拆成 6 个子路由
  (/settings/{general,appearance,island,reminder,account,about}),新增深色模式(主题持久化到主进程配置,
  主窗口底色跟主题走,避免"先白后黑"闪一下),新增「关于」页(应用信息 / 诊断信息)
- 客户端新增首启六步引导(OnboardingWelcome,状态存主进程配置 onboardingDone)
- 客户端主窗口初始尺寸与 ClassIsland 对齐(1242x582 / minHeight 540 / 居中)
- 版本号统一提升到 1.0.0:5 个 package.json、部署配置与镜像标签(.env.example / docker-compose / Dockerfile)、
  服务端 /health 与首页、插件 manifest.yml 与 BridgeService.PluginVersion、文档里的安装包名
- 文档与验收同步:AGENTS.md 补第 37~51 条约定(深色主题实现边界、设置子路由、数据库管理三件事、侧栏与窗口
  尺寸、引导在自动化里的判据等),README 补「数据库管理 / 新手引导 / 设置改版」三节;verify:e2e 增补 13 条
  数据库管理用例,客户端冒烟与 Web UI 冒烟跟进子路由、深色主题、侧栏与引导

验证:pnpm lint 0 error;pnpm typecheck 全过;verify:e2e 186/186;verify:classisland-plugin 68/68;
build:desktop 通过(含产物凭据门禁);verify:desktop 99/102(3 项为上课时段下的"真实通知链路"用例,
客户端按产品规则暂存普通通知所致,见下);插件 dotnet 编译 0 错误。

注:verify:desktop 的「真实通知链路 / 标记已读」三项要求当前不在上课时段——本次运行时种子课表恰有
「周五 10:55-11:40 生物」正在进行,客户端正确地暂存了普通通知(AGENTS.md 第 18 条),属时间相关用例,
与本次改动无关。
2026-10-02 11:18:47 +08:00
LoveChengke 391e2c1591 docs(desktop,island): 修正被写成既成事实的"收回握手"机制描述
AGENTS.md 第 34 条把一个从未落地的设计当成了已实现的规则,还配上了"踩过的坑"与
"两条配套铁律",读起来像历史教训。实际核对:`island:closing`、`island:closing-done`、
`sendClosingDone`、`noteClosingDone`、`closingTimer`、`finishClosing` 六个符号在全部
源码中零命中,在 git 全部历史里也从未出现过。

真实实现是主进程单向的:handleAction() → dismissActive() / clearPendingForClose()
→ hide() → fadeOut(),状态同一帧写成 hidden,不等渲染进程任何回执。渲染侧只有本地
弹簧形变(spring.ts),是纯视觉动画,不参与淡出时机。

另,早先那层自研的"卡片缩回胶囊再淡出"快照动画(closing / closingSnapshot)确实存在过,
因在触摸屏上会露出旧帧/重影,已按用户要求整体删除 —— IslandApp.vue 顶部注释有记载。

改动:重写 AGENTS.md 第 34 条为真实机制,并注明该自研动画已移除、别再照着不存在的
握手机制改代码;README 三处同样表述一并修正;smoke.ts 里那句"渲染进程收敛上报"的
过时注释改为描述真实的淡出轮询。
2026-10-02 00:32:48 +08:00
LoveChengke 20fcca0388 feat(server,web,shared,desktop): 上传超限正确报错 + 两个登录入口都限流 + 作业按天深链,文档与验证脚本同步
服务端加固:
- express.json 上限 2mb → 12mb:表格导入把文件以 base64 放进 JSON(约 4/3 倍),
  8MB 的声明上限原先到 1.5MB 就被拦掉;超限现在由 error 中间件映射成
  413 IMPORT_TOO_LARGE(中文提示"请拆分后分批导入"),不再落进 500 兜底分支抛英文原文;
- loginRateLimiter 同时挂 /auth/login 与 /auth/class-login(班级密码默认 123456,
  班级登录曾是唯一没有暴力破解防护的入口),两个路径共享同一计数器;
- CORS_ORIGIN=* 时启动告警(不拦截启动,避免挡住教室机 file:// 的合法部署);
- 删除已无用的 DEFAULT_STUDENT_PASSWORD;班级 termWeeks 上限 40 → 30,
  与 MAX_TERM_WEEK / weekNumberSchema 对齐(原先对外承诺了系统兑现不了的学期长度)。

Web 端:
- 作业页 ?date= 深链在同路由再推 query 时也生效(watch route.query.date);
- 表格导入对话框适配 8MB 上限与 413 提示。

冒烟与文档:
- 新增 scripts/lib/smoke-class.mjs:验证用临时班级,避免探针通知弹到用户自己的客户端与灵动岛;
- README 与 AGENTS.md 同步本轮全部行为变更(含 schedule source、学生账号清理、凭据门禁)。
2026-10-02 00:25:21 +08:00
LoveChengke 3880eee08e feat(desktop,island,shared): 灵动岛支持多条通知竖排列表 + 触摸模式 + 收回动画,产物加凭据门禁
灵动岛列表:多条通知时展开为竖排列表,默认显示 3 条,点「展开更多」铺到屏幕容纳
上限,放不下的收进「更多请前往应用内操作」。卡片高度由主进程与渲染进程各算一次
同一个数 —— 度量表 ISLAND_LIST_METRICS 与排序权重 PRIORITY_RANK 放在 shared,
窗口包围盒随之长高(不够高会把底部按钮裁掉)。

触摸模式:触摸屏上手指既不产生 mousemove、也不移动系统光标,原先两条命中链路都会
让窗口永远停在穿透态、手指点不开岛。现按 navigator.maxTouchPoints 上报后,主进程把
窗口贴合岛体并始终接收输入;非触摸屏机器完全不走这条路。

收回动画:main 先发 island:closing,渲染进程形变收敛后回 closing-done 才淡出,
不再靠猜时长(rAF 被节流时会把卡片缩到一半窗口就没了)。

安全门禁:新增 scripts/check-bundle-secrets.mjs 并接进 build:desktop ——
dist 产物会被打进 app.asar 发到每台学生机、且可解包,冒烟凭据一律改由环境变量注入,
产物里出现种子口令即构建失败。
2026-10-02 00:25:10 +08:00
LoveChengke d27f9a4b9e feat(students,teachers,classes,auth,web): 学生个人账号彻底清理,学生只是名单记录
学生不再有登录能力:User.passwordHash 以空串占位,role=STUDENT 在密码校验之前
一律 403 并提示改用班级登录(否则「密码错 401 / 密码对但已停用 403」的差异会把
学生账号密码变成可离线验证的预言机)。成绩、未交名单、叫人、已读全部按名单记。

配套改动:
- 删除 POST /students/:id/reset-password(调用返回 404,e2e 有负断言);
- 新建学生不设密码,StudentsView 移除密码输入与「重置密码」入口,
  列表标识仍自动生成为学号式(student01…);
- class-account.ts / auth.service.ts 收紧班级会话语义;
- 经管「修改密码」入口收敛到 Web 端:教师改本人密码走顶栏下拉,
  班级密码由管理员在班级管理里维护,教师可用 POST /teachers/:id/reset-password 设初始密码。
2026-10-02 00:25:04 +08:00
LoveChengke 7ea0e0f7c9 feat(schedules,classisland,server,plugin,shared): 课表行加来源字段,插件上报可真正同步删除
课表行新增 Schedule.source(manual / classisland):插件每次全量上报时,服务端
只清理「source=classisland 且本次未再上报」的行。原先 merge 只做 upsert,老师在
ClassIsland 里删掉或挪走一节,服务端会永远留着那行幽灵课;现在能真正同步下来,
而老师在小助手这边手排的课(manual)一律不删。

配套改动:
- 插件上报时带回 machineKey,服务端回填到设备记录(避开 [classId, deviceKey] 唯一约束);
- 新增迁移 20260930120000_add_schedule_source,存量数据保守地按 manual 处理;
- verify:classisland 补「幽灵行清理」「手排课不被误删」用例。

另:.gitignore 补上 .zcode/ 与 .zcodeignore(AI 会话产物,不属于产品代码)。
2026-10-02 00:24:58 +08:00
LoveChengke 9c678b3730 fix(deploy,docs): 修好 Docker 构建(缺 prisma generate)+ 新增 SQLite 单容器 compose
- Dockerfile:构建阶段补 `pnpm --filter @classhelper/server run db:generate`。生成产物 packages/server/src/generated/prisma 是 gitignored 的,而 pnpm install 用了 --ignore-scripts 跳过 postinstall,少了这一步 tsc 会报 "Cannot find module ../generated/prisma/client.js"(从 git clone 构建必踩)
- 新增 deploy/docker-compose.sqlite.yml + deploy/.env.sqlite.example:只跑服务端一个容器(DATABASE_URL=file:/app/data/classhelper.db + 数据卷),首次启动靠 AUTO_MIGRATE=true 自动建表与建管理员。适合内存小的机器或与别的服务共用一台机器(MySQL 变体会多一个数据库进程)
- docs/production.md:补 2.1 单容器变体说明(用法、适用场景、端口/生产自检注意事项、备份命令)
2026-09-27 18:34:19 +08:00
151 changed files with 17734 additions and 3107 deletions

No files matched your search

+116
View File
@@ -0,0 +1,116 @@
name: 发布 Linux 服务端安装包
# 为什么单独有这个 workflow:
# Linux 包的依赖(@libsql/linux-x64-gnu、@prisma/adapter-libsql 等)是平台相关的,
# 在 Windows 开发机上 npm install 出来的 node_modules 装到 Linux 跑不起来,
# 所以 Linux 包必须在 Linux 上构建。这个 workflow 用 ubuntu runner 产出
# classhelper-server-linux-x64-<版本>.tar.gz 并挂到 GitHub Release 上,
# 服务器上的 `classhelper upgrade` 就是从这里下载 + 校验 sha256 的。
#
# 用法:
# 1. 先在本地按惯例打出 Windows 包并发 Release(vX.Y.Z);
# 2. 到 Actions 页面手动运行本 workflow,填 tag(例如 v1.1.0);
# 3. 跑完 Release 里会多出 Linux 包与更新后的 SHA256SUMS-<版本>.txt。
#
# 也可以只跑构建不挂 Release(attach=false),产物在 workflow 的 Artifacts 里。
on:
workflow_dispatch:
inputs:
tag:
description: '要构建并挂载的 Release tag(例如 v1.1.0)'
required: true
type: string
attach:
description: '构建后上传到该 Release'
required: false
default: true
type: boolean
push:
tags:
- 'v*'
permissions:
contents: write
jobs:
build-linux-package:
runs-on: ubuntu-22.04
timeout-minutes: 40
steps:
- name: 确定 tag
id: ref
run: |
if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
echo "tag=${{ inputs.tag }}" >> "$GITHUB_OUTPUT"
echo "attach=${{ inputs.attach }}" >> "$GITHUB_OUTPUT"
else
echo "tag=${GITHUB_REF_NAME}" >> "$GITHUB_OUTPUT"
echo "attach=true" >> "$GITHUB_OUTPUT"
fi
- name: 检出代码
uses: actions/checkout@v4
with:
ref: ${{ steps.ref.outputs.tag }}
- name: 安装 Node 22
uses: actions/setup-node@v4
with:
node-version: '22'
- name: 安装 pnpm
uses: pnpm/action-setup@v4
with:
version: 11.8.0
run_install: false
- name: 安装依赖
run: pnpm install --frozen-lockfile
- name: 构建 Linux 安装包
run: pnpm dist:server:linux
- name: 展示产物
run: ls -la release-server/
- name: 上传构建产物(Artifacts)
uses: actions/upload-artifact@v4
with:
name: classhelper-server-linux-x64
path: |
release-server/classhelper-server-linux-x64-*.tar.gz
release-server/classhelper-server-linux-x64-*.tar.gz.sha256
if-no-files-found: error
retention-days: 30
- name: 挂到 Release 并更新 SHA256SUMS
if: steps.ref.outputs.attach == 'true'
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
TAG: ${{ steps.ref.outputs.tag }}
run: |
set -euo pipefail
VERSION="${TAG#v}"
TARBALL="release-server/classhelper-server-linux-x64-${VERSION}.tar.gz"
SUMS="release-server/SHA256SUMS-${VERSION}.txt"
if [ ! -f "$TARBALL" ]; then
echo "::error::没有找到 $TARBALL(tag 与 package.json 的版本号对得上吗?)"
exit 1
fi
# 取回已有的校验清单(Windows 包那几行),把本次的 Linux 包追加/替换进去
gh release download "$TAG" --pattern "SHA256SUMS-*.txt" --dir release-server --clobber || true
DOWNLOADED="$(ls release-server/SHA256SUMS-*.txt 2>/dev/null | head -n 1 || true)"
if [ -n "$DOWNLOADED" ] && [ "$DOWNLOADED" != "$SUMS" ]; then mv "$DOWNLOADED" "$SUMS"; fi
grep -v "classhelper-server-linux-x64-${VERSION}.tar.gz" "$SUMS" 2>/dev/null > "${SUMS}.tmp" || true
cat "${SUMS}.tmp" > "$SUMS" 2>/dev/null || true
rm -f "${SUMS}.tmp"
sha256sum "$TARBALL" | awk '{print $1" "$2}' | sed "s#release-server/##" >> "$SUMS"
sort -u -k2 "$SUMS" -o "$SUMS"
gh release upload "$TAG" "$TARBALL" "$SUMS" --clobber
echo "已上传:"
cat "$SUMS"
+7
View File
@@ -41,3 +41,10 @@ Thumbs.db
# 参考用的第三方源码包(设计 token 已提取到 docs/winisland-design-tokens.md) # 参考用的第三方源码包(设计 token 已提取到 docs/winisland-design-tokens.md)
WinIsland-master.zip WinIsland-master.zip
releases/
# AI 浼氳瘽浜х墿锛圸Code 璁″垝/閰嶇疆锛屼笉灞炰簬浜у搧浠g爜锛�
.zcode/
.zcodeignore
packages/server/prisma/backups/
packages/server/prisma/database-settings.json
+832 -199
View File
File diff suppressed because it is too large. Load diff
+956 -1040
View File
File diff suppressed because it is too large. Load diff
+2 -2
View File
@@ -7,7 +7,7 @@
SERVER_PORT=4000 SERVER_PORT=4000
# 应用版本(镜像标签) # 应用版本(镜像标签)
APP_VERSION=0.1.0 APP_VERSION=1.1.0
# MySQL 配置 # MySQL 配置
MYSQL_ROOT_PASSWORD=请改成强密码_root MYSQL_ROOT_PASSWORD=请改成强密码_root
@@ -31,7 +31,7 @@ INITIAL_ADMIN_USERNAME=admin
INITIAL_ADMIN_PASSWORD=admin123 INITIAL_ADMIN_PASSWORD=admin123
# 各类账号的默认初始密码(新增/重置时使用) # 各类账号的默认初始密码(新增/重置时使用)
DEFAULT_STUDENT_PASSWORD=123456
DEFAULT_CLASS_PASSWORD=123456 DEFAULT_CLASS_PASSWORD=123456
DEFAULT_TEACHER_PASSWORD=123456 DEFAULT_TEACHER_PASSWORD=123456
+36
View File
@@ -0,0 +1,36 @@
# ---------------------------------------------------------------------------
# 班级小助手 · Docker 单容器(SQLite)环境变量
# 复制为 deploy/.env.sqlite 后填写:cp deploy/.env.sqlite.example deploy/.env.sqlite
# 配合 deploy/docker-compose.sqlite.yml 使用
# ---------------------------------------------------------------------------
# 服务端对外端口(宿主机)。注意与同机其他服务错开:80/443 常被反代占用
SERVER_PORT=4000
# 应用版本(镜像标签)
APP_VERSION=1.1.0
# JWT 签名密钥(必填,必须 ≥32 位;不能包含 secret / change-me 等示例词)
# 生成:node -e "console.log(require('crypto').randomBytes(48).toString('hex'))"
JWT_SECRET=
# 令牌有效期
JWT_EXPIRES_IN=7d
# 允许的跨域来源;用域名访问时建议写成具体来源,例如 https://class.example.com
CORS_ORIGIN=*
# 首次启动创建的管理员账号(**部署后请立即登录修改密码**)
INITIAL_ADMIN_USERNAME=admin
INITIAL_ADMIN_PASSWORD=admin123
# 各类账号的默认初始密码(新增/重置时使用)
DEFAULT_CLASS_PASSWORD=123456
DEFAULT_TEACHER_PASSWORD=123456
# 第 1 教学周的周一(用于"当前周次")
TERM_START_DATE=2026-08-31
# 日志级别:debug | info | warn | error
LOG_LEVEL=info
+7 -2
View File
@@ -5,13 +5,13 @@
# runtime —— 仅保留运行时所需内容(生产依赖 + 构建产物),镜像更小 # runtime —— 仅保留运行时所需内容(生产依赖 + 构建产物),镜像更小
# #
# 构建(在仓库根目录执行): # 构建(在仓库根目录执行):
# docker build -f deploy/Dockerfile -t classhelper-server:0.1.0 . # docker build -f deploy/Dockerfile -t classhelper-server:1.1.0 .
# #
# 运行(SQLite + 数据卷): # 运行(SQLite + 数据卷):
# docker run -d --name classhelper -p 4000:4000 \ # docker run -d --name classhelper -p 4000:4000 \
# -e JWT_SECRET=<48字节随机串> \ # -e JWT_SECRET=<48字节随机串> \
# -v classhelper-data:/app/data \ # -v classhelper-data:/app/data \
# classhelper-server:0.1.0 # classhelper-server:1.1.0
# #
# 生产推荐用 docker compose(见 deploy/docker-compose.yml,含 MySQL 与 HTTPS 反代) # 生产推荐用 docker compose(见 deploy/docker-compose.yml,含 MySQL 与 HTTPS 反代)
@@ -33,7 +33,12 @@ RUN pnpm install --frozen-lockfile --ignore-scripts
# 再拷贝源码并构建(只构建服务端与 Web 管理端,桌面客户端不参与) # 再拷贝源码并构建(只构建服务端与 Web 管理端,桌面客户端不参与)
COPY packages ./packages COPY packages ./packages
COPY scripts ./scripts COPY scripts ./scripts
# 必须先生成 Prisma Client:`pnpm install --ignore-scripts` 跳过了 postinstall,
# 而生成产物 `packages/server/src/generated/prisma` 是 gitignored 的(clone 下来没有),
# 少了这一步下面的 tsc 会报 "Cannot find module '../generated/prisma/client.js'"。
RUN pnpm build:shared \ RUN pnpm build:shared \
&& pnpm --filter @classhelper/server run db:generate \
&& pnpm --filter @classhelper/server build \ && pnpm --filter @classhelper/server build \
&& pnpm --filter @classhelper/web-admin build && pnpm --filter @classhelper/web-admin build
+45
View File
@@ -0,0 +1,45 @@
# ---------------------------------------------------------------------------
# 班级小助手服务端 · Docker 形态镜像(由 install.sh --mode docker 使用)
#
# 与仓库根 deploy/Dockerfile 的区别:
# - 那份是"从源码构建"(两阶段、需要 pnpm 与全量源码),适合开发与自己打包镜像;
# - 这份是"从安装包构建":安装包里的 server/dist、web、node_modules 已经是**linux-x64 的真实目录**,
# 所以这里只做 COPY,不需要联网装依赖、不需要构建工具,几十秒就能出镜像。
#
# 构建(install.sh 自动执行,也可手工):
# docker build -t classhelper-server:1.1.0 -f Dockerfile .
# 运行:
# docker run -d --name classhelper-server -p 4000:4000 \
# --env-file /etc/classhelper/config.env -v classhelper-data:/app/data \
# classhelper-server:1.1.0
# ---------------------------------------------------------------------------
FROM node:22-slim
ENV NODE_ENV=production \
HOST=0.0.0.0 \
PORT=4000
WORKDIR /app
# 运行时会用到的全部内容(安装包里就是这套布局)
COPY package.json ./
COPY node_modules ./node_modules
COPY server ./server
COPY web ./web
COPY tools ./tools
# 数据目录(compose 里挂成卷)
RUN mkdir -p /app/data /app/logs
# 说明:不用 `USER node`
# - 镜像只在本机跑,容器本身就是隔离边界;
# - 数据卷里的文件需要与宿主机上的 classhelper backup / restore 互通,
# 用 root 可以避免 uid 不一致导致的权限问题。
EXPOSE 4000
# 健康检查用 Node 自己发请求:slim 镜像里没有 curl/wget
HEALTHCHECK --interval=30s --timeout=5s --start-period=40s --retries=3 \
CMD node -e "fetch('http://127.0.0.1:'+(process.env.PORT||4000)+'/healthz').then(r=>process.exit(r.ok?0:1)).catch(()=>process.exit(1))"
CMD ["node", "server/dist/index.js"]
+1580
View File
File diff suppressed because it is too large. Load diff
+41 -15
View File
@@ -1,24 +1,33 @@
# --------------------------------------------------------------------------- # ---------------------------------------------------------------------------
# 班级小助手 · 服务端 systemd 单元(Linux) # 班级小助手 · 服务端 systemd 单元(Linux)
# #
# 这是**模板**:deploy/install-linux.sh 会把 __NODE__ / __DIR__ / __USER__ 替换成真实值后 # 这是**模板**:`deploy/install.sh` 会把占位符替换成真实值后安装到
# 安装到 /etc/systemd/system/classhelper.service。手动部署时直接改这三处即可: # /etc/systemd/system/classhelper.service。手动部署时照着替换这四处即可:
# #
# sudo sed -e 's#__NODE__#/usr/bin/node#' \ # __NODE__ Node 可执行文件的绝对路径(内置运行时:<安装目录>/runtime/node/bin/node)
# __DIR__ 安装目录(默认 /opt/classhelper)
# __USER__ 运行服务的系统用户(默认 classhelper)
# __CONFIG__ 环境变量文件(默认 /etc/classhelper/config.env)
# __CONFIGDIR__ __CONFIG__ 所在目录(需要写权限,见下面的 ReadWritePaths)
#
# sudo sed -e 's#__NODE__#/opt/classhelper/runtime/node/bin/node#' \
# -e 's#__DIR__#/opt/classhelper#' \ # -e 's#__DIR__#/opt/classhelper#' \
# -e 's#__USER__#classhelper#' \ # -e 's#__USER__#classhelper#' \
# deploy/classhelper.service | sudo tee /etc/systemd/system/classhelper.service # -e 's#__CONFIGDIR__#/etc/classhelper#' \
# -e 's#__CONFIG__#/etc/classhelper/config.env#' \
# deploy/classhelper.service > /tmp/classhelper.service
# sudo install -m 644 /tmp/classhelper.service /etc/systemd/system/classhelper.service
# sudo systemctl daemon-reload && sudo systemctl enable --now classhelper # sudo systemctl daemon-reload && sudo systemctl enable --now classhelper
# #
# 常用命令: # 常用命令(也有对应的 classhelper 封装):
# classhelper status / start / stop / restart / logs -f
# systemctl status classhelper # systemctl status classhelper
# journalctl -u classhelper -f # 实时日志 # journalctl -u classhelper -f
# systemctl restart classhelper # 重启(改完 .env 需要)
# --------------------------------------------------------------------------- # ---------------------------------------------------------------------------
[Unit] [Unit]
Description=ClassHelper Server (班级小助手服务端) Description=ClassHelper Server (班级小助手服务端)
Documentation=file://__DIR__/README.txt Documentation=https://github.com/LoveChengke/ClassHelper
After=network-online.target After=network-online.target
Wants=network-online.target Wants=network-online.target
@@ -27,15 +36,18 @@ Type=simple
User=__USER__ User=__USER__
Group=__USER__ Group=__USER__
WorkingDirectory=__DIR__ WorkingDirectory=__DIR__
# .env 由服务端自己从 WorkingDirectory 加载(工作目录即安装根目录)
# 配置从这里注入(唯一的配置真身;安装目录里的 .env 是指向它的软链,见 docs/linux-deploy.md)。
# systemd 会剥掉值两侧的引号,所以同一份文件给 dotenv / shell source / systemd 三种读法都能用。
# 前面不加 "-":文件被删掉时直接启动失败,比拿着一份假配置跑起来更容易发现。
EnvironmentFile=__CONFIG__
ExecStart=__NODE__ server/dist/index.js ExecStart=__NODE__ server/dist/index.js
Environment=NODE_ENV=production
Restart=always Restart=always
RestartSec=3 RestartSec=3
# Socket.IO 长连接较多:提高文件描述符上限 # Socket.IO 长连接较多:提高文件描述符上限
LimitNOFILE=65535 LimitNOFILE=65535
# 优雅退出:给在途请求与 websocket 收尾时间 # 优雅退出:给在途请求与 websocket 收尾时间(index.ts 处理 SIGTERM/SIGINT)
KillSignal=SIGTERM KillSignal=SIGTERM
TimeoutStopSec=20 TimeoutStopSec=20
@@ -44,12 +56,26 @@ StandardOutput=journal
StandardError=journal StandardError=journal
SyslogIdentifier=classhelper SyslogIdentifier=classhelper
# 基础加固(服务只需要读程序、写 data/logs) # ---------------------------------------------------------------- 加固
NoNewPrivileges=true # 为什么 ReadWritePaths 要给整个 __DIR__ 与配置目录,而不是只给 data/logs:
PrivateTmp=true # 1) Web 端「数据库管理 → 一键切换」会在运行中改写 server/prisma/schema.prisma,
# 并把重新生成的 Prisma Client 编译进 server/dist/generated —— 那两处都在 __DIR__ 里;
# 2) 同一功能切换成功后要改写 __CONFIG__(DATABASE_PROVIDER / DATABASE_URL 两行)。
# ProtectSystem=full 默认把 /etc 与 /usr 设成只读,ReadWritePaths 是官方的"打洞"方式。
# 服务本来就以 __USER__ 身份运行,这里给的写权限没有超出它的既有边界。
ProtectSystem=full ProtectSystem=full
ProtectHome=true ProtectHome=true
ReadWritePaths=__DIR__/data __DIR__/logs PrivateTmp=true
NoNewPrivileges=true
ReadWritePaths=__DIR__ __CONFIGDIR__
ProtectKernelTunables=true
ProtectKernelModules=true
ProtectControlGroups=true
RestrictSUIDSGID=true
LockPersonality=true
# 需要 AF_NETLINK:glibc 解析主机名(MySQL 主机 / GitHub API)时会用到
RestrictAddressFamilies=AF_INET AF_INET6 AF_UNIX AF_NETLINK
[Install] [Install]
WantedBy=multi-user.target WantedBy=multi-user.target
+56
View File
@@ -0,0 +1,56 @@
# 班级小助手 · Docker 单容器部署(SQLite + 数据卷)
#
# 适用:云服务器 / 与别的服务共用一台机器。相比 deploy/docker-compose.yml(MySQL 变体)
# 少跑一个数据库容器,内存占用小很多;数据落在 Docker 卷 classhelper-data 里。
#
# 使用:
# 1) cp deploy/.env.sqlite.example deploy/.env.sqlite 并填 JWT_SECRET / 管理员密码
# (生成密钥:node -e "console.log(require('crypto').randomBytes(48).toString('hex'))")
# 2) docker compose -f deploy/docker-compose.sqlite.yml --env-file deploy/.env.sqlite up -d --build
# 3) 访问:http://<服务器IP>:${SERVER_PORT}/
#
# 首次启动(AUTO_MIGRATE=true)会自动执行 prisma/migrations 里的建表语句并创建管理员账号,
# 见 packages/server/src/lib/db-bootstrap.ts("Docker 挂载空数据卷"就是它的目标场景之一)。
#
# 备份:docker run --rm -v classhelper-sqlite_classhelper-data:/data -v "$PWD":/backup alpine \
# tar czf /backup/classhelper-db.tar.gz -C /data .
name: classhelper-sqlite
services:
server:
build:
context: ..
dockerfile: deploy/Dockerfile
target: runtime
image: classhelper-server:${APP_VERSION:-1.1.0}
restart: unless-stopped
environment:
NODE_ENV: production
HOST: 0.0.0.0
PORT: 4000
DATABASE_PROVIDER: sqlite
# 必须写绝对路径:容器里 serverRoot 是 /app/server,相对路径会解析到别处
DATABASE_URL: file:/app/data/classhelper.db
# 首启动自动建表 + 建管理员;生产自检会拒绝 dev.db 与过短的 JWT_SECRET
AUTO_MIGRATE: 'true'
STARTUP_DB_CHECK: 'true'
JWT_SECRET: ${JWT_SECRET:?请在 deploy/.env.sqlite 中设置(≥32 位随机串)}
JWT_EXPIRES_IN: ${JWT_EXPIRES_IN:-7d}
CORS_ORIGIN: ${CORS_ORIGIN:-*}
TRUST_PROXY: '1'
RATE_LIMIT_ENABLED: 'true'
LOG_LEVEL: ${LOG_LEVEL:-info}
TERM_START_DATE: ${TERM_START_DATE:-}
INITIAL_ADMIN_USERNAME: ${INITIAL_ADMIN_USERNAME:-admin}
INITIAL_ADMIN_PASSWORD: ${INITIAL_ADMIN_PASSWORD:-admin123}
DEFAULT_CLASS_PASSWORD: ${DEFAULT_CLASS_PASSWORD:-123456}
DEFAULT_TEACHER_PASSWORD: ${DEFAULT_TEACHER_PASSWORD:-123456}
ports:
- '${SERVER_PORT:-4000}:4000'
volumes:
- classhelper-data:/app/data
volumes:
classhelper-data:
+2 -2
View File
@@ -60,7 +60,7 @@ services:
context: .. context: ..
dockerfile: deploy/Dockerfile dockerfile: deploy/Dockerfile
target: runtime target: runtime
image: classhelper-server:${APP_VERSION:-0.1.0} image: classhelper-server:${APP_VERSION:-1.1.0}
restart: unless-stopped restart: unless-stopped
environment: environment:
NODE_ENV: production NODE_ENV: production
@@ -78,7 +78,7 @@ services:
TERM_START_DATE: ${TERM_START_DATE:-} TERM_START_DATE: ${TERM_START_DATE:-}
INITIAL_ADMIN_USERNAME: ${INITIAL_ADMIN_USERNAME:-admin} INITIAL_ADMIN_USERNAME: ${INITIAL_ADMIN_USERNAME:-admin}
INITIAL_ADMIN_PASSWORD: ${INITIAL_ADMIN_PASSWORD:-admin123} INITIAL_ADMIN_PASSWORD: ${INITIAL_ADMIN_PASSWORD:-admin123}
DEFAULT_STUDENT_PASSWORD: ${DEFAULT_STUDENT_PASSWORD:-123456}
DEFAULT_CLASS_PASSWORD: ${DEFAULT_CLASS_PASSWORD:-123456} DEFAULT_CLASS_PASSWORD: ${DEFAULT_CLASS_PASSWORD:-123456}
DEFAULT_TEACHER_PASSWORD: ${DEFAULT_TEACHER_PASSWORD:-123456} DEFAULT_TEACHER_PASSWORD: ${DEFAULT_TEACHER_PASSWORD:-123456}
ports: ports:
+9 -274
View File
@@ -1,279 +1,14 @@
#!/usr/bin/env bash #!/usr/bin/env bash
# --------------------------------------------------------------------------- # ---------------------------------------------------------------------------
# 班级小助手 · 服务端 Linux 一键部署(systemd + SQLite,单机单实例) # 兼容壳:早期文档、脚本与 README 里写的是 deploy/install-linux.sh,
# 现在安装器统一在 deploy/install.sh(避免两份实现漂移)。
# #
# 干什么: # 两者参数完全一致:
# 在 Linux 服务器上把服务端装成 systemd 服务,布局与已验证的 Windows 免安装目录完全一致: # sudo bash deploy/install-linux.sh --port 8080
# /opt/classhelper/ # 等价于
# ├── .env 全部配置(首次安装随机生成 JWT_SECRET) # sudo bash deploy/install.sh --port 8080
# ├── server/dist 后端程序(入口 index.js)
# ├── server/prisma 迁移 SQL(AUTO_MIGRATE=true 时首启动自动执行)
# ├── web/ Web 管理端(由后端托管,单端口 4000)
# ├── node_modules/ 仅生产依赖(npm install --omit=dev)
# ├── data/ classhelper.db + server.pid
# └── logs/ 预留(日志默认进 journald)
#
# 前置条件:
# - 在**仓库根目录**已执行过构建:pnpm build:shared && pnpm --filter @classhelper/server build \
# && pnpm --filter @classhelper/web-admin build
# - 目标机装好 Node.js ≥ 20.19(推荐 22 LTS);本脚本不代装 Node
#
# 用法(在仓库根目录执行,需要 root):
# sudo bash deploy/install-linux.sh # 安装/升级,默认端口 4000、目录 /opt/classhelper
# sudo bash deploy/install-linux.sh --port 8080 # 换端口
# sudo bash deploy/install-linux.sh --dir /srv/classhelper
# sudo bash deploy/install-linux.sh --no-service # 只铺文件,不装 systemd(自己接管进程)
# bash deploy/install-linux.sh --check # 只体检(不需要 root):校验构建产物/Node 版本/端口探针
# sudo bash deploy/install-linux.sh --uninstall # 停止并禁用服务(保留 data 与 .env)
#
# 升级:把新代码构建好后**再跑一次同样的命令**即可。脚本不会覆盖已有 .env(JWT 密钥与端口保持
# 不变,用户不用重新登录),只会补齐缺失项并覆盖程序文件。
#
# 注意:本脚本未在 Linux 实机验证过(开发机是 Windows,无 Docker/WSL 发行版)。
# 它复用的是**已验证**的两套布局:Windows 免安装目录(install/ 结构)与 deploy/Dockerfile
# 的 runtime 阶段(package.runtime.json + prisma/migrations + web/)。
# --------------------------------------------------------------------------- # ---------------------------------------------------------------------------
set -euo pipefail set -euo pipefail
DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
TARGET_DIR="/opt/classhelper" printf '\033[33m[classhelper]\033[0m install-linux.sh 已更名为 install.sh,本次自动转发(后续请直接用 install.sh)\n' >&2
SERVICE_USER="classhelper" exec bash "${DIR}/install.sh" "$@"
PORT="4000"
WITH_SERVICE=1
UNINSTALL=0
CHECK_ONLY=0
SERVICE_NAME="classhelper"
while [ $# -gt 0 ]; do
case "$1" in
--dir) TARGET_DIR="$2"; shift 2 ;;
--port) PORT="$2"; shift 2 ;;
--user) SERVICE_USER="$2"; shift 2 ;;
--no-service) WITH_SERVICE=0; shift ;;
--check) CHECK_ONLY=1; shift ;;
--uninstall) UNINSTALL=1; shift ;;
-h|--help) sed -n '2,40p' "$0"; exit 0 ;;
*) echo "未知参数:$1(用 --help 看用法)" >&2; exit 2 ;;
esac
done
log() { printf '\033[32m[classhelper]\033[0m %s\n' "$*"; }
warn() { printf '\033[33m[classhelper]\033[0m %s\n' "$*" >&2; }
die() { printf '\033[31m[classhelper]\033[0m %s\n' "$*" >&2; exit 1; }
# 就绪探针:优先 curl(几乎每台 Linux 都有),否则退回 node。
# 注意不要用 `node -e "...process.exit()"` —— 在部分 Node 版本上于 promise 回调里硬退会触发
# libuv 断言崩溃(本机 Windows 实测退出码 -1073740791),改成设置 process.exitCode 让事件循环自然结束。
probe_ready() {
if command -v curl >/dev/null 2>&1; then
curl -fsS -o /dev/null --max-time 3 "http://127.0.0.1:${PORT}/healthz" >/dev/null 2>&1
return $?
fi
"$NODE_BIN" -e "fetch('http://127.0.0.1:${PORT}/healthz').then(r=>{process.exitCode=r.ok?0:1}).catch(()=>{process.exitCode=1})" >/dev/null 2>&1
}
[ "$(id -u)" = "0" ] || { [ "$CHECK_ONLY" = "1" ] || die "请用 root 执行:sudo bash deploy/install-linux.sh"; }
# ---------------------------------------------------------------- 卸载分支
if [ "$UNINSTALL" = "1" ]; then
if systemctl list-unit-files | grep -q "^${SERVICE_NAME}.service"; then
systemctl disable --now "$SERVICE_NAME" || true
rm -f "/etc/systemd/system/${SERVICE_NAME}.service"
systemctl daemon-reload
log "已停止并移除 systemd 服务 ${SERVICE_NAME}"
else
warn "没有找到 ${SERVICE_NAME}.service(可能没装成服务)"
fi
log "程序文件与数据保留在 ${TARGET_DIR};确认不需要后再手动删除"
exit 0
fi
# ---------------------------------------------------------------- 定位仓库与产物
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
REPO_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)"
cd "$REPO_ROOT"
SERVER_DIST="packages/server/dist/index.js"
SERVER_PRISMA="packages/server/prisma"
WEB_DIST="packages/web-admin/dist/index.html"
SHARED_DIST="packages/shared/dist/index.js"
RUNTIME_PKG="deploy/package.runtime.json"
for f in "$SERVER_DIST" "$WEB_DIST" "$SHARED_DIST" "$RUNTIME_PKG"; do
[ -e "$f" ] || die "缺少构建产物:$f
请先在仓库根目录执行:
pnpm build:shared && pnpm --filter @classhelper/server build && pnpm --filter @classhelper/web-admin build"
done
[ -d "$SERVER_PRISMA/migrations" ] || die "缺少迁移文件目录:$SERVER_PRISMA/migrations"
# ---------------------------------------------------------------- Node 检查
NODE_BIN="$(command -v node || true)"
[ -n "$NODE_BIN" ] || die "未找到 node,请先安装 Node.js ≥ 20.19(推荐 22 LTS)"
NODE_MAJOR="$("$NODE_BIN" -p 'process.versions.node.split(".")[0]')"
NODE_MINOR="$("$NODE_BIN" -p 'process.versions.node.split(".")[1]')"
if [ "$NODE_MAJOR" -lt 20 ] || { [ "$NODE_MAJOR" -eq 20 ] && [ "$NODE_MINOR" -lt 19 ]; }; then
die "Node 版本过低:$("$NODE_BIN" -v)(要求 ≥ 20.19)"
fi
NPM_BIN="$(command -v npm || true)"
[ -n "$NPM_BIN" ] || die "未找到 npm(随 Node 一起安装)"
log "Node $("$NODE_BIN" -v) → $NODE_BIN"
# ---------------------------------------------------------------- 只体检
if [ "$CHECK_ONLY" = "1" ]; then
echo
echo "构建产物:"
for f in "$SERVER_DIST" "$WEB_DIST" "$SHARED_DIST" "$RUNTIME_PKG" "$SERVER_PRISMA/migrations"; do
printf ' %-42s %s\n' "$f" "OK"
done
printf ' %-42s %s\n' "迁移文件数量" "$(find "$SERVER_PRISMA/migrations" -mindepth 1 -maxdepth 1 -type d | wc -l | tr -d ' ')"
echo
echo "运行环境:"
printf ' %-42s %s\n' "node" "$("$NODE_BIN" -v)(要求 ≥ 20.19)"
printf ' %-42s %s\n' "npm" "$("$NPM_BIN" -v)"
printf ' %-42s %s\n' "systemd" "$(command -v systemctl >/dev/null 2>&1 && echo 可用 || echo '不可用(用 --no-service)')"
printf ' %-42s %s\n' "目标目录 ${TARGET_DIR}" "$([ -e "$TARGET_DIR" ] && echo '已存在(会就地升级,保留 .env)' || echo 尚未创建)"
printf ' %-42s %s\n' "端口 ${PORT} 上的既有服务" "$(probe_ready && echo '健康(就绪)' || echo '无响应')"
echo
log "--check 通过:构建产物与运行环境都满足,可以执行安装(sudo bash deploy/install-linux.sh)"
exit 0
fi
# ---------------------------------------------------------------- 用户与目录
if ! id -u "$SERVICE_USER" >/dev/null 2>&1; then
useradd --system --create-home --shell /usr/sbin/nologin "$SERVICE_USER" 2>/dev/null \
|| useradd --system --shell /sbin/nologin "$SERVICE_USER"
log "已创建系统用户 ${SERVICE_USER}"
fi
mkdir -p "${TARGET_DIR}/server" "${TARGET_DIR}/web" "${TARGET_DIR}/data" "${TARGET_DIR}/logs"
log "安装目录:${TARGET_DIR}"
# ---------------------------------------------------------------- 拷贝产物
rm -rf "${TARGET_DIR}/server/dist"
cp -R "packages/server/dist" "${TARGET_DIR}/server/dist"
rm -rf "${TARGET_DIR}/server/prisma"
cp -R "$SERVER_PRISMA" "${TARGET_DIR}/server/prisma"
# 运行时不读 schema,但保留一份便于排查
[ -f packages/server/prisma/schema.prisma ] && cp packages/server/prisma/schema.prisma "${TARGET_DIR}/server/prisma/schema.prisma"
rm -rf "${TARGET_DIR}/web"
cp -R "packages/web-admin/dist" "${TARGET_DIR}/web"
cp "$RUNTIME_PKG" "${TARGET_DIR}/package.json"
cp -R deploy/classhelper.service "${TARGET_DIR}/classhelper.service.template"
# 生产依赖(与 Dockerfile 的 runtime 阶段同一份清单)
if [ ! -d "${TARGET_DIR}/node_modules" ] || [ "${FORCE_NPM_INSTALL:-0}" = "1" ]; then
log "安装生产依赖(npm install --omit=dev,约 1~3 分钟)..."
( cd "$TARGET_DIR" && "$NPM_BIN" install --omit=dev --no-audit --no-fund )
else
log "复用已有 node_modules(如需强制重装:FORCE_NPM_INSTALL=1 再跑一次)"
fi
# workspace 共享包(后端 import '@classhelper/shared'):拷进 node_modules 里
mkdir -p "${TARGET_DIR}/node_modules/@classhelper/shared"
rm -rf "${TARGET_DIR}/node_modules/@classhelper/shared/dist"
cp -R "packages/shared/dist" "${TARGET_DIR}/node_modules/@classhelper/shared/dist"
cp packages/shared/package.json "${TARGET_DIR}/node_modules/@classhelper/shared/package.json"
# ---------------------------------------------------------------- .env(已存在则不覆盖)
ENV_FILE="${TARGET_DIR}/.env"
if [ -f "$ENV_FILE" ]; then
log "检测到已有 .env:保留现有配置(含 JWT_SECRET),只补齐缺失项"
else
JWT_SECRET="$("$NODE_BIN" -e 'console.log(require("crypto").randomBytes(48).toString("hex"))')"
cat > "$ENV_FILE" <<EOF
# 班级小助手服务端(install-linux.sh 生成,请妥善保管)
# 修改后重启服务生效:systemctl restart ${SERVICE_NAME}
NODE_ENV=production
HOST=0.0.0.0
PORT=${PORT}
# 数据库:SQLite 文件放在安装根目录的 data 下(备份只需复制该目录)
DATABASE_PROVIDER=sqlite
DATABASE_URL="file:../data/classhelper.db"
# 空库首启动自动执行随包迁移并创建管理员
AUTO_MIGRATE=true
# 令牌签名密钥(随机生成;更换后所有用户需重新登录)
JWT_SECRET=${JWT_SECRET}
JWT_EXPIRES_IN=7d
# 允许的跨域来源:走域名/反代时建议改成具体来源,例如 https://class.example.com
CORS_ORIGIN=*
# 前面有 Nginx 等反向代理时设为 1,限流才会按真实客户端 IP 统计
TRUST_PROXY=1
RATE_LIMIT_ENABLED=true
STARTUP_DB_CHECK=true
PID_FILE=../data/server.pid
LOG_LEVEL=info
BCRYPT_ROUNDS=10
DEFAULT_STUDENT_PASSWORD=123456
DEFAULT_CLASS_PASSWORD=123456
DEFAULT_TEACHER_PASSWORD=123456
TERM_START_DATE=
EOF
log "已生成 ${ENV_FILE}(含随机 JWT_SECRET)"
fi
# data/logs 必须可写;程序文件只读即可
chown -R "${SERVICE_USER}:${SERVICE_USER}" "${TARGET_DIR}/data" "${TARGET_DIR}/logs"
chown -R "${SERVICE_USER}:${SERVICE_USER}" "${TARGET_DIR}/node_modules"
chown "${SERVICE_USER}:${SERVICE_USER}" "$ENV_FILE"
chown -R root:root "${TARGET_DIR}/server" "${TARGET_DIR}/web"
chmod 600 "$ENV_FILE"
# ---------------------------------------------------------------- systemd
if [ "$WITH_SERVICE" = "1" ]; then
command -v systemctl >/dev/null 2>&1 || die "本机没有 systemd;请加 --no-service 自行托管进程"
sed -e "s#__NODE__#${NODE_BIN}#g" \
-e "s#__DIR__#${TARGET_DIR}#g" \
-e "s#__USER__#${SERVICE_USER}#g" \
deploy/classhelper.service > "/etc/systemd/system/${SERVICE_NAME}.service"
systemctl daemon-reload
systemctl enable "$SERVICE_NAME" >/dev/null
systemctl restart "$SERVICE_NAME"
log "等待服务就绪..."
ready=0
for _ in $(seq 1 60); do
if probe_ready; then
ready=1
break
fi
sleep 1
done
if [ "$ready" != "1" ]; then
warn "60 秒内没通过 /healthz,最近日志:"
journalctl -u "$SERVICE_NAME" -n 50 --no-pager || true
die "启动失败,请按上面的日志排查(常见:端口被占用、数据目录权限、JWT_SECRET 未生成)"
fi
log "服务已就绪 ✅"
else
log "已跳过 systemd(--no-service)。手动启动:"
echo " sudo -u ${SERVICE_USER} sh -c 'cd ${TARGET_DIR} && ${NODE_BIN} server/dist/index.js'"
fi
# ---------------------------------------------------------------- 结果
cat <<EOF
------------------------------------------------------------------
安装完成
访问管理端:http://<服务器IP>:${PORT}/
健康探针: http://<服务器IP>:${PORT}/healthz · /readyz
配置文件: ${ENV_FILE}
数据目录: ${TARGET_DIR}/data(备份只需复制这里)
查看日志: journalctl -u ${SERVICE_NAME} -f
重启服务: systemctl restart ${SERVICE_NAME}
首次启动会自动建表并创建管理员:admin / admin123(登录后请立即在右上角「修改密码」改掉)。
公网部署请在前面加 Nginx + HTTPS(deploy/nginx.conf 可直接用),并把 .env 里的
TRUST_PROXY 设为 1、CORS_ORIGIN 收敛到你的域名。
学生端客户端登录时填的「服务器地址」就是 https://你的域名(或 http://IP:${PORT})。
------------------------------------------------------------------
EOF
+1119
View File
File diff suppressed because it is too large. Load diff
+19
View File
@@ -0,0 +1,19 @@
# ---------------------------------------------------------------------------
# 班级小助手 · 日志轮转
# 由 deploy/install.sh 安装到 /etc/logrotate.d/classhelper
#
# copytruncate 而不是 create+信号:安装器与 classhelper 都是"追加写完就关"
# (`>>` 打开、写完立即关闭),没有常驻 fd 可通知,copytruncate 是这里唯一正确的做法。
# ---------------------------------------------------------------------------
/var/log/classhelper/*.log {
weekly
rotate 8
missingok
notifempty
compress
delaycompress
copytruncate
create 0600 root root
su root root
}
+4 -1
View File
@@ -1,12 +1,13 @@
{ {
"name": "classhelper-server-runtime", "name": "classhelper-server-runtime",
"version": "0.1.0", "version": "1.1.0",
"private": true, "private": true,
"type": "module", "type": "module",
"description": "班级小助手服务端运行时(安装包 / 容器内置)", "description": "班级小助手服务端运行时(安装包 / 容器内置)",
"dependencies": { "dependencies": {
"@libsql/client": "^0.17.0", "@libsql/client": "^0.17.0",
"@prisma/adapter-libsql": "7.10.0", "@prisma/adapter-libsql": "7.10.0",
"@prisma/adapter-mariadb": "7.10.0",
"@prisma/client": "7.10.0", "@prisma/client": "7.10.0",
"bcryptjs": "^3.0.3", "bcryptjs": "^3.0.3",
"compression": "^1.8.2", "compression": "^1.8.2",
@@ -16,7 +17,9 @@
"express-rate-limit": "^8.7.0", "express-rate-limit": "^8.7.0",
"helmet": "^8.3.0", "helmet": "^8.3.0",
"jsonwebtoken": "^9.0.3", "jsonwebtoken": "^9.0.3",
"prisma": "7.10.0",
"socket.io": "^4.8.3", "socket.io": "^4.8.3",
"typescript": "~5.9.3",
"xlsx": "0.18.5", "xlsx": "0.18.5",
"zod": "^4.6.2" "zod": "^4.6.2"
} }
+28
View File
@@ -0,0 +1,28 @@
# ---------------------------------------------------------------------------
# 班级小助手 · 登录 shell 环境变量
#
# 由 deploy/install.sh 安装到 /etc/profile.d/classhelper.sh(占位符替换成真实路径)。
# 生效方式:重新登录,或 `source /etc/profile.d/classhelper.sh`。
#
# 说明:`classhelper` 命令本身装在 /usr/local/bin(软链到 $CLASSHELPER_HOME/bin/classhelper),
# 不依赖这个文件也能用;这里提供的是路径类变量,方便写脚本时引用。
# ---------------------------------------------------------------------------
# 只在目录真实存在时导出:卸载后残留的 profile.d 不应该污染别人的环境
if [ -d '__DIR__' ]; then
export CLASSHELPER_HOME='__DIR__'
export CLASSHELPER_CONFIG='__CONFIG__'
export CLASSHELPER_LOG_DIR='__LOGDIR__'
export CLASSHELPER_BACKUP_DIR='__BACKUPDIR__'
export CLASSHELPER_SERVICE='classhelper'
case ":${PATH}:" in
*":${CLASSHELPER_HOME}/bin:"*) ;;
*) export PATH="${PATH}:${CLASSHELPER_HOME}/bin" ;;
esac
fi
# 让 `classhelper` 在非 root 登录时也能补全(bash 补全由 `classhelper completion bash` 输出)
if [ -n "${BASH_VERSION:-}" ] && [ -r /usr/share/bash-completion/completions/classhelper ]; then
. /usr/share/bash-completion/completions/classhelper
fi
+22
View File
@@ -0,0 +1,22 @@
# ---------------------------------------------------------------------------
# 班级小助手 · 定时备份(systemd timer)
# 由 `classhelper backup schedule daily|weekly` 安装(占位符 __BIN__ / __KEEP__ 由命令替换)
#
# 手工安装:
# sudo sed -e 's#__BIN__#/usr/local/bin/classhelper#' -e 's#__KEEP__#7#' \
# deploy/systemd/classhelper-backup.service > /tmp/x.service ...
# 然后 systemctl daemon-reload && systemctl enable --now classhelper-backup.timer
# ---------------------------------------------------------------------------
[Unit]
Description=ClassHelper 定时备份
Documentation=https://github.com/LoveChengke/ClassHelper
After=classhelper.service
[Service]
Type=oneshot
ExecStart=__BIN__ backup --quiet --keep __KEEP__
# 备份失败时不要静默:journalctl -u classhelper-backup 里能看到退出码与原因
StandardOutput=journal
StandardError=journal
SyslogIdentifier=classhelper-backup
+19
View File
@@ -0,0 +1,19 @@
# ---------------------------------------------------------------------------
# 班级小助手 · 定时备份(触发器)
# 由 `classhelper backup schedule daily|weekly` 安装;OnCalendar 行由命令按选择替换
# ---------------------------------------------------------------------------
[Unit]
Description=ClassHelper 定时备份触发器
Documentation=https://github.com/LoveChengke/ClassHelper
[Timer]
OnCalendar=__ONCALENDAR__
# 错开整点:避免所有装了本服务的机器在同一秒打盘
RandomizedDelaySec=30m
# 机器关机期间错过的备份在开机后补一次
Persistent=true
Unit=classhelper-backup.service
[Install]
WantedBy=timers.target
+335
View File
@@ -0,0 +1,335 @@
#!/usr/bin/env node
/**
* 班级小助手 · 离线账号工具(随 Linux 包发布,安装在 ${INSTALL_DIR}/tools/admin-cli.mjs)
*
* 为什么不用 HTTP API 改密码:`classhelper password` 要能在**服务停机**时救急,
* 而调 API 必须先有一个能登录的账号 —— 管理员忘了密码时就是死锁。
* 因此这里直连数据库,复用服务端自己的 Prisma Client 与 bcrypt 参数(`server/dist/lib/*`),
* 保证写入的哈希与登录校验用的是同一套实现。
*
* 安全约定(务必保持):
* - **密码只从 stdin 读**,绝不接受 argv / 环境变量形式的密码(否则会进 shell history 与 ps 输出);
* - 本工具自己**不打印任何密码**,也不写任何日志;
* - `dump-hash` 会输出 bcrypt 哈希 —— 仅由 root 调用的 `classhelper password` 用于改前备份,
* 调用方负责把结果落到 600 权限的文件里。
*
* 用法(全部由 classhelper 封装,一般不需要手工调):
* node tools/admin-cli.mjs info
* node tools/admin-cli.mjs list [--json]
* node tools/admin-cli.mjs dump-hash <用户名|class:班级码>
* node tools/admin-cli.mjs set-password <用户名> # 新密码从 stdin 读
* node tools/admin-cli.mjs set-class-password <班级码> # 新密码从 stdin 读
* node tools/admin-cli.mjs verify <用户名> # 待校验密码从 stdin 读
* node tools/admin-cli.mjs restore-hash <备份json路径>
* node tools/admin-cli.mjs snapshot <目标db文件> # SQLite 一致性快照(VACUUM INTO)
*
* 退出码:0 成功 / 1 通用失败 / 2 用法错误 / 3 目标不存在 / 4 密码不合规 / 5 数据库不可用
*/
import fs from 'node:fs';
import path from 'node:path';
import { fileURLToPath, pathToFileURL } from 'node:url';
const scriptDir = path.dirname(fileURLToPath(import.meta.url));
/** 安装根目录(tools/ 的上一级) */
const installDir = path.resolve(scriptDir, '..');
const serverDist = path.join(installDir, 'server', 'dist');
const EXIT = { OK: 0, FAIL: 1, USAGE: 2, NOT_FOUND: 3, WEAK: 4, NO_DB: 5 };
function fail(message, code = EXIT.FAIL) {
process.stderr.write(`admin-cli: ${message}\n`);
process.exitCode = code;
return null;
}
/** 一次性读完 stdin(去掉行尾换行;保留内部空白,密码里可以有空格) */
async function readSecretFromStdin() {
const chunks = [];
for await (const chunk of process.stdin) chunks.push(chunk);
return Buffer.concat(chunks).toString('utf8').replace(/\r?\n$/, '');
}
/** 与服务端一致的密码强度规则(classhelper 里还有一份交互式版本,两边保持同样口径) */
function checkStrength(password, username) {
const problems = [];
if (password.length < 8) problems.push('长度至少 8 位');
if (password.length > 128) problems.push('长度不要超过 128 位');
const kinds = [/[a-z]/, /[A-Z]/, /[0-9]/, /[^A-Za-z0-9]/].filter((re) => re.test(password)).length;
if (kinds < 3) problems.push('需包含小写字母 / 大写字母 / 数字 / 符号 中至少 3 类');
if (username && password.toLowerCase() === username.toLowerCase()) problems.push('不能与用户名相同');
if (/^(123456|password|admin|classhelper|qwerty|111111|abc123)/i.test(password) && password.length < 12) {
problems.push('过于常见,请换一个');
}
return problems;
}
/** 懒加载服务端模块:先做"库在不在"的检查,避免 libSQL 在连接时凭空建出一个空库 */
async function loadServerModules() {
const envFile = path.join(serverDist, 'config', 'env.js');
if (!fs.existsSync(envFile)) {
fail(`找不到服务端产物:${envFile}`, EXIT.NO_DB);
return null;
}
const env = await import(pathToFileURL(envFile).href);
if (env.env.databaseProvider === 'sqlite') {
// classhelper 做备份时会用 CLASSHELPER_SNAPSHOT_DB 显式指定数据文件(跳过硬编码路径假设)
const dbFile = process.env.CLASSHELPER_SNAPSHOT_DB || env.env.sqliteFilePath;
if (!dbFile || !fs.existsSync(dbFile)) {
fail(
`数据库文件不存在:${dbFile || '(未配置)'}\n` +
' 提示:全新安装请先 systemctl start classhelper 完成建表(AUTO_MIGRATE);',
EXIT.NO_DB,
);
return null;
}
}
const db = await import(pathToFileURL(path.join(serverDist, 'lib', 'db.js')).href);
const password = await import(pathToFileURL(path.join(serverDist, 'lib', 'password.js')).href);
return { env: env.env, prisma: db.prisma, disconnectPrisma: db.disconnectPrisma, ...password };
}
/** 目标账号:普通用户按 username,班级账号按 Class.code(学生端登录用的是班级码) */
async function resolveTarget(prisma, key) {
if (key.startsWith('class:')) {
const code = key.slice('class:'.length).toUpperCase();
const klass = await prisma.class.findUnique({ where: { code } });
if (!klass) return { error: `班级码不存在:${code}`, code: EXIT.NOT_FOUND };
return { kind: 'class', id: klass.id, label: `班级 ${klass.name}(码 ${klass.code})`, hash: klass.passwordHash };
}
const user = await prisma.user.findUnique({ where: { username: key } });
if (!user) return { error: `用户名不存在:${key}`, code: EXIT.NOT_FOUND };
if (user.role === 'STUDENT') {
return {
error: `学生没有个人账号(${key} 只是名单记录),学生端用「班级码 + 班级密码」登录,请用 --class 改班级密码`,
code: EXIT.NOT_FOUND,
};
}
return { kind: 'user', id: user.id, label: `${user.name}(${user.username} / ${user.role})`, hash: user.passwordHash };
}
/* ------------------------------------------------------------------ 子命令 */
/**
* SQLite 一致性快照:`VACUUM INTO` 在服务运行中也能拿到自洽的副本
* (直接 cp 数据文件可能抓到写入中的中间状态)。
* 目标文件必须不存在 —— 这是 SQLite 的硬要求,先删掉。
*/
async function cmdSnapshot(modules, dest) {
const { env, prisma } = modules;
if (env.databaseProvider !== 'sqlite') {
return fail('snapshot 只支持 SQLite;MySQL 请用 mysqldump', EXIT.FAIL);
}
const target = path.resolve(dest);
fs.mkdirSync(path.dirname(target), { recursive: true });
fs.rmSync(target, { force: true });
// VACUUM INTO 不接受参数占位符,只能拼字面量 —— 单引号按 SQL 规则翻倍转义
await prisma.$executeRawUnsafe(`VACUUM INTO '${target.replace(/'/g, "''")}'`);
if (!fs.existsSync(target)) return fail('快照未生成(VACUUM INTO 未报错但没有产出文件)', EXIT.FAIL);
process.stdout.write(`${target}\n`);
}
async function cmdInfo(modules) {
const { env, prisma } = modules;
const counts = {};
for (const model of ['user', 'class', 'course', 'schedule', 'homework', 'notification', 'grade']) {
counts[model] = await prisma[model].count();
}
const payload = {
provider: env.databaseProvider,
sqliteFile: env.sqliteFilePath || null,
serverRoot: env.serverRoot,
termStartDate: env.termStartDate || null,
counts,
};
process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
}
async function cmdList(modules, asJson) {
const { prisma } = modules;
const users = await prisma.user.findMany({
where: { role: { in: ['ADMIN', 'TEACHER'] } },
select: { username: true, name: true, role: true, classId: true, updatedAt: true },
orderBy: [{ role: 'asc' }, { username: 'asc' }],
});
const classes = await prisma.class.findMany({
select: { code: true, name: true, passwordHash: true },
orderBy: { code: 'asc' },
});
if (asJson) {
process.stdout.write(
`${JSON.stringify(
{
users,
classes: classes.map((item) => ({ code: item.code, name: item.name, hasPassword: !!item.passwordHash })),
},
null,
2,
)}\n`,
);
return;
}
process.stdout.write('可登录账号(教师 / 管理员):\n');
for (const user of users) {
process.stdout.write(` ${user.role.padEnd(8)} ${user.username.padEnd(16)} ${user.name}\n`);
}
process.stdout.write('\n班级账号(学生端用「班级码 + 班级密码」登录):\n');
for (const item of classes) {
const state = item.passwordHash ? '已设置' : '⚠ 未设置密码(该班当前无法登录)';
process.stdout.write(` ${item.code.padEnd(8)} ${item.name.padEnd(16)} ${state}\n`);
}
}
async function cmdDumpHash(modules, key) {
const { prisma } = modules;
const target = await resolveTarget(prisma, key);
if (target.error) return fail(target.error, target.code);
if (!target.hash) return fail(`${target.label} 当前没有密码(passwordHash 为空)`, EXIT.NOT_FOUND);
// 只给调用方(root)看的原始数据,不落到本工具的日志里
process.stdout.write(`${JSON.stringify({ target: key, kind: target.kind, id: target.id, hash: target.hash })}\n`);
}
async function cmdSetPassword(modules, key, readSecret) {
const { prisma, hashPassword } = modules;
const target = await resolveTarget(prisma, key);
if (target.error) return fail(target.error, target.code);
const secret = await readSecret();
const problems = checkStrength(secret, key);
if (problems.length > 0) return fail(`密码不合规:${problems.join(';')}`, EXIT.WEAK);
const hash = await hashPassword(secret);
if (target.kind === 'class') {
await prisma.class.update({ where: { id: target.id }, data: { passwordHash: hash } });
} else {
await prisma.user.update({ where: { id: target.id }, data: { passwordHash: hash } });
}
// 写完立刻复核一次:曾经出现过"bcrypt 参数不一致导致写进去的哈希验证不过"的排查成本
const ok = await modules.verifyPassword(secret, hash);
if (!ok) return fail('写入后复核失败:哈希无法通过校验,请用 restore-hash 回滚', EXIT.FAIL);
process.stdout.write(`已更新密码:${target.label}\n`);
}
async function cmdVerify(modules, key, readSecret) {
const { prisma, verifyPassword } = modules;
const target = await resolveTarget(prisma, key);
if (target.error) return fail(target.error, target.code);
const secret = await readSecret();
const ok = !!target.hash && (await verifyPassword(secret, target.hash));
process.stdout.write(`${ok ? 'match' : 'mismatch'}\n`);
if (!ok) process.exitCode = EXIT.FAIL;
}
async function cmdRestoreHash(modules, backupFile) {
const { prisma } = modules;
if (!fs.existsSync(backupFile)) return fail(`备份文件不存在:${backupFile}`, EXIT.NOT_FOUND);
let payload;
try {
payload = JSON.parse(fs.readFileSync(backupFile, 'utf8'));
} catch (error) {
return fail(`备份文件不是合法 JSON:${error.message}`);
}
const { target, hash } = payload;
if (typeof target !== 'string' || typeof hash !== 'string') {
return fail('备份文件缺少 target / hash 字段,拒绝回滚');
}
if (target.startsWith('class:')) {
await prisma.class.update({ where: { code: target.slice('class:'.length).toUpperCase() }, data: { passwordHash: hash } });
} else {
await prisma.user.update({ where: { username: target }, data: { passwordHash: hash } });
}
process.stdout.write(`已回滚密码哈希:${target}\n`);
}
/* ------------------------------------------------------------------ 入口 */
const argv = process.argv.slice(2);
const command = argv[0] ?? 'help';
const args = argv.slice(1);
const wantsJson = args.includes('--json');
const positional = args.filter((item) => !item.startsWith('--'));
function usage() {
process.stdout.write(
[
'classhelper 离线账号工具(一般由 classhelper 命令调用)',
'',
' info 输出数据库与表行数(JSON)',
' list [--json] 列出可登录账号与班级账号',
' dump-hash <用户名|class:班级码> 输出当前密码哈希(供改密前备份)',
' set-password <用户名> 从 stdin 读新密码并写入',
' set-class-password <班级码> 从 stdin 读新密码并写入班级账号',
' verify <用户名> 从 stdin 读密码,输出 match / mismatch',
' restore-hash <备份json路径> 用备份文件里的哈希回滚',
' snapshot <目标db文件> 把 SQLite 库一致性快照到指定路径(VACUUM INTO)',
'',
].join('\n'),
);
}
if (command === 'help' || command === '--help' || command === '-h') {
usage();
} else if (
![
'info',
'list',
'dump-hash',
'set-password',
'set-class-password',
'verify',
'restore-hash',
'snapshot',
].includes(command)
) {
fail(`未知子命令:${command}\n`, EXIT.USAGE);
usage();
} else {
const modules = await loadServerModules();
if (!modules) {
// 已经在 loadServerModules 里设了 exitCode
} else {
try {
switch (command) {
case 'info':
await cmdInfo(modules);
break;
case 'list':
await cmdList(modules, wantsJson);
break;
case 'dump-hash':
if (!positional[0]) fail('缺少目标账号', EXIT.USAGE);
else await cmdDumpHash(modules, positional[0]);
break;
case 'set-password':
case 'set-class-password': {
const key = command === 'set-class-password' ? `class:${positional[0] ?? ''}` : (positional[0] ?? '');
if (!positional[0]) fail('缺少目标账号', EXIT.USAGE);
else await cmdSetPassword(modules, key, readSecretFromStdin);
break;
}
case 'verify':
if (!positional[0]) fail('缺少目标账号', EXIT.USAGE);
else await cmdVerify(modules, positional[0], readSecretFromStdin);
break;
case 'restore-hash':
if (!positional[0]) fail('缺少备份文件路径', EXIT.USAGE);
else await cmdRestoreHash(modules, positional[0]);
break;
case 'snapshot':
if (!positional[0]) fail('缺少目标文件路径', EXIT.USAGE);
else await cmdSnapshot(modules, positional[0]);
break;
default:
usage();
}
} catch (error) {
fail(error instanceof Error ? error.message : String(error));
} finally {
// 不用 process.exit():在顶层 await 里硬退会踩 libuv 断言(见 AGENTS.md §7)
await modules.disconnectPrisma();
}
}
}
+302
View File
@@ -0,0 +1,302 @@
#!/usr/bin/env bash
# ---------------------------------------------------------------------------
# 班级小助手 · Linux 安装与运维链路验收(在**已安装的服务器上**运行)
#
# 覆盖:安装结果 → 服务可用性 → API 登录 → 改密(含回滚与审计)→ 备份 →
# 配置读写 → key rotate →(可选)升级 / 回滚 / 卸载
#
# 用法(在服务器上,需要 root):
# sudo bash verify-linux.sh # 基础链路
# sudo bash verify-linux.sh --full --package /tmp/xxx.tar.gz # 追加升级/回滚
# sudo bash verify-linux.sh --admin-password-stdin # 密码从 stdin 读一行(不进 argv/history)
#
# 说明:
# - 本脚本会**真的**改一次管理员密码(换成随机强密码,再改回去),并真的发一条备份;
# - 除了 --purge 的卸载测试,不会删除任何数据;
# - 全程不需要外网(升级测试用 --package 指向本地包)。
# ---------------------------------------------------------------------------
set -uo pipefail
INSTALL_DIR="/opt/classhelper"
CONFIG_FILE="/etc/classhelper/config.env"
LOG_DIR="/var/log/classhelper"
BACKUP_DIR="/var/backups/classhelper"
PORT=""
ADMIN_USER="admin"
ADMIN_PASSWORD=""
ADMIN_PASSWORD_FROM_STDIN=0
DO_FULL=0
PACKAGE=""
TOTAL=0; PASS=0; FAIL=0
FAILED=()
while [ $# -gt 0 ]; do
case "$1" in
--dir) INSTALL_DIR="$2"; shift 2 ;;
--config) CONFIG_FILE="$2"; shift 2 ;;
--port) PORT="$2"; shift 2 ;;
--user) ADMIN_USER="$2"; shift 2 ;;
--admin-password) ADMIN_PASSWORD="$2"; shift 2 ;;
--admin-password-stdin) ADMIN_PASSWORD_FROM_STDIN=1; shift ;;
--package) PACKAGE="$2"; shift 2 ;;
--full) DO_FULL=1; shift ;;
-h|--help) sed -n '2,18p' "$0"; exit 0 ;;
*) echo "未知参数:$1" >&2; exit 2 ;;
esac
done
if [ -t 1 ]; then G=$'\033[32m'; R=$'\033[31m'; Y=$'\033[33m'; D=$'\033[2m'; B=$'\033[1m'; N=$'\033[0m'; else G=; R=; Y=; D=; B=; N=; fi
section() { printf '\n%s▶ %s%s\n' "$B" "$1" "$N"; }
check() { # $1=描述 $2=0 通过
TOTAL=$((TOTAL + 1))
if [ "$2" = "0" ]; then
PASS=$((PASS + 1)); printf ' %s✔%s %s\n' "$G" "$N" "$1"
else
FAIL=$((FAIL + 1)); FAILED+=("$1"); printf ' %s✘%s %s\n' "$R" "$N" "$1"
fi
}
note() { printf ' %s· %s%s\n' "$D" "$1" "$N"; }
[ "$(id -u)" = "0" ] || { echo "请用 root 运行:sudo bash verify-linux.sh" >&2; exit 1; }
if [ ! -f "$CONFIG_FILE" ]; then
echo "找不到安装:${CONFIG_FILE} 不存在(用 --config 指定,或先跑 install.sh)" >&2
exit 1
fi
read_cfg() { sed -n "s/^[[:space:]]*$1=//p" "$CONFIG_FILE" | tail -n 1 | tr -d '"'; }
[ -n "$PORT" ] || PORT="$(read_cfg PORT)"
[ -n "$PORT" ] || PORT=4000
CLASSHELPER="${INSTALL_DIR}/bin/classhelper"
API="http://127.0.0.1:${PORT}"
CURL=(curl -fsS --noproxy '*')
if [ "$ADMIN_PASSWORD_FROM_STDIN" = "1" ]; then IFS= read -r ADMIN_PASSWORD || true; fi
printf '%s班级小助手 · Linux 安装验收%s\n' "$B" "$N"
note "安装目录 ${INSTALL_DIR}|配置 ${CONFIG_FILE}|端口 ${PORT}"
# ---------------------------------------------------------------- 1. 安装结果
section "安装结果"
check "安装目录存在且含 server/dist/index.js" "$([ -f "${INSTALL_DIR}/server/dist/index.js" ] && echo 0 || echo 1)"
check "版本文件 VERSION 可读" "$([ -s "${INSTALL_DIR}/VERSION" ] && echo 0 || echo 1)"
check "安装元数据 .installed.json 存在" "$([ -f "${INSTALL_DIR}/.installed.json" ] && echo 0 || echo 1)"
cfg_mode="$(stat -c '%a' "$CONFIG_FILE" 2>/dev/null || echo '?')"
check "配置文件权限 600(实际 ${cfg_mode})" "$([ "$cfg_mode" = "600" ] && echo 0 || echo 1)"
dir_mode="$(stat -c '%a' "$(dirname "$CONFIG_FILE")" 2>/dev/null || echo '?')"
check "配置目录权限 700(实际 ${dir_mode})" "$([ "$dir_mode" = "700" ] && echo 0 || echo 1)"
env_link="${INSTALL_DIR}/.env"
check "安装目录 .env 是指向配置真身的软链(Web 端切库依赖它)" \
"$([ -L "$env_link" ] && [ "$(readlink "$env_link")" = "$CONFIG_FILE" ] && echo 0 || echo 1)"
node_bin="${INSTALL_DIR}/runtime/node/bin/node"
node_ver="$([ -x "$node_bin" ] && "$node_bin" -v 2>/dev/null || echo '')"
check "内置 Node 可用(${node_ver:-未找到})" "$([ -n "$node_ver" ] && echo 0 || echo 1)"
check "classhelper 命令已装到 /usr/local/bin" "$([ -x /usr/local/bin/classhelper ] && echo 0 || echo 1)"
check "安装日志 ${LOG_DIR}/install.log 存在" "$([ -s "${LOG_DIR}/install.log" ] && echo 0 || echo 1)"
check "审计日志 ${LOG_DIR}/audit.log 存在" "$([ -f "${LOG_DIR}/audit.log" ] && echo 0 || echo 1)"
check "审计/安装日志权限不放行他人(≤640)" \
"$([ "$(stat -c '%a' "${LOG_DIR}/audit.log" 2>/dev/null || echo 644)" -le 640 ] && echo 0 || echo 1)"
check "/etc/profile.d/classhelper.sh 已写入" "$([ -f /etc/profile.d/classhelper.sh ] && echo 0 || echo 1)"
profile_home="$(bash -lc 'echo "${CLASSHELPER_HOME:-}"' 2>/dev/null)"
check "新登录 shell 里 CLASSHELPER_HOME 生效(${profile_home:-空})" "$([ -n "$profile_home" ] && echo 0 || echo 1)"
# ---------------------------------------------------------------- 2. 服务
section "服务与探针"
if command -v systemctl >/dev/null 2>&1 && [ -f /etc/systemd/system/classhelper.service ]; then
check "systemd 单元已安装" 0
check "服务处于 active" "$(systemctl is-active --quiet classhelper && echo 0 || echo 1)"
check "服务开机自启(enabled)" "$(systemctl is-enabled --quiet classhelper 2>/dev/null && echo 0 || echo 1)"
else
check "systemd 单元已安装" 1
fi
check "/healthz 返回 200" "$("${CURL[@]}" -o /dev/null "${API}/healthz" 2>/dev/null && echo 0 || echo 1)"
status_json="$("$CLASSHELPER" status --json 2>/dev/null || true)"
check "classhelper status --json 是合法 JSON" "$(printf '%s' "$status_json" | grep -q '"healthy"' && echo 0 || echo 1)"
check "status 报告 healthy=yes" "$(printf '%s' "$status_json" | grep -q '"healthy": "yes"' && echo 0 || echo 1)"
check "status 报告的端口与实际一致" "$(printf '%s' "$status_json" | grep -q "\"port\": ${PORT}" && echo 0 || echo 1)"
check "classhelper help 可执行(非 root 也能看)" "$("$CLASSHELPER" help >/dev/null 2>&1 && echo 0 || echo 1)"
check "classhelper completion bash 有输出" "$("$CLASSHELPER" completion bash 2>/dev/null | grep -q 'classhelper' && echo 0 || echo 1)"
doctor_out="$("$CLASSHELPER" doctor 2>&1 || true)"
check "classhelper doctor 无待处理项" "$(printf '%s' "$doctor_out" | grep -q '体检通过' && echo 0 || echo 1)"
if ! printf '%s' "$doctor_out" | grep -q '体检通过'; then
printf '%s' "$doctor_out" | sed 's/^/ /'
fi
# ---------------------------------------------------------------- 3. API
section "API 与登录"
TOKEN=""
login() { # $1=密码 → 输出 token(失败则空)
"${CURL[@]}" -X POST "${API}/api/auth/login" -H 'content-type: application/json' \
-d "{\"username\":\"${ADMIN_USER}\",\"password\":\"$1\"}" 2>/dev/null \
| sed -n 's/.*"token"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p'
}
if [ -z "$ADMIN_PASSWORD" ]; then
note "未提供 --admin-password(-stdin),跳过登录与改密用例"
else
TOKEN="$(login "$ADMIN_PASSWORD")"
check "管理员用提供的密码能登录并拿到 token" "$([ -n "$TOKEN" ] && echo 0 || echo 1)"
if [ -n "$TOKEN" ]; then
classes="$("${CURL[@]}" -H "Authorization: Bearer ${TOKEN}" "${API}/api/classes" 2>/dev/null || true)"
check "带 token 能读业务接口 /api/classes" "$(printf '%s' "$classes" | grep -q '"data"' && echo 0 || echo 1)"
me="$("${CURL[@]}" -H "Authorization: Bearer ${TOKEN}" "${API}/api/auth/me" 2>/dev/null || true)"
check "/api/auth/me 返回的是 ADMIN" "$(printf '%s' "$me" | grep -q '"ADMIN"' && echo 0 || echo 1)"
fi
fi
# ---------------------------------------------------------------- 4. 改密
if [ -n "$TOKEN" ]; then
section "password 子命令(改密 → 回滚 → 审计)"
# 生成一个一定满足强度要求的密码(大小写+数字+符号,且不落在常见口令里)
GENERATED="Ch$(head -c 12 /dev/urandom | od -An -tx1 | tr -d ' \n')!a9Z"
before_count="$(grep -c 'action=password' "${LOG_DIR}/audit.log" 2>/dev/null || echo 0)"
# 密码经管道进 stdin,不出现在 argv / 环境变量 / shell history
out="$(printf '%s\n%s\n' "$GENERATED" "$GENERATED" | "$CLASSHELPER" password "$ADMIN_USER" 2>&1)"
check "classhelper password 执行成功" "$(printf '%s' "$out" | grep -q '密码已更新' && echo 0 || echo 1)"
new_token="$(login "$GENERATED")"
check "新密码能登录" "$([ -n "$new_token" ] && echo 0 || echo 1)"
old_token="$(login "$ADMIN_PASSWORD")"
check "旧密码已失效(登录被拒)" "$([ -z "$old_token" ] && echo 0 || echo 1)"
hash_backup="$(ls -1t "${BACKUP_DIR}"/password-*.json 2>/dev/null | head -n 1 || true)"
check "改密前备份了原哈希(${hash_backup:-无})" "$([ -n "$hash_backup" ] && echo 0 || echo 1)"
check "哈希备份权限 600" \
"$([ -n "$hash_backup" ] && [ "$(stat -c '%a' "$hash_backup")" = "600" ] && echo 0 || echo 1)"
after_count="$(grep -c 'action=password' "${LOG_DIR}/audit.log" 2>/dev/null || echo 0)"
check "审计日志新增了 password 记录" "$([ "${after_count:-0}" -gt "${before_count:-0}" ] && echo 0 || echo 1)"
check "审计日志里没有新密码明文" "$(grep -q -- "$GENERATED" "${LOG_DIR}/audit.log" 2>/dev/null && echo 1 || echo 0)"
check "审计日志里没有原密码明文" "$(grep -q -- "$ADMIN_PASSWORD" "${LOG_DIR}/audit.log" 2>/dev/null && echo 1 || echo 0)"
check "弱密码被拒绝(长度/种数不足)" \
"$(printf 'abc\nabc\n' | "$CLASSHELPER" password "$ADMIN_USER" 2>&1 | grep -q '不合规' && echo 0 || echo 1)"
check "密码不合规时不会卡死(stdin 结束即退出)" \
"$(printf 'abc\n' | timeout 20 "$CLASSHELPER" password "$ADMIN_USER" >/dev/null 2>&1; [ $? -ne 124 ] && echo 0 || echo 1)"
check "password --list 能列出账号" \
"$("$CLASSHELPER" password --list 2>&1 | grep -q "$ADMIN_USER" && echo 0 || echo 1)"
# 用改密前保存的哈希把账号恢复原样:比再改一次密码更可靠
# (原密码若是 admin123 这类弱口令,改回去会被强度校验挡下 —— 那是产品的正确行为)
if [ -n "$hash_backup" ]; then
restore_hash_out="$(LOG_LEVEL=error DOTENV_CONFIG_QUIET=true "$node_bin" "${INSTALL_DIR}/tools/admin-cli.mjs" restore-hash "$hash_backup" 2>&1 || true)"
check "restore-hash 能把原哈希回滚回来" "$(printf '%s' "$restore_hash_out" | grep -q '已回滚密码哈希' && echo 0 || echo 1)"
check "原密码重新可用" "$([ -n "$(login "$ADMIN_PASSWORD")" ] && echo 0 || echo 1)"
fi
else
note "跳过改密用例(没有可用的登录会话)"
fi
# ---------------------------------------------------------------- 5. 备份
section "backup 子命令"
backup_out="$("$CLASSHELPER" backup --keep 5 2>&1)"
check "classhelper backup 执行成功" "$(printf '%s' "$backup_out" | grep -q '备份完成' && echo 0 || echo 1)"
latest="$(ls -1dt "${BACKUP_DIR}"/*/ 2>/dev/null | head -n 1)"
check "生成了新的备份目录" "$([ -n "$latest" ] && echo 0 || echo 1)"
if [ -n "$latest" ]; then
check "备份含 config.env" "$([ -f "${latest}config.env" ] && echo 0 || echo 1)"
check "备份 meta.json 带版本号" "$(grep -q '"version"' "${latest}meta.json" 2>/dev/null && echo 0 || echo 1)"
db_kind="$(read_cfg DATABASE_PROVIDER)"
if [ "$db_kind" = "sqlite" ]; then
snap="${latest}classhelper.db"
check "备份含 SQLite 快照" "$([ -s "$snap" ] && echo 0 || echo 1)"
# 一致性快照必须是完整的 SQLite 文件(VACUUM INTO 产物)
check "快照是合法 SQLite 文件(文件头正确)" \
"$([ -n "$snap" ] && [ "$(head -c 15 "$snap" 2>/dev/null)" = "SQLite format 3" ] && echo 0 || echo 1)"
check "快照权限 600" "$([ -n "$snap" ] && [ "$(stat -c '%a' "$snap")" = "600" ] && echo 0 || echo 1)"
else
note "数据库是 MySQL,跳过 SQLite 快照用例"
fi
check "备份目录权限 700" "$([ "$(stat -c '%a' "${latest%/}" 2>/dev/null)" = "700" ] && echo 0 || echo 1)"
fi
check "backup list 能列出备份" "$("$CLASSHELPER" backup list 2>&1 | grep -qE '^ [0-9]{8}-' && echo 0 || echo 1)"
# ---------------------------------------------------------------- 6. 配置
section "config 子命令"
check "config get PORT 返回当前端口" "$([ "$("$CLASSHELPER" config get PORT)" = "$PORT" ] && echo 0 || echo 1)"
masked="$("$CLASSHELPER" config show 2>/dev/null | grep '^JWT_SECRET=')"
check "config show 对 JWT_SECRET 打码" "$(printf '%s' "$masked" | grep -q '\*\*\*\*' && echo 0 || echo 1)"
check "config show 没打印出真实密钥" \
"$(secret="$(read_cfg JWT_SECRET)"; [ -n "$secret" ] && printf '%s' "$masked" | grep -q -- "$secret" && echo 1 || echo 0)"
# 用一个无害的键做读写往返(不重启服务)
printf 'CH_VERIFY_PROBE=1\n' >>"$CONFIG_FILE"
probe="$("$CLASSHELPER" config get CH_VERIFY_PROBE 2>/dev/null)"
check "config get 能读到新增键" "$([ "$probe" = "1" ] && echo 0 || echo 1)"
sed -i '/^CH_VERIFY_PROBE=/d' "$CONFIG_FILE"
# ---------------------------------------------------------------- 7. key rotate
if [ -n "$TOKEN" ]; then
section "key rotate"
if [ "${CLASSHELPER_VERIFY_SKIP_KEY_ROTATE:-0}" = "1" ]; then
note "按环境变量跳过"
else
old_secret="$(read_cfg JWT_SECRET)"
# key rotate 会问一次确认;无 tty 时从 stdin 读,因此用管道喂 yes
printf 'yes\n' | CLASSHELPER_NO_TTY=1 "$CLASSHELPER" key rotate >/dev/null 2>&1 || true
new_secret="$(read_cfg JWT_SECRET)"
check "key rotate 改变了 JWT_SECRET" "$([ -n "$new_secret" ] && [ "$new_secret" != "$old_secret" ] && echo 0 || echo 1)"
check "新密钥长度 ≥32" "$([ "${#new_secret}" -ge 32 ] && echo 0 || echo 1)"
check "轮换后服务仍可用" "$("${CURL[@]}" -o /dev/null "${API}/healthz" && echo 0 || echo 1)"
check "轮换前的 token 已失效(/api/auth/me 返回 401)" \
"$(code="$(curl -s --noproxy '*' -o /dev/null -w '%{http_code}' -H "Authorization: Bearer ${TOKEN}" "${API}/api/auth/me")"; [ "$code" = "401" ] && echo 0 || echo 1)"
# 轮换后要重新登录,否则后面的用例会带着失效 token 跑
TOKEN="$(login "$ADMIN_PASSWORD")"
check "轮换后重新登录成功" "$([ -n "$TOKEN" ] && echo 0 || echo 1)"
fi
fi
# ---------------------------------------------------------------- 8. 升级 / 回滚
if [ "$DO_FULL" = "1" ]; then
section "upgrade / rollback(--full)"
if [ -z "$PACKAGE" ]; then
note "未提供 --package,跳过升级用例"
else
before_version="$("$CLASSHELPER" version 2>/dev/null | awk '{print $2}')"
sha="$(sha256sum "$PACKAGE" | awk '{print $1}')"
up_out="$("$CLASSHELPER" upgrade --url "$PACKAGE" --sha256 "$sha" --force 2>&1)"
check "upgrade 执行成功" "$(printf '%s' "$up_out" | grep -q '升级完成' && echo 0 || echo 1)"
check "升级后服务仍就绪" "$("${CURL[@]}" -o /dev/null "${API}/healthz" && echo 0 || echo 1)"
check "升级后配置未被改动(JWT_SECRET 保持)" \
"$([ "$(read_cfg JWT_SECRET)" = "${new_secret:-$(read_cfg JWT_SECRET)}" ] && echo 0 || echo 1)"
check "产生了程序快照(可回滚)" "$(ls -1 "${BACKUP_DIR}/rollback" 2>/dev/null | grep -q . && echo 0 || echo 1)"
check "坏包被拒绝(sha256 不匹配时不改动任何文件)" \
"$("$CLASSHELPER" upgrade --url "$PACKAGE" --sha256 0000000000000000000000000000000000000000000000000000000000000000 2>&1 | grep -q '校验失败' && echo 0 || echo 1)"
check "校验失败后服务仍在运行" "$("${CURL[@]}" -o /dev/null "${API}/healthz" && echo 0 || echo 1)"
note "(回滚需要交互确认,这里用 yes 管道)"
rb_out="$(printf 'yes\n' | "$CLASSHELPER" rollback 2>&1)"
check "rollback 执行成功" "$(printf '%s' "$rb_out" | grep -qE '已回滚到|回滚' && echo 0 || echo 1)"
check "回滚后服务仍就绪" "$("${CURL[@]}" -o /dev/null "${API}/healthz" && echo 0 || echo 1)"
note "升级前版本 ${before_version}|升级后 $("$CLASSHELPER" version 2>/dev/null | awk '{print $2}')"
fi
fi
# ---------------------------------------------------------------- 结果
printf '\n'
if [ "$FAIL" = "0" ]; then
printf '%s=== 结果:%s/%s 项通过 ===%s\n' "$G" "$PASS" "$TOTAL" "$N"
else
printf '%s=== 结果:%s/%s 项通过,%s 项失败 ===%s\n' "$R" "$PASS" "$TOTAL" "$FAIL" "$N"
printf '%s失败项:%s\n' "$Y" "$N"
for item in "${FAILED[@]}"; do printf ' · %s\n' "$item"; done
fi
[ "$FAIL" = "0" ] || exit 1
+536
View File
@@ -0,0 +1,536 @@
# Linux 部署与运维指南
本文覆盖服务端在 Linux 上的**一键安装**与日常运维(`classhelper` 命令)。
适用:Ubuntu 20.04+ / Debian 11+ / CentOS 7+ / Rocky Linux / AlmaLinux 8+(自动识别 apt / yum / dnf)。
不想看长文的话,最短路径是这两条命令:
```bash
sudo bash install.sh --package /path/to/classhelper-server-linux-x64-1.1.0.tar.gz
sudo classhelper status
```
---
## 1. 三种形态怎么选
| 形态 | 适合 | 命令 | 说明 |
| --- | --- | --- | --- |
| **直接安装(native)** | 有一台 Linux 服务器/Mini 主机,单机跑 | `install.sh` 选 1 | systemd 管理,自带 Node 运行时,SQLite 或 MySQL |
| **直接安装 + MySQL** | 多终端共享数据、已有 MySQL | `install.sh` 选 2 | 连接串写在配置里;库要先建好 |
| **Docker** | 机器上已有 Docker、想与其他服务隔离 | `install.sh` 选 3 | 用安装包里随带的 Dockerfile 构建镜像 + compose 起容器 |
> 只想先看看这台机器能不能装:`bash install.sh --check`(**不需要 root**,不改动任何东西)。
> Windows 机器用服务端安装包(`pnpm dist:server` 的产物),不需要本文。
---
## 2. 安装包从哪来
Linux 安装包命名固定为:
```
classhelper-server-linux-x64-<版本>.tar.gz ← install.sh / classhelper upgrade 都认这个名字
classhelper-server-linux-x64-<版本>.tar.gz.sha256 ← 旁边那份校验值
```
它发布在 [GitHub Releases](https://github.com/LoveChengke/ClassHelper/releases) 上。
**为什么 Linux 包要单独出一个**:`@libsql/linux-x64-gnu`、`@prisma/adapter-libsql` 这些依赖是平台相关的,
Windows 开发机上 `npm install` 出来的 `node_modules` 拷到 Linux 跑不起来,因此 Linux 包必须在 Linux 上构建。
仓库里的 [`.github/workflows/release-linux-server.yml`](../.github/workflows/release-linux-server.yml)
就是干这个的(拿 ubuntu runner 跑 `pnpm dist:server:linux`,再把产物挂到对应 Release 上):
1. 本地照惯例发 Windows 包的 Release(tag 形如 `v1.1.0`);
2. GitHub → Actions → 「发布 Linux 服务端安装包」→ Run workflow → 填 tag → 运行;
3. 跑完 Release 里会多出 Linux 包与更新后的 `SHA256SUMS-<版本>.txt`。
内网离线分发也可以:在能上网的机器上 `pnpm dist:server:linux`,把 tar.gz 拷进去,
用 `install.sh --package /path/to/xxx.tar.gz --sha256 <哈希>` 安装。
### 没有 Linux 机器时(交叉构建)
`pnpm dist:server:linux` 在非 Linux 上也**能跑**:脚本会用 npm 的 `--os=linux --cpu=x64`
按目标平台解析可选依赖,所以 `@libsql/linux-x64-gnu` 这些"按平台分发"的包会被正确装进来。
适合本地快速打一个包去验证安装与运维流程。已核对过的结论:
| 项 | 结论 |
| --- | --- |
| SQLite 驱动 | ✅ 包内是 `@libsql/linux-x64-gnu` + `linux-x64-musl`,**没有任何 win32 残留** |
| 服务端本体 | ✅ Node + libsql + express + socket.io 都是纯 JS 或已就位的 Linux 原生包 |
| 运维命令 | ✅ `status` / `doctor` / `password` / `backup` / `upgrade` / `rollback` 都不依赖平台差异 |
| Web 端「一键切换数据库」 | ⚠ **可能失败**:这条链路要调 prisma CLI 的 schema engine,CLI 在运行期按平台扫 `@prisma/engines/schema-engine-debian-openssl-3.0.x` 这类路径,而交叉包里只有宿主平台的 `schema-engine-windows.exe` |
所以交叉包**能装、能跑、能验收**,只是那一个 Web 端功能存疑 —— 它会在包内写入 `.cross-built` 标记,
`classhelper doctor` 会据此提示你(不会静默)。**正式发布一律用 GitHub Actions 那条路。**
```bash
# 开发机(Windows 也可以)
pnpm dist:server:linux
# → release-server/classhelper-server-linux-x64-<版本>.tar.gz(+ .sha256)
# 重跑很快:node scripts/dist-server.mjs --platform linux --reuse-deps(复用已装的 node_modules)
```
---
## 3. 一键安装
### 3.1 交互式(推荐第一次用)
```bash
sudo bash install.sh
```
TUI 会依次问:形态 → 安装目录 → 端口 → 数据库 → 初始管理员密码 → 是否要 Nginx 配置 / 放行防火墙。
每一问都有默认值,直接回车即可。
### 3.2 非交互(自动化 / 批量部署)
```bash
# 全部默认:/opt/classhelper、4000 端口、SQLite、内置 Node
sudo bash install.sh --yes --package ./classhelper-server-linux-x64-1.1.0.tar.gz
# 指定目录与端口,从 stdin 传初始管理员密码(不进 argv / shell history)
printf '%s\n' 'MyStrongPass!2026' | sudo bash install.sh --yes \
--dir /srv/classhelper --port 8080 --admin-password-stdin \
--package ./classhelper-server-linux-x64-1.1.0.tar.gz
# MySQL 形态
sudo bash install.sh --yes --database mysql --mysql-host 10.0.0.5 --mysql-db classhelper \
--mysql-user classhelper --mysql-password-stdin \
--package ./classhelper-server-linux-x64-1.1.0.tar.gz <<< 'MySQL密码'
```
完整参数见 `bash install.sh --help`。要点:
| 参数 | 作用 |
| --- | --- |
| `--package <url|file://路径>` | 安装包地址(默认从 GitHub Release 取最新版) |
| `--sha256 <哈希>` | 强制校验安装包哈希 |
| `--admin-password-stdin` | 从 stdin 读一行作为初始管理员密码 |
| `--node-source bundled|system|tarball` | 内置 Node / 系统 Node / 指定压缩包 |
| `--node-mirror <url>` | Node 下载镜像(默认 `https://npmmirror.com/mirrors/node`) |
| `--node-tarball <url|路径>` | 内网离线时直接用本地 Node 包 |
| `--with-nginx` / `--open-firewall` | 顺带生成反代配置 / 放行端口 |
| `--yes` | 全默认、不再交互 |
| `--check` | 只体检(无需 root) |
| `--force` | 覆盖已有配置;在无 systemd 的机器上只铺文件不装服务 |
**幂等性**:重复执行就是覆盖安装。已有的 `config.env`(含 `JWT_SECRET`)与 `data/` 一律保留,
用户不会被踢下线;端口与数据库形态也沿用旧配置,不会被改回默认值。
### 3.3 安装器做了什么
1. 识别发行版与包管理器,补齐 `curl / tar / gzip / ca-certificates`(只装缺的);
2. 创建系统用户与组 `classhelper`(`--system`,nologin);
3. 建目录、收权限(见下一节);
4. 下载安装包 → 校验 sha256 → 解压铺文件;
5. 下载 Node(默认走 npmmirror 镜像,从 `SHASUMS256.txt` 同时取版本号与哈希);
6. 生成 `/etc/classhelper/config.env`(随机 `JWT_SECRET`,权限 600);
7. 装 systemd 单元、`/usr/local/bin/classhelper`、`/etc/profile.d/classhelper.sh`、logrotate;
8. 启动服务并轮询 `/healthz`,通过后才算安装成功;
9. 全过程写 `/var/log/classhelper/install.log`。
### 3.4 Docker 形态
`install.sh` 选 3(或 `--mode docker`):用安装包里随带的 `Dockerfile` 直接构建镜像
(包的 `node_modules` 已经是 linux 的真实目录,**构建时不需要联网装依赖**,几十秒出镜像),
然后写一份 `/etc/classhelper/compose.yml` 拉起容器。
```bash
classhelper status # 走 docker compose ps / logs
classhelper restart # 重建容器
classhelper password admin # 通过 docker exec 在容器里执行同一份 admin-cli
classhelper backup # 容器内做一致性快照再取出来
```
Docker 形态与直接安装的差异:
| | 直接安装 | Docker |
| --- | --- | --- |
| 数据位置 | `<安装目录>/data` | Docker 卷 `classhelper-data` |
| 配置 | `/etc/classhelper/config.env`(systemd 注入) | 同一份文件(compose `env_file`) |
| 升级 / 回滚 | 替换程序文件后重启服务 | 同一套流程:替换构建上下文 → 重建镜像(`classhelper-server:local`)→ `compose up -d --force-recreate` |
| 恢复数据 | `classhelper backup restore <目录>` | 需手工 `docker cp` 回容器(命令里有提示) |
| `backup schedule` | 支持(systemd timer) | 用宿主机 cron 调 `classhelper backup --quiet` |
> Docker 形态的镜像用**稳定标签** `classhelper-server:local`(另打一个 `classhelper-server:<版本>` 便于追溯)。
> 版本号写在 compose 里的话,升级替换完程序文件后那个标签就过期了,`compose up` 会一直沿用旧镜像 ——
> 表现为"升级成功但行为没变"。`classhelper` 自己按 `VERSION` 决定要不要重建镜像。
---
## 4. 目录、权限与配置
```
/opt/classhelper/ 安装目录(--dir 可改)
├── server/ 后端程序(入口 server/dist/index.js)
│ ├── dist/ prisma/ 产物 + 迁移 SQL(首启动 AUTO_MIGRATE 自动执行)
│ ├── prisma.config.ts tsconfig.generate.json 数据库「一键切换」用
├── web/ Web 管理端(由后端托管)
├── node_modules/ 生产依赖(真实目录,非软链)
├── tools/admin-cli.mjs 离线改密 / 数据库快照工具
├── bin/classhelper 运维命令本体(/usr/local/bin/classhelper 软链到它)
├── runtime/node/ 内置 Node 运行时
├── systemd/ logrotate.d/ profile.d/ 模板(安装时拷到 /etc 下)
├── Dockerfile Docker 形态构建用
├── data/ 数据库 + Web 端自建快照(备份就是拷这里)
├── logs/ 预留
├── VERSION 当前版本
├── .installed.json 安装元数据(形态/版本/端口,classhelper 靠它决策)
└── .env → /etc/classhelper/config.env (软链,见下)
/etc/classhelper/ 目录 700,属主 classhelper
└── config.env 配置文件,**权限 600**,唯一真身
/var/log/classhelper/ 安装日志 install.log + 审计日志 audit.log
/var/backups/classhelper/ 备份 + 程序快照(回滚用)
```
### 4.1 为什么安装目录里的 `.env` 是软链
Web 端「数据库管理 → 一键切换数据库」在运行中改写的是 **`<安装目录>/.env`**
(`packages/server/src/modules/database/database.service.ts`),而 systemd 是通过
`EnvironmentFile=/etc/classhelper/config.env` 注入环境变量的。dotenv 不覆盖已存在的环境变量 →
如果这两处不是同一份文件,**切换看起来成功、重启后又连回旧库**。
所以安装器把 `<安装目录>/.env` 做成指向 `config.env` 的软链:两种读法落到同一个真身。
`classhelper doctor` 会专门检查这条软链,别手工删掉。
### 4.2 配置项
配置就是一份 `KEY=VALUE` 的 env 文件,systemd / dotenv / `source` 三种读法都兼容
(含空白或 `#` 的值请加双引号)。最常见的几项:
| KEY | 默认 | 说明 |
| --- | --- | --- |
| `PORT` / `HOST` | `4000` / `0.0.0.0` | 监听端口与地址 |
| `DATABASE_PROVIDER` | `sqlite` | `sqlite` 或 `mysql` |
| `DATABASE_URL` | `file:../data/classhelper.db` | SQLite 相对 `<安装目录>/server` 解析;MySQL 是连接串 |
| `JWT_SECRET` | 随机 | 登录令牌签名密钥。**换掉=所有用户重新登录**(`classhelper key rotate`) |
| `JWT_EXPIRES_IN` | `7d` | 令牌有效期 |
| `CORS_ORIGIN` | `*` | 走域名/反代时建议收敛成 `https://你的域名` |
| `TRUST_PROXY` | `1` | 前面有 Nginx 时保持 1,限流才按真实 IP 统计 |
| `AUTO_MIGRATE` | `true` | 空库首启动自动建表 + 建管理员 |
| `INITIAL_ADMIN_USERNAME` / `INITIAL_ADMIN_PASSWORD` | `admin` / `admin123` | **只在空库首次初始化时生效**,之后改密码用 `classhelper password` |
| `DEFAULT_CLASS_PASSWORD` / `DEFAULT_TEACHER_PASSWORD` | `123456` | 新建班级 / 重置教师时的初始密码 |
| `TERM_START_DATE` | 空 | 第 1 教学周的周一(`YYYY-MM-DD`),影响"当前周次" |
改配置的三种方式(都会先自动备份、改完问你是否重启):
```bash
sudo classhelper config show # 敏感值打码查看
sudo classhelper config get PORT
sudo classhelper config set CORS_ORIGIN https://class.example.com # 敏感项会改成交互输入
sudo classhelper config edit # 用 $EDITOR 直接编辑
sudo classhelper port 8080 # 改端口的快捷方式
```
> 手工改也可以(`vim /etc/classhelper/config.env`),但记得改完 `classhelper restart`,
> 并确认权限仍是 600。
---
## 5. `classhelper` 运维命令
安装后可直接使用(`/usr/local/bin/classhelper`)。除 `help` / `version` / `completion` 外都需要 root。
### 5.1 查看与诊断
```bash
classhelper status # 服务状态、版本、端口、数据库、各类路径
classhelper status --json # 同上,机器可读(接监控用)
classhelper doctor # 完整体检:权限 / Node / 服务单元 / 探针 / 数据库 / 磁盘 / 备份
classhelper logs -f # 实时日志(= journalctl -u classhelper -f)
classhelper logs -n 200 --since "1 hour ago"
classhelper logs --unit classhelper-backup # 看定时备份的日志
```
`doctor` 会把每一项标成 `✔` / `✘`,失败项后面直接跟修复建议,例如:
```
✘ 安装目录 .env 是指向配置真身的软链
✔ Node 运行时可用且 ≥20.19(v22.20.0)
✘ 最近 7 天内有备份(无)
建议依次处理:
· ln -sfn /etc/classhelper/config.env /opt/classhelper/.env(Web 端「一键切换数据库」依赖它)
· classhelper backup;长期可用 classhelper backup schedule daily
```
### 5.2 改密码
```bash
sudo classhelper password # 改 admin
sudo classhelper password teacher1 # 改指定教师
sudo classhelper password --list # 列出可登录账号与班级账号(含是否已设密码)
sudo classhelper password --class G101 # 改某个班的班级密码(学生端登录用)
```
安全约定(照要求逐条落实):
- 密码**交互输入、不回显**;不接受命令行传参,因此不会进 shell history、也不出现在 `ps` 里;
- 强度校验:≥8 位,小写/大写/数字/符号至少 3 类,不得与用户名相同,常见弱口令直接拒绝;
需二次确认,连续 3 次不合规即退出(密码不变);
- 改前把**原密码哈希**备份到 `/var/backups/classhelper/password-<时间戳>.json`(权限 600),
写入失败或写入后复核不通过会**自动回滚**原哈希;
- 全过程写审计日志,**审计里只有"谁对谁做了什么、结果如何",没有密码**;
- 自动化可以用管道传入(仍不进 history):
```bash
printf '%s\n%s\n' "$NEW_PW" "$NEW_PW" | sudo classhelper password admin
```
> 顺带说明:改密码不需要重启服务(登录时读库校验);已登录的会话仍有效,
> 要让所有会话立刻失效用 `classhelper key rotate`。
### 5.3 备份与恢复
```bash
sudo classhelper backup # 备份配置 + 数据库
sudo classhelper backup --note "升级前" --keep 7
sudo classhelper backup list
sudo classhelper backup restore 20261005-033000 # 用某个备份覆盖当前配置与数据(会先停服务)
sudo classhelper backup schedule daily # 每天 03:30 自动备份(systemd timer,保留 7 份)
sudo classhelper backup schedule off
```
- 备份落在 `/var/backups/classhelper/<时间戳>[-说明]/`:`config.env` + `classhelper.db` + `meta.json`,
目录 700、文件 600;
- SQLite 用 `VACUUM INTO` 做**一致性快照**(服务在跑也安全,比直接 `cp` 可靠);
- MySQL 用 `mysqldump --single-transaction`(密码经 `MYSQL_PWD` 传给子进程,不进 argv);
- `restore` 前会先自动备份现状,恢复对象是配置与数据(不是程序);
- 程序文件快照(回滚用)在 `/var/backups/classhelper/rollback/`,是另一类东西,`backup list` 会分开列。
### 5.4 升级与回滚
```bash
sudo classhelper upgrade --check # 只检查有没有新版本(查 GitHub Release)
sudo classhelper upgrade # 升到最新版
sudo classhelper upgrade --version 1.2.0 # 升到指定版本
sudo classhelper upgrade --url ./classhelper-server-linux-x64-1.0.1.tar.gz --sha256 <哈希> # 内网离线
sudo classhelper upgrade --url <包> --force # 强制重装同一版本
sudo classhelper rollback --list # 看有哪些程序快照
sudo classhelper rollback # 回滚到最近一份(会问一次确认)
```
`upgrade` 的完整链路(任一步失败都不改动程序文件):
```
解析目标版本 → 下载 → 校验 sha256 → 备份数据与配置 → 快照当前程序文件 →
停服 → 替换程序文件(mv 原子替换,data/ 配置/ 运行时原地不动)→ 起服 → 轮询 /healthz
↘ 失败:自动用刚才的快照回滚并重新起服,再告诉你失败原因
```
两点必须知道:
1. **升级不会回滚数据库结构**。如果新版执行过迁移,回滚程序前要确认旧版还能读新库,
必要时用 `classhelper backup restore` 连数据一起回退;
2. 替换程序文件用的是"改名 + 就位"而不是删除重写 —— 升级时正在运行的就是 `bin/classhelper` 自己,
必须先改名再放新文件,运行中的进程继续读旧 inode,否则会读到半个脚本。
### 5.5 服务与配置
```bash
sudo classhelper start | stop | restart | reload # reload 与 restart 同义(服务端不支持热重载)
sudo classhelper port # 看当前端口
sudo classhelper port 8080 # 改端口(顺带提示放行防火墙)
sudo classhelper config show [--reveal]
sudo classhelper config set KEY VALUE
sudo classhelper key rotate # 轮换 JWT_SECRET(所有用户需重新登录)
```
### 5.6 其它
```bash
classhelper version
classhelper help
source <(classhelper completion bash) # 补全(安装时已装到 /usr/share/bash-completion)
```
### 5.7 卸载
```bash
sudo classhelper uninstall
```
会依次问:保留配置?保留数据?保留备份?默认全部保留 —— 数据与配置会被**搬到**
`/var/backups/classhelper/uninstall-<时间戳>/`,然后才删除程序目录,不会悄悄丢数据。
```bash
sudo classhelper uninstall --yes # 不问,用默认(保留配置/数据/备份)
sudo classhelper uninstall --purge # 全删(含备份与数据),不可恢复
```
---
## 6. 环境变量文件
安装器会写 `/etc/profile.d/classhelper.sh`(内容见
[`deploy/profile.d/classhelper.sh`](../deploy/profile.d/classhelper.sh)):
```sh
export CLASSHELPER_HOME=/opt/classhelper
export CLASSHELPER_CONFIG=/etc/classhelper/config.env
export CLASSHELPER_LOG_DIR=/var/log/classhelper
export CLASSHELPER_BACKUP_DIR=/var/backups/classhelper
export PATH=$PATH:$CLASSHELPER_HOME/bin
```
新登录的 shell 自动生效;当前会话要手工 `source /etc/profile.d/classhelper.sh`。
`classhelper` 命令本身装在 `/usr/local/bin`(软链),所以**不登录也照样能用**。
---
## 7. 反向代理与 HTTPS(公网部署必做)
```bash
sudo bash install.sh --with-nginx # 或者安装后手工:
sudo cp deploy/nginx.conf /etc/nginx/conf.d/classhelper.conf
```
要点:
- `client_max_body_size 12m`(表格导入最大 8MB,base64 后约 11MB);
- Socket.IO 需要 `Upgrade` / `Connection` 头与较长的 `proxy_read_timeout`(模板里已配);
- 配置里保持 `TRUST_PROXY=1`,并把 `CORS_ORIGIN` 收敛成你的域名;
- 证书用 certbot 或你自己的证书,装好后 `nginx -t && nginx -s reload`。
---
## 8. 故障排查
| 现象 | 先查什么 |
| --- | --- |
| 服务起不来 | `classhelper doctor` → `classhelper logs -n 100`。常见:端口被占用、MySQL 连接串错、`data/` 权限 |
| 装完打不开页面 | `classhelper status` 看探针与监听地址;云服务器还要在**安全组**放行端口 |
| 改了配置没生效 | 是否重启过(`classhelper config set` 会问);`EnvironmentFile` 的值优先于文件里的同项 |
| Web 端切库后还是连旧库 | `classhelper doctor` 看 `.env` 软链是否被破坏(`ln -sfn /etc/classhelper/config.env <安装目录>/.env`) |
| 升级卡住/失败 | 失败会自动回滚;看 `classhelper logs -n 100`,确认磁盘余量 ≥1GB |
| `classhelper` 命令找不到 | `ls -l /usr/local/bin/classhelper`;被删了就重装或 `ln -sfn <安装目录>/bin/classhelper /usr/local/bin/classhelper` |
| 忘记管理员密码 | `sudo classhelper password admin`(直连数据库,不需要登录) |
| 学生端连不上 | 客户端「服务器地址」填 `http://IP:端口` 或域名;确认没有多余路径与斜杠 |
| CentOS 7 装完立刻退出 | glibc < 2.28,见下面的"已知限制" |
---
## 9. 已知限制
### CentOS 7 / glibc < 2.28
Node 官方的 linux-x64 二进制要求 **glibc ≥ 2.28**,而 CentOS 7 是 2.17 —— 直接装官方包会表现成
"装完服务立刻退出、日志里什么也没有"。安装器会自动检测 glibc,低于 2.28 时改用
[unofficial-builds](https://unofficial-builds.nodejs.org/) 的 **glibc-217** 构建(功能一致,只是编译基线更低)。
但即便这样,个别原生依赖仍可能不兼容,CentOS 7 支持属于**尽力而为**:
- CentOS 7 已于 2024-06 EOL,**新部署请用 Rocky Linux 9 / AlmaLinux 9 / Ubuntu 22.04+**;
- 若坚持用 CentOS 7,建议装完立刻跑一遍 `classhelper doctor` 与本文第 10 节的验收清单。
### 其它
- 直接安装形态要求 **systemd**(容器里没有 `/run/systemd/system` 时会明确拒绝;
容器场景请用 Docker 形态)。
- Docker 形态的数据恢复需要手工 `docker cp`(数据在容器卷里,宿主机上看不到那个文件);
`classhelper backup restore` 会给出具体命令。
- `classhelper reload` 等价于 restart(服务端没有 SIGHUP 处理)。
- 升级包只发 x64;arm64 需要自行构建(`node scripts/dist-server.mjs --platform linux` 跑在 arm64 机器上)。
---
## 10. 验收清单
下面这套在干净的 **Ubuntu 22.04** 与 **Rocky Linux 9** 上各跑一遍。
`deploy/verify-linux.sh` 会把第 3~8 步自动跑完并打印 `=== 结果:N/N 项通过 ===`。
### 10.0 准备
```bash
# 在开发机:做出 Linux 包(或在 Actions 里下载)
pnpm dist:server:linux
scp release-server/classhelper-server-linux-x64-*.tar.gz root@<服务器>:/tmp/
scp deploy/install.sh deploy/verify-linux.sh root@<服务器>:/tmp/
```
### 10.1 体检(不需要 root)
```bash
bash /tmp/install.sh --check
```
期望:系统/包管理器/glibc/docker/端口/磁盘逐项列出,末尾「体检通过」。
端口被占用、缺 curl、没有 systemd 都会在这里被点出来。
### 10.2 安装
```bash
sudo bash /tmp/install.sh --yes \
--package /tmp/classhelper-server-linux-x64-1.1.0.tar.gz \
--admin-password-stdin <<< 'Verify-Pass-2026!'
```
期望:末尾出现「安装完成」与「服务已就绪 ✅」,并打印管理端地址。
### 10.3 自动验收
```bash
sudo bash /tmp/verify-linux.sh --admin-password-stdin <<< 'Verify-Pass-2026!'
```
覆盖项:
| 分组 | 检查内容 |
| --- | --- |
| 安装结果 | 程序文件、`VERSION`、`.installed.json`、`config.env` 600、配置目录 700、`.env` 软链、内置 Node、`/usr/local/bin/classhelper`、安装/审计日志、profile.d 生效 |
| 服务 | systemd 单元、active、enabled、`/healthz` 200、`status --json` 合法且 healthy |
| 体检 | `classhelper doctor` 无待处理项、`help` / `completion` 可用 |
| API | 用初始密码登录拿 token、带 token 读 `/api/classes` 与 `/api/auth/me` |
| 改密 | 改密成功 → 新密码可登录 → **旧密码被拒** → 原哈希已备份且 600 → 审计有记录且**不含密码明文** → 弱密码被拒 → stdin 结束不卡死 → `restore-hash` 把原密码回滚回来 |
| 备份 | 备份目录/文件/权限、SQLite 快照是合法库文件、`backup list` |
| 配置 | `config get/show`、敏感值打码、读写往返 |
| key rotate | 密钥确实变了且 ≥32 位、服务仍可用、**旧 token 变 401**、重新登录成功 |
追加升级/回滚链路(会真的替换一次程序文件):
```bash
sudo bash /tmp/verify-linux.sh --full --package /tmp/classhelper-server-linux-x64-1.0.1.tar.gz \
--admin-password-stdin <<< 'Verify-Pass-2026!'
```
覆盖:升级成功 → 服务恢复 → 配置未被改动 → 产生程序快照 → **坏哈希被拒绝且服务不受影响** →
`rollback` 回到旧版且服务可用。
### 10.4 手工补验(自动化覆盖不到的)
```bash
# ① 浏览器打开 http://<IP>:4000/ ,用 admin 登录,改一次密码再登录
# ② 学生端客户端填 http://<IP>:4000 用班级码 G101/123456 登录,收到一条老师发的通知
# ③ 重跑安装器(幂等性):sudo bash /tmp/install.sh --yes --package <同一个包>
# 期望:配置与数据保留、JWT_SECRET 不变(已登录用户不被踢下线)
# ④ 卸载:sudo classhelper uninstall --yes
# 期望:服务停止、单元删除、/usr/local/bin/classhelper 消失、
# 数据与配置被搬到 /var/backups/classhelper/uninstall-*/
# ⑤ 重启机器后服务自动起来(systemctl is-enabled classhelper)
```
### 10.5 Rocky 9 的差异点
- 包管理器走 `dnf`,依赖包名与 apt 不同(`install.sh` 已按 `PKG` 分支处理);
- 默认没有 `curl` 之外的工具时会被补装,注意首次安装需要能访问 dnf 源;
- 防火墙默认是 `firewalld`:用 `--open-firewall` 或手工
`firewall-cmd --add-port=4000/tcp --permanent && firewall-cmd --reload`;
- SELinux(Enforcing):服务读写 `/opt/classhelper` 与 `/etc/classhelper` 一般不受影响,
若日志里出现 `Permission denied` 且路径正常,先 `ausearch -m avc -ts recent` 看是不是 SELinux,
可以用 `semanage fcontext` 加规则,或临时 `setenforce 0` 验证判断。
---
## 11. 安全清单
- [ ] 改掉默认管理员密码:`classhelper password admin`(**公网部署第一件事**)
- [ ] 公网服务前面加 Nginx + HTTPS,`CORS_ORIGIN` 收敛到具体域名
- [ ] 定期备份:`classhelper backup schedule daily`,并确认备份能恢复(`backup restore` 演练一次)
- [ ] 配置与备份权限:`config.env` 600、`/etc/classhelper` 700、备份目录 700
- [ ] `classhelper doctor` 无待处理项;关注"最近 7 天内有备份"
- [ ] 审计日志(`/var/log/classhelper/audit.log`)随日志轮转保留,必要时接集中日志
- [ ] 只在需要时使用 `--purge`;卸载默认保留数据与备份
- [ ] 升级包一律校验 sha256(`upgrade` 内网分发时也要带 `--sha256`)
+53 -9
View File
@@ -19,28 +19,62 @@ MySQL 兼容方式设计,可平滑切换到云端 MySQL / MariaDB 统一存储
| 唯一约束仅使用 `@@unique` / `@unique` | SQLite 与 MySQL 语义一致 | | 唯一约束仅使用 `@@unique` / `@unique` | SQLite 与 MySQL 语义一致 |
| 级联删除使用 Prisma 的 `onDelete` | 由 Prisma 生成对应外键动作 | | 级联删除使用 Prisma 的 `onDelete` | 由 Prisma 生成对应外键动作 |
## 切换步骤 ## 切换到 MySQL
### 1. 修改 provider ### 方式一:Web 管理端「数据库管理 → 一键切换」(推荐,v1.0.0 新增)
管理员在 Web 管理端打开 **数据库管理** 页(`/database`,仅 ADMIN 可见),在「一键切换数据库」卡片里:
1. 选目标类型(SQLite ⇄ MySQL)并填**空库**连接串(有表的库会被拒绝,防误覆盖);
2. 输入「确认迁移」→ 点「开始迁移」。
界面会自动依次执行(带步骤进度条):
1. **备份当前数据库**(gzip JSON 快照存 `<数据目录>/backups/`,失败可回滚);
2. 导出当前数据为快照;
3. 测试目标库连接;
4. 检查目标库为空;
5. 改写 `schema.prisma` 的 provider;
6. 子进程 `prisma generate` 生成新方言的 Prisma 客户端;
7. (打包形态)把生成的 `.ts` 客户端编译进 `dist/generated`;
8. 子进程 `prisma db push` 在目标库建表;
9. 子进程 `dist/tools/apply-snapshot.js` 把快照写入目标库;
10. 全部成功后改写 `.env` 的 `DATABASE_PROVIDER` / `DATABASE_URL`。
**完成后必须重启服务端**(安装版运行 `restart.cmd`,开发模式重跑 `pnpm dev:server`)才会连接新库。
中途任一步失败会**回滚 `schema.prisma`**,`.env` 不被改写 —— 现有数据库与配置保持可用。
> 同一页还提供:连接状态检测(版本 / 体积 / 各表行数)、连接测试、手动与**定时备份**、
> 备份恢复、快照导出导入、SQLite 数据库文件下载。备份与导入导出共用同一种 JSON 快照格式,
> 因此**任意备份都能恢复回任意一种受支持的数据库**。
>
> 只支持 SQLite 与 MySQL 两种主库:Redis 等键值库不是 Prisma 支持的主数据库(无法建表/迁移),
> 接口层直接拒绝。
### 方式二:命令行手工切换
#### 1. 修改 provider
```bash ```bash
# 自动把 prisma/schema.prisma 的 provider 改成 mysql # 自动把 prisma/schema.prisma 的 provider 改成 mysql
node scripts/use-database.mjs mysql node scripts/use-database.mjs mysql
``` ```
### 2. 安装 MySQL 驱动适配器 #### 2. MySQL 驱动适配器(自 v1.0.0 起已随包内置)
Prisma 7 要求所有数据库都通过 driver adapter 接入,MySQL 对应 `@prisma/adapter-mariadb` Prisma 7 要求所有数据库都通过 driver adapter 接入,MySQL 对应 `@prisma/adapter-mariadb`
(该适配器基于 `mariadb` 驱动,兼容 MySQL 8)。 (该适配器基于 `mariadb` 驱动,兼容 MySQL 8)。**它已在 `packages/server/package.json` 的
依赖里**(数据库管理模块的连接测试/迁移需要),因此无需再手动安装:
```bash ```bash
# 仅当从旧版本升级、依赖里还没有时才需要
pnpm --filter @classhelper/server add @prisma/adapter-mariadb pnpm --filter @classhelper/server add @prisma/adapter-mariadb
``` ```
`packages/server/src/lib/db.ts` 已经内置分支:当 `DATABASE_PROVIDER=mysql` 时会动态加载该适配器, `packages/server/src/lib/db.ts` 内置分支:当 `DATABASE_PROVIDER=mysql` 时会动态加载该适配器,
因此只需要安装依赖 + 配置环境变量,服务端代码无需改动。 服务端代码无需改动。
### 3. 配置环境变量 #### 3. 配置环境变量
编辑 `packages/server/.env`: 编辑 `packages/server/.env`:
@@ -52,7 +86,7 @@ DATABASE_URL="mysql://classhelper:your-password@127.0.0.1:3306/classhelper"
> 云端部署时把 `127.0.0.1` 换成云数据库内网/公网地址; > 云端部署时把 `127.0.0.1` 换成云数据库内网/公网地址;
> 生产环境请同时修改 `JWT_SECRET` 与 `CORS_ORIGIN`。 > 生产环境请同时修改 `JWT_SECRET` 与 `CORS_ORIGIN`。
### 4. 重建迁移并生成客户端 #### 4. 重建迁移并生成客户端
SQLite 与 MySQL 的 DDL 方言不同,**必须重新生成迁移文件**: SQLite 与 MySQL 的 DDL 方言不同,**必须重新生成迁移文件**:
@@ -71,7 +105,11 @@ pnpm db:seed
pnpm --filter @classhelper/server exec prisma migrate dev --create-only --name init_mysql pnpm --filter @classhelper/server exec prisma migrate dev --create-only --name init_mysql
``` ```
### 5. 回到 SQLite > 只搬数据、不要演示数据时,用界面的「下载快照 / 导入快照」更省事:
> 旧库导出 JSON → 切库建表 → 新库导入,一份快照也可用 CLI 迁移:
> `node server/dist/tools/apply-snapshot.js --provider mysql --url "mysql://..." --file snapshot.json`
#### 5. 回到 SQLite
```bash ```bash
node scripts/use-database.mjs sqlite node scripts/use-database.mjs sqlite
@@ -80,6 +118,8 @@ rm -rf packages/server/prisma/migrations # 若之前已切换成 MySQL 迁移
pnpm db:migrate pnpm db:migrate
``` ```
> 用界面「一键切换」回 SQLite 时,目标库同样必须是空文件:删除旧 `.db` 或指定一个新路径。
## 生产部署注意事项 ## 生产部署注意事项
1. **连接池**:Prisma 7 的 driver adapter 使用底层驱动(`mariadb`)的连接池设置, 1. **连接池**:Prisma 7 的 driver adapter 使用底层驱动(`mariadb`)的连接池设置,
@@ -88,3 +128,7 @@ pnpm db:migrate
三端展示时再按本地时区格式化(前端使用 `@classhelper/shared` 的 `formatDate`)。 三端展示时再按本地时区格式化(前端使用 `@classhelper/shared` 的 `formatDate`)。
3. **迁移部署**:CI/CD 中使用 `prisma migrate deploy`(对应 `pnpm db:deploy`)而不是 `migrate dev`。 3. **迁移部署**:CI/CD 中使用 `prisma migrate deploy`(对应 `pnpm db:deploy`)而不是 `migrate dev`。
4. **备份**:切换云数据库后,`packages/server/prisma/dev.db` 不再被使用,可从 `.gitignore` 之外移除。 4. **备份**:切换云数据库后,`packages/server/prisma/dev.db` 不再被使用,可从 `.gitignore` 之外移除。
界面「定时备份」把快照写进 `<数据目录>/backups/`(MySQL 模式下即安装根 `data/backups/`),
**服务端进程不运行时不会补跑**;关键环境建议同时用数据库自带的备份策略。
5. **安装包体积**:切换链路需要随包内置 `prisma` CLI 与 `typescript` 编译器(Prisma 7 生成器产出
`.ts`,切换后需在目标机编译进 `dist/generated`),服务端安装包因此约 34MB → 71MB。
+107 -109
View File
@@ -6,7 +6,7 @@
| --------------------- | -------------------------------------------- | -------------------------------------------------------- | -------------------------------------- | | --------------------- | -------------------------------------------- | -------------------------------------------------------- | -------------------------------------- |
| **A. Windows 安装包** | 学校机房、教师办公电脑(单机即完整系统) | `release-server/班级小助手服务端-<版本>-x64-setup.exe` | ✅ 已完整实测(静默安装/启停/卸载/UI) | | **A. Windows 安装包** | 学校机房、教师办公电脑(单机即完整系统) | `release-server/班级小助手服务端-<版本>-x64-setup.exe` | ✅ 已完整实测(静默安装/启停/卸载/UI) |
| **B. Docker + MySQL** | 云服务器、多终端共享一套数据(推荐长期方案) | `deploy/Dockerfile` + `deploy/docker-compose.yml` | ⚠️ 文件已提供,本机无 Docker 未实测 | | **B. Docker + MySQL** | 云服务器、多终端共享一套数据(推荐长期方案) | `deploy/Dockerfile` + `deploy/docker-compose.yml` | ⚠️ 文件已提供,本机无 Docker 未实测 |
| **C. Linux 原生部署** | 已有 Linux 服务器(systemd + SQLite) | `deploy/install-linux.sh` + `deploy/classhelper.service` | ⚠️ 脚本已提供,本机无 Linux 未实测 | | **C. Linux 原生部署** | 已有 Linux 服务器(systemd,SQLite 或 MySQL) | [`deploy/install.sh`](../deploy/install.sh) + `classhelper` 运维命令 | ⚠️ 本机无 Linux,实机验收见 [linux-deploy.md](linux-deploy.md) §10 |
| **D. 手动部署** | 已有 Node 环境的服务器、需要自定义 | `pnpm dist:server` 的免安装目录 | ✅ 免安装目录已实测(163 项端到端) | | **D. 手动部署** | 已有 Node 环境的服务器、需要自定义 | `pnpm dist:server` 的免安装目录 | ✅ 免安装目录已实测(163 项端到端) |
--- ---
@@ -25,7 +25,7 @@ pnpm dist:server -- --reuse-deps # 迭代打包:复用已安装依赖,跳
| 路径 | 说明 | | 路径 | 说明 |
| ----------------------------------------------------- | ----------------------------------------------- | | ----------------------------------------------------- | ----------------------------------------------- |
| `release-server/classhelper-server/` | 免安装目录,可直接拷到任意 Windows x64 机器运行 | | `release-server/classhelper-server/` | 免安装目录,可直接拷到任意 Windows x64 机器运行 |
| `release-server/班级小助手服务端-0.1.0-x64-setup.exe` | 安装程序(约 34 MB,NSIS) | | `release-server/班级小助手服务端-1.1.0-x64-setup.exe` | 安装程序(约 34 MB,NSIS) |
打包内容:内置 **Node 运行时**(目标机无需安装 Node.js)、后端产物、Web 管理端产物、 打包内容:内置 **Node 运行时**(目标机无需安装 Node.js)、后端产物、Web 管理端产物、
生产依赖(真实目录,非软链)、迁移 SQL、`.env`(随机 JWT 密钥)、启停脚本。 生产依赖(真实目录,非软链)、迁移 SQL、`.env`(随机 JWT 密钥)、启停脚本。
@@ -35,7 +35,7 @@ pnpm dist:server -- --reuse-deps # 迭代打包:复用已安装依赖,跳
双击安装程序即可,**无需管理员权限**(当前用户级安装): 双击安装程序即可,**无需管理员权限**(当前用户级安装):
- 安装目录:`%LOCALAPPDATA%\Programs\ClassHelperServer` - 安装目录:`%LOCALAPPDATA%\Programs\ClassHelperServer`
- 静默安装:`"班级小助手服务端-0.1.0-x64-setup.exe" /S` - 静默安装:`"班级小助手服务端-1.1.0-x64-setup.exe" /S`
- 开始菜单:启动服务 / 停止服务 / 重启服务 / 打开管理端 / 使用说明 / 卸载 - 开始菜单:启动服务 / 停止服务 / 重启服务 / 打开管理端 / 使用说明 / 卸载
- 桌面:`班级小助手服务端.lnk`(打开管理端) - 桌面:`班级小助手服务端.lnk`(打开管理端)
- 自动加入当前用户开机自启(`HKCU\...\CurrentVersion\Run`) - 自动加入当前用户开机自启(`HKCU\...\CurrentVersion\Run`)
@@ -125,110 +125,121 @@ docker compose -f deploy/docker-compose.yml --env-file deploy/.env up -d --build
- 反向代理上启用 HTTPS:见 `deploy/nginx.conf`,并在服务端环境变量中设置 - 反向代理上启用 HTTPS:见 `deploy/nginx.conf`,并在服务端环境变量中设置
`TRUST_PROXY=1`、`CORS_ORIGIN=https://你的域名`。 `TRUST_PROXY=1`、`CORS_ORIGIN=https://你的域名`。
### 2.1 单容器变体(SQLite,推荐给内存小的机器 / 与别的服务共用一台机器)
`deploy/docker-compose.sqlite.yml` 只跑**服务端一个容器**,不额外起 MySQL:数据落在 Docker 卷
`classhelper-data` 的 `/app/data/classhelper.db`,首次启动由 `AUTO_MIGRATE=true` 自动建表并创建管理员
(`packages/server/src/lib/db-bootstrap.ts` 的"空数据卷"分支)。
```bash
cp deploy/.env.sqlite.example deploy/.env.sqlite # 填 JWT_SECRET、管理员密码、端口
docker compose -f deploy/docker-compose.sqlite.yml --env-file deploy/.env.sqlite up -d --build
```
适用场景与注意点:
- 机器内存紧张(比如 2G 小机器上还跑着别的服务)时,比 MySQL 变体少一个数据库进程;
- 端口用 `SERVER_PORT` 指定,**别抢占 80/443**(那通常是同机反代占用的);
- 生产自检会拒绝 `dev.db` 与过短的 `JWT_SECRET`,因此 `DATABASE_URL` 必须是绝对路径且不含 `dev.db`;
- 备份就是整个卷:`docker run --rm -v classhelper-sqlite_classhelper-data:/data -v "$PWD":/backup alpine tar czf /backup/classhelper-db.tar.gz -C /data .`
> `deploy/Dockerfile` 的构建阶段会先跑 `pnpm --filter @classhelper/server run db:generate`:
> 生成产物 `packages/server/src/generated/prisma` 是 gitignored 的,而 `--ignore-scripts` 跳过了
> postinstall,少了这一步 `tsc` 会直接编译失败。
--- ---
## 三、Linux 原生部署(形态 C,systemd + SQLite) ## 三、Linux 部署(形态 C,推荐一键安装器)
适用:Ubuntu / Debian / CentOS / Rocky 等有 systemd 的服务器,单机跑一套(SQLite), 适用:Ubuntu 20.04+ / Debian 11+ / CentOS 7+ / Rocky / AlmaLinux,任何有 systemd 的服务器
用 Nginx 挂 HTTPS 给校内网/公网访问。 (容器环境用下面的 Docker 形态)。**完整指南见 [linux-deploy.md](linux-deploy.md)**,这里是速查。
### 3.1 一键脚本(推荐) ### 3.1 一键安装(推荐)
在**仓库根目录**先构建,然后执行脚本(需要 root): Linux 包由 GitHub Actions 在 ubuntu runner 上构建(平台相关的依赖只能在 Linux 上装),
产物挂在 Release 上;也可以本地 `pnpm dist:server:linux` 后把 tar.gz 拷到服务器。
安装器脚本两个文件都在仓库的 `deploy/` 下:
```bash ```bash
# 1) 构建(Node ≥ 20.19,推荐 22 LTS;目标机没有 pnpm 时可在别的机器上构建后拷仓库过来) # 开发机:做出 Linux 包并连同脚本一起拷到服务器
corepack enable && corepack prepare pnpm@11.8.0 --activate pnpm dist:server:linux
pnpm install scp release-server/classhelper-server-linux-x64-*.tar.gz deploy/install.sh deploy/verify-linux.sh \
pnpm build:shared root@<服务器>:/tmp/
pnpm --filter @classhelper/server build
pnpm --filter @classhelper/web-admin build
# 2) 安装成 systemd 服务 # 服务器上
sudo bash deploy/install-linux.sh # 默认端口 4000、目录 /opt/classhelper bash /tmp/install.sh --check # 只体检(不需要 root,不改动系统)
# 常用变体: sudo bash /tmp/install.sh # 交互式:选形态 → 选目录 → 选库 → 设初始管理员密码
# bash deploy/install-linux.sh --check # 只体检(不需要 root):校验构建产物/Node/端口探针
# sudo bash deploy/install-linux.sh --port 8080
# sudo bash deploy/install-linux.sh --dir /srv/classhelper
# sudo bash deploy/install-linux.sh --no-service # 只铺文件,自己托管进程
# sudo bash deploy/install-linux.sh --uninstall # 停服务并移除 unit(保留 data 与 .env)
``` ```
> 建议先跑一次 `--check`:它只读地校验"构建产物齐不齐、Node 版本够不够、目标端口上有没有旧实例", 非交互(批量部署 / 验收用):
> 不需要 root,也不会改任何东西。输出示例见 `deploy/install-linux.sh` 头部注释。
脚本做的事:建系统用户 `classhelper` → 把后端产物、`prisma/migrations`、Web 管理端拷到
`/opt/classhelper` → `npm install --omit=dev`(清单就是 `deploy/package.runtime.json`,与
容器运行时同一份)→ 生成 `.env`(随机 `JWT_SECRET`、`AUTO_MIGRATE=true`)→ 装 systemd unit →
`enable --now` → 轮询 `/healthz` 就绪后打印地址与初始管理员。
安装后的目录(与已验证的 Windows 免安装目录同构,因此 `.env` 里的相对路径语义一致):
```
/opt/classhelper/
├── .env 全部配置(权限 600)
├── server/dist 后端程序(入口 index.js)
├── server/prisma 迁移 SQL(首启动自动执行)
├── web/ Web 管理端(后端托管,单端口)
├── node_modules/ 仅生产依赖
├── data/ classhelper.db + server.pid(备份只复制这里)
└── logs/
```
首次启动会自动建表并创建管理员 `admin / admin123`(**登录后立刻改密码**)。
### 3.2 手动部署(不想用脚本 / 没有 systemd)
等价的手工步骤,便于排查:
```bash ```bash
sudo useradd --system --shell /usr/sbin/nologin classhelper printf '%s\n' 'StrongPass!2026' | sudo bash /tmp/install.sh --yes \
sudo mkdir -p /opt/classhelper/{server,web,data,logs} --dir /srv/classhelper --port 8080 --admin-password-stdin \
--package /tmp/classhelper-server-linux-x64-1.1.0.tar.gz
```
# 程序产物 安装器做的事:识别发行版与包管理器补依赖 → 建系统用户 `classhelper` → 下载包并校验 sha256 →
sudo cp -R packages/server/dist /opt/classhelper/server/dist 铺文件(`server/` `web/` `node_modules/` `tools/` `bin/`)→ 下载内置 Node 运行时 →
sudo cp -R packages/server/prisma /opt/classhelper/server/prisma 写 `/etc/classhelper/config.env`(随机 `JWT_SECRET`,权限 600)→ 装 systemd 单元与
sudo cp -R packages/web-admin/dist /opt/classhelper/web `/usr/local/bin/classhelper` → 启动并轮询 `/healthz` 通过为止。全过程写
sudo cp deploy/package.runtime.json /opt/classhelper/package.json `/var/log/classhelper/install.log`。
# 生产依赖 + 工作区共享包 重跑就是**覆盖安装**:`config.env`(含密钥)与 `data/` 保留,已登录用户不会被踢下线。
cd /opt/classhelper && sudo npm install --omit=dev --no-audit --no-fund
sudo mkdir -p /opt/classhelper/node_modules/@classhelper/shared
sudo cp -R packages/shared/dist /opt/classhelper/node_modules/@classhelper/shared/dist
sudo cp packages/shared/package.json /opt/classhelper/node_modules/@classhelper/shared/package.json
# 配置(参考脚本生成的 .env,务必自己生成 JWT_SECRET) ### 3.2 安装后的布局与运维
sudo tee /opt/classhelper/.env >/dev/null <<'EOF'
NODE_ENV=production
HOST=0.0.0.0
PORT=4000
DATABASE_PROVIDER=sqlite
DATABASE_URL="file:../data/classhelper.db"
AUTO_MIGRATE=true
JWT_SECRET=换成 openssl rand -hex 48 的输出
JWT_EXPIRES_IN=7d
CORS_ORIGIN=https://class.example.com
TRUST_PROXY=1
RATE_LIMIT_ENABLED=true
STARTUP_DB_CHECK=true
PID_FILE=../data/server.pid
LOG_LEVEL=info
EOF
sudo chown -R classhelper:classhelper /opt/classhelper/{data,logs,node_modules} /opt/classhelper/.env ```
sudo chmod 600 /opt/classhelper/.env /opt/classhelper/ 程序、node_modules、内置 Node、data/、tools/、bin/
/etc/classhelper/config.env 唯一配置真身(600);安装目录里的 .env 是指向它的软链
/var/log/classhelper/ install.log + audit.log
/var/backups/classhelper/ 备份与程序快照(回滚用)
```
# systemd > 为什么安装目录的 `.env` 是软链:Web 端「数据库管理 → 一键切换」改写的是 `<安装目录>/.env`,
sudo sed -e 's#__NODE__#/usr/bin/node#' -e 's#__DIR__#/opt/classhelper#' -e 's#__USER__#classhelper#' \ > 而 systemd 用 `EnvironmentFile=` 注入同一份配置;两处不是同一个文件时,切换会"看起来成功、
deploy/classhelper.service | sudo tee /etc/systemd/system/classhelper.service > 重启后又连回旧库"。软链把两者收成一份真身(`classhelper doctor` 会检查它)。
日常运维全部走 `classhelper`(`classhelper help` 看全部):
| 事项 | 命令 |
| ------ | --------------------------------------------------------------------------------------- |
| 状态 | `classhelper status [--json]` |
| 体检 | `classhelper doctor`(权限 / Node / 服务单元 / 探针 / 数据库 / 磁盘 / 备份) |
| 改密码 | `classhelper password [用户名]`(交互输入、不回显、不进 shell history) |
| 备份 | `classhelper backup`;每日自动:`classhelper backup schedule daily` |
| 升级 | `classhelper upgrade [--check]`(下载 + 校验 sha256 + 备份 + 替换 + 探针,失败自动回滚) |
| 回滚 | `classhelper rollback [--list]` |
| 日志 | `classhelper logs -f` |
| 改配置 | `classhelper config set KEY VALUE` / `config show` / `port 8080` |
| 换密钥 | `classhelper key rotate`(所有用户需重新登录) |
| 卸载 | `classhelper uninstall`(默认保留配置、数据与备份) |
| 服务 | `classhelper start|stop|restart|reload` |
### 3.3 手动部署(不想用安装器 / 没有 systemd)
没有 systemd 的容器里可以用安装器的"只铺文件"模式,再自己托管进程:
```bash
sudo bash /tmp/install.sh --yes --force --package /tmp/classhelper-server-linux-x64-1.1.0.tar.gz
sudo -u classhelper /opt/classhelper/runtime/node/bin/node /opt/classhelper/server/dist/index.js
```
完全手工也可以(等价步骤,便于排查):解包后把 `server/` `web/` `node_modules/` `tools/` 铺到安装目录,
配置写到 `/etc/classhelper/config.env`(`JWT_SECRET` 用 `openssl rand -hex 48`),再用
`deploy/classhelper.service` 模板生成单元 —— 注意模板有 5 个占位符
(`__NODE__` `__DIR__` `__USER__` `__CONFIG__` `__CONFIGDIR__`):
```bash
sudo sed -e "s#__NODE__#/opt/classhelper/runtime/node/bin/node#" \
-e "s#__DIR__#/opt/classhelper#" -e "s#__USER__#classhelper#" \
-e "s#__CONFIG__#/etc/classhelper/config.env#" -e "s#__CONFIGDIR__#/etc/classhelper#" \
deploy/classhelper.service > /tmp/classhelper.service
sudo install -m 644 /tmp/classhelper.service /etc/systemd/system/classhelper.service
sudo systemctl daemon-reload && sudo systemctl enable --now classhelper sudo systemctl daemon-reload && sudo systemctl enable --now classhelper
systemctl status classhelper --no-pager
``` ```
也可以用 PM2 之类托管(`pm2 start /opt/classhelper/server/dist/index.js --name classhelper`), ### 3.4 Nginx + HTTPS
但 systemd 更省心:`Restart=always`、日志进 journald、开机自启一次配好。
### 3.3 Nginx + HTTPS
```bash ```bash
sudo cp deploy/nginx.conf /etc/nginx/conf.d/classhelper.conf sudo cp deploy/nginx.conf /etc/nginx/conf.d/classhelper.conf
@@ -237,7 +248,7 @@ sudo nginx -t && sudo systemctl reload nginx
``` ```
`deploy/nginx.conf` 已经处理了最容易踩的两点:`/socket.io/` 的 WebSocket 升级头, `deploy/nginx.conf` 已经处理了最容易踩的两点:`/socket.io/` 的 WebSocket 升级头,
以及 `X-Forwarded-For/X-Forwarded-Proto` 透传(配合 `.env` 里 `TRUST_PROXY=1`,限流才会按真实 IP 统计)。 以及 `X-Forwarded-For/X-Forwarded-Proto` 透传(配合配置里的 `TRUST_PROXY=1`,限流才会按真实 IP 统计)。
用 certbot 签证书: 用 certbot 签证书:
```bash ```bash
@@ -245,31 +256,19 @@ sudo apt install -y certbot python3-certbot-nginx
sudo certbot --nginx -d class.example.com sudo certbot --nginx -d class.example.com
``` ```
### 3.4 升级 / 备份 / 排障 ### 3.5 验收
升级(不会动 `.env`,JWT 密钥不变,学生端不用重新登录):
```bash ```bash
git pull && pnpm install sudo bash /tmp/verify-linux.sh --admin-password-stdin <<< 'StrongPass!2026'
pnpm build:shared && pnpm --filter @classhelper/server build && pnpm --filter @classhelper/web-admin build # 追加升级 / 回滚链路(会真的替换一次程序文件):
sudo bash deploy/install-linux.sh # 覆盖程序文件 + 自动补迁移(AUTO_MIGRATE) sudo bash /tmp/verify-linux.sh --full --package /tmp/classhelper-server-linux-x64-1.0.1.tar.gz \
journalctl -u classhelper -n 30 --no-pager --admin-password-stdin <<< 'StrongPass!2026'
``` ```
| 事项 | 命令 | 覆盖安装结果、服务探针、API 登录、改密(含审计与回滚)、备份、配置读写、key rotate、
| -------- | ---------------------------------------------------------------------------------------------------------- | 升级与回滚整条链路,末尾打印 `=== 结果:N/N 项通过 ===`。逐条清单见
| 备份 | `systemctl stop classhelper && cp -a /opt/classhelper/data /root/classhelper-data-$(date +%F)`(然后启动) | [linux-deploy.md](linux-deploy.md) 第 10 节。
| 恢复 | 停服务 → 用备份覆盖 `data/` → 启动 |
| 看日志 | `journalctl -u classhelper -f` |
| 重启 | `systemctl restart classhelper`(改 `.env` 后必须重启) |
| 探针 | `curl -s localhost:4000/healthz` / `/readyz`(就绪 200,数据库不可用 503) |
| 换端口 | 改 `.env` 的 `PORT` → 重启;同时改 Nginx 的 `upstream` |
| 换数据库 | 见 `docs/mysql.md`:切 provider + 装 `@prisma/adapter-mariadb` + `npx prisma migrate deploy` |
> 注意:本机(开发环境)是 Windows 且无 Docker/WSL 发行版,因此 **3.1 的脚本没有在 Linux 实机跑过**。
> 它复用的两套东西都已验证:Windows 免安装目录(同样的目录结构、`.env` 相对路径与
> `AUTO_MIGRATE` 首启动行为)和 `deploy/Dockerfile` 的 runtime 阶段(同样的依赖清单与产物布局)。
> 首次在服务器上执行后请按 3.4 的探针 + Web 登录 + `pnpm verify:e2e`(把 `VERIFY_BASE_URL` 指向服务器)确认。
--- ---
@@ -315,7 +314,6 @@ start.cmd :: Windows
| `PID_FILE` | — | PID 文件路径(安装包启停脚本依赖),相对 `server` 根 | | `PID_FILE` | — | PID 文件路径(安装包启停脚本依赖),相对 `server` 根 |
| `WEB_DIST_DIR` | 自动探测 | Web 管理端产物目录(`../web-admin/dist` 或 `./web`) | | `WEB_DIST_DIR` | 自动探测 | Web 管理端产物目录(`../web-admin/dist` 或 `./web`) |
| `LOG_LEVEL` | `info` | `debug` / `info` / `warn` / `error` | | `LOG_LEVEL` | `info` | `debug` / `info` / `warn` / `error` |
| `DEFAULT_STUDENT_PASSWORD` | `123456` | 新增/重置学生账号的默认密码 |
| `DEFAULT_CLASS_PASSWORD` | `123456` | 新建班级时班级账号(学生端登录)的默认密码 | | `DEFAULT_CLASS_PASSWORD` | `123456` | 新建班级时班级账号(学生端登录)的默认密码 |
| `DEFAULT_TEACHER_PASSWORD` | `123456` | 新增/重置教师账号的默认密码(管理员录入教师用) | | `DEFAULT_TEACHER_PASSWORD` | `123456` | 新增/重置教师账号的默认密码(管理员录入教师用) |
| `TERM_START_DATE` | — | 第 1 教学周的周一,用于"当前周次"与课表默认视图 | | `TERM_START_DATE` | — | 第 1 教学周的周一,用于"当前周次"与课表默认视图 |
+3 -1
View File
@@ -1,6 +1,6 @@
{ {
"name": "class-helper", "name": "class-helper",
"version": "0.1.0", "version": "1.1.0",
"private": true, "private": true,
"description": "班级小助手 - 班级信息管理系统(Web 管理端 + 后端服务 + 桌面客户端)", "description": "班级小助手 - 班级信息管理系统(Web 管理端 + 后端服务 + 桌面客户端)",
"packageManager": "pnpm@11.8.0", "packageManager": "pnpm@11.8.0",
@@ -16,6 +16,7 @@
"build": "pnpm build:shared && pnpm --filter @classhelper/server build && pnpm --filter @classhelper/web-admin build && pnpm --filter @classhelper/desktop-client build", "build": "pnpm build:shared && pnpm --filter @classhelper/server build && pnpm --filter @classhelper/web-admin build && pnpm --filter @classhelper/desktop-client build",
"build:desktop": "pnpm build:shared && pnpm --filter @classhelper/desktop-client build", "build:desktop": "pnpm build:shared && pnpm --filter @classhelper/desktop-client build",
"build:classisland-plugin": "node packages/classisland-plugin/scripts/build.mjs", "build:classisland-plugin": "node packages/classisland-plugin/scripts/build.mjs",
"check:icons": "node scripts/check-icons.mjs",
"typecheck": "pnpm build:shared && pnpm -r --no-bail typecheck", "typecheck": "pnpm build:shared && pnpm -r --no-bail typecheck",
"lint": "eslint .", "lint": "eslint .",
"lint:fix": "eslint . --fix", "lint:fix": "eslint . --fix",
@@ -38,6 +39,7 @@
"dist:win": "pnpm --filter @classhelper/desktop-client dist:win", "dist:win": "pnpm --filter @classhelper/desktop-client dist:win",
"dist:dir": "pnpm --filter @classhelper/desktop-client dist:dir", "dist:dir": "pnpm --filter @classhelper/desktop-client dist:dir",
"dist:server": "pnpm build:shared && pnpm --filter @classhelper/server build && pnpm --filter @classhelper/web-admin build && node scripts/dist-server.mjs", "dist:server": "pnpm build:shared && pnpm --filter @classhelper/server build && pnpm --filter @classhelper/web-admin build && node scripts/dist-server.mjs",
"dist:server:linux": "pnpm build:shared && pnpm --filter @classhelper/server build && pnpm --filter @classhelper/web-admin build && node scripts/dist-server.mjs --platform linux",
"dist:classisland-plugin": "node packages/classisland-plugin/scripts/build.mjs --cipx", "dist:classisland-plugin": "node packages/classisland-plugin/scripts/build.mjs --cipx",
"dist:all": "pnpm dist:server && pnpm dist:win && pnpm dist:classisland-plugin" "dist:all": "pnpm dist:server && pnpm dist:win && pnpm dist:classisland-plugin"
}, },
+1 -1
View File
@@ -14,6 +14,6 @@ description: |-
4. 可选:把班级小助手上排好的课表镜像回 ClassIsland。 4. 可选:把班级小助手上排好的课表镜像回 ClassIsland。
entranceAssembly: 'ClassHelper.ClassIslandPlugin.dll' entranceAssembly: 'ClassHelper.ClassIslandPlugin.dll'
url: https://github.com/LoveChengke/ClassHelper url: https://github.com/LoveChengke/ClassHelper
version: 0.1.0.0 version: 1.1.0.0
apiVersion: 2.0.0.0 apiVersion: 2.0.0.0
author: 班级小助手 author: 班级小助手
@@ -295,6 +295,57 @@ check(
bridgeSource.includes('NotificationPollSeconds'), bridgeSource.includes('NotificationPollSeconds'),
); );
/* ------------------------------------------------------------ 8. 回归护栏:本次修复过的坑 */
check(
'课表配对用原始 TimeType==0 列表,**不用** ValidTimeLayoutItems(后者会剔除被停用的节次,导致整份课表错位)',
// 只查代码形态(`.Count`),因为源码注释里特意点名了这个属性来说明"为什么不能用它"
mapperSource.includes('classPoints[index]') && !mapperSource.includes('.ValidTimeLayoutItems.Count'),
);
check(
'上报字段按服务端 zod 上限截断(一个超长名字会让整批上报 400,连状态与心跳一起丢掉)',
mapperSource.includes('Truncate(') &&
mapperSource.includes('SubjectMaxLength') &&
mapperSource.includes('PlanNameMaxLength'),
);
check(
'课表镜像在 UI 线程改写档案(线程池上改 Observable 集合会与落盘并发,可能写坏档案)',
bridgeSource.includes('Dispatcher.UIThread.InvokeAsync') && bridgeSource.includes('SaveProfile()'),
);
check(
'镜像内容未变化时跳过(否则每次上报都重建课表并全量落盘)',
bridgeSource.includes('_lastMirrorSignature') && bridgeSource.includes('MirrorSignature('),
);
check(
'上报异常有 catch(fire-and-forget 的异常会被静默吞掉)',
bridgeSource.includes('catch (Exception exception)') && bridgeSource.includes('上报异常'),
);
check(
'镜像前过滤时间非法的条目(避免档案里出现 00:00 的课次,且必须与 Classes 同步过滤)',
read('src/Services/ClassPlanWriter.cs').includes('IsValidTime'),
);
check(
'上报体带上 deviceKey,且服务端 schema 也声明了该字段(回填机器码的契约两端一致)',
clientSource.includes('"deviceKey"') && serverSchemas.includes('deviceKey:'),
);
check(
'2xx 但不是本服务响应体时给出原因(而不是"成功但无数据 + 空消息"),并限制响应体大小',
clientSource.includes('响应不是班级小助手的标准格式') &&
clientSource.includes('MaxResponseContentBufferSize'),
);
check(
'提醒提供方惰性获取课程服务并重试(拿不到服务时"上课暂存"会永久失效且静默)',
providerSource.includes('EnsureLessons') && providerSource.includes('_lessonsHooked'),
);
check(
'设置落盘先写临时文件再原子替换(逐字符写盘 + 截断式写入会留下坏 JSON)',
pluginSource.includes('File.Move(temp, path, overwrite: true)'),
);
check(
'服务器地址只接受 http/https(裸 Uri.TryCreate 会放过 file:// / ftp://)',
settingsSource.includes('TryGetServerUri') && settingsSource.includes('UriSchemeHttp'),
);
/* ------------------------------------------------------------ 结果 */ /* ------------------------------------------------------------ 结果 */
const failed = results.filter((item) => !item.ok); const failed = results.filter((item) => !item.ok);
@@ -69,6 +69,8 @@ public class ReportRequestDto
{ {
[JsonPropertyName("pluginVersion")] public string PluginVersion { get; set; } = ""; [JsonPropertyName("pluginVersion")] public string PluginVersion { get; set; } = "";
[JsonPropertyName("classIslandVersion")] public string ClassIslandVersion { get; set; } = ""; [JsonPropertyName("classIslandVersion")] public string ClassIslandVersion { get; set; } = "";
/// <summary>本机机器码:设备创建时服务端还不知道它,靠这里回填(见服务端 syncDeviceKey)。</summary>
[JsonPropertyName("deviceKey")] public string DeviceKey { get; set; } = "";
[JsonPropertyName("state")] public StateDto? State { get; set; } [JsonPropertyName("state")] public StateDto? State { get; set; }
[JsonPropertyName("schedule")] public SchedulePayloadDto? Schedule { get; set; } [JsonPropertyName("schedule")] public SchedulePayloadDto? Schedule { get; set; }
[JsonPropertyName("timeLayout")] public TimeLayoutPayloadDto? TimeLayout { get; set; } [JsonPropertyName("timeLayout")] public TimeLayoutPayloadDto? TimeLayout { get; set; }
@@ -198,6 +200,12 @@ public sealed class ClassHelperClient : IDisposable
/// </summary> /// </summary>
private static readonly TimeSpan Timeout = TimeSpan.FromSeconds(12); private static readonly TimeSpan Timeout = TimeSpan.FromSeconds(12);
/// <summary>
/// 响应体上限(4MB)。默认是 2GB —— 服务器地址填错(指到一个会吐大页面的地址)时,
/// 一次请求就能在 12 秒内把内存吃光。
/// </summary>
private const long MaxResponseBytes = 4 * 1024 * 1024;
private static readonly JsonSerializerOptions JsonOptions = new() private static readonly JsonSerializerOptions JsonOptions = new()
{ {
PropertyNameCaseInsensitive = true, PropertyNameCaseInsensitive = true,
@@ -216,6 +224,7 @@ public sealed class ClassHelperClient : IDisposable
private readonly HttpClient _http = new(new SocketsHttpHandler { Proxy = new LocalAwareProxy() }) private readonly HttpClient _http = new(new SocketsHttpHandler { Proxy = new LocalAwareProxy() })
{ {
Timeout = Timeout, Timeout = Timeout,
MaxResponseContentBufferSize = MaxResponseBytes,
}; };
public string LastError { get; private set; } = ""; public string LastError { get; private set; } = "";
@@ -334,6 +343,17 @@ public sealed class ClassHelperClient : IDisposable
return envelope ?? new ApiEnvelope<T> { Success = false, Message = message! }; return envelope ?? new ApiEnvelope<T> { Success = false, Message = message! };
} }
if (envelope is null)
{
// 2xx 但响应不是本服务的统一响应体(网关/反代的 HTML 错误页、地址指到了别的服务等)。
// 必须留下原因:否则调用方拿到的是"成功但无数据 + 空错误消息",
// 设置页显示"连接异常"却没有原因,与上面专门为代理错误页写的诊断自相矛盾。
LastError =
$"HTTP {(int)response.StatusCode}({method.Method} {request.RequestUri})——" +
"响应不是班级小助手的标准格式,请检查服务器地址是否正确,或该系统代理是否拦截了内网请求";
return new ApiEnvelope<T> { Success = false, Message = LastError };
}
LastError = ""; LastError = "";
LastSuccessAt = DateTimeOffset.Now; LastSuccessAt = DateTimeOffset.Now;
return envelope; return envelope;
@@ -40,7 +40,10 @@ public class PluginSettings : ObservableObject
public string DeviceToken public string DeviceToken
{ {
get => _deviceToken; get => _deviceToken;
set => SetProperty(ref _deviceToken, value); // 在 setter 里就去掉首尾空白:粘贴令牌时带前导空格非常常见,
// 而 Normalize() 只在启动加载时跑一次 —— 运行期粘进来的脏值会让 IsConfigured
// 一直为 false,用户看着明明填好了却查不出原因。
set => SetProperty(ref _deviceToken, (value ?? "").Trim());
} }
/// <summary> /// <summary>
@@ -154,5 +157,20 @@ public class PluginSettings : ObservableObject
/// <summary>是否已经配置好(地址 + 令牌都填了)。</summary> /// <summary>是否已经配置好(地址 + 令牌都填了)。</summary>
public bool IsConfigured => public bool IsConfigured =>
Uri.TryCreate(ServerUrl, UriKind.Absolute, out _) && DeviceToken.StartsWith("chci_", StringComparison.Ordinal); TryGetServerUri(out _) && DeviceToken.StartsWith("chci_", StringComparison.Ordinal);
/// <summary>
/// 解析服务器地址,**只接受 http/https 绝对地址**。
///
/// 不用裸的 `Uri.TryCreate(..., UriKind.Absolute)`:它会接受 `file://` / `ftp://`,
/// 那种地址会在发请求时抛一句难以理解的 NotSupportedException,用户根本猜不到是地址填错了。
/// </summary>
public bool TryGetServerUri(out Uri uri)
{
uri = null!;
if (!Uri.TryCreate((ServerUrl ?? "").Trim(), UriKind.Absolute, out var parsed)) return false;
if (parsed.Scheme != Uri.UriSchemeHttp && parsed.Scheme != Uri.UriSchemeHttps) return false;
uri = parsed;
return true;
}
} }
+17 -3
View File
@@ -127,9 +127,15 @@ public class Plugin : PluginBase
settings.Normalize(); settings.Normalize();
if (needGenerateKey) if (needGenerateKey)
{ {
// 机器名 + 随机短码:既是人眼可读的"这台机器",又不会两台同名机器撞车 // 机器名 + 随机短码:既是人眼可读的"这台机器",又不会两台同名机器撞车。
// 注意长度:原先写的是 `[..Math.Min(24, machine.Length + 33)]`,而 machine.Length + 33
// 恒大于 24,所以实际**永远只取前 24 个字符** —— 机器名稍长就把随机段整个切掉,
// "同名机器不撞车"的保障就没了。这里改成"机器名按需截短 + 保留 8 位随机段"。
var machine = Environment.MachineName.ToLowerInvariant(); var machine = Environment.MachineName.ToLowerInvariant();
settings.DeviceKey = $"{machine}-{Guid.NewGuid():N}"[..Math.Min(24, machine.Length + 33)]; var suffix = Guid.NewGuid().ToString("N")[..8];
var maxMachineLength = Math.Max(4, 24 - suffix.Length - 1);
if (machine.Length > maxMachineLength) machine = machine[..maxMachineLength];
settings.DeviceKey = $"{machine}-{suffix}";
} }
Settings = settings; Settings = settings;
@@ -146,7 +152,15 @@ public class Plugin : PluginBase
{ {
var folder = Path.GetDirectoryName(path); var folder = Path.GetDirectoryName(path);
if (!string.IsNullOrEmpty(folder)) Directory.CreateDirectory(folder); if (!string.IsNullOrEmpty(folder)) Directory.CreateDirectory(folder);
File.WriteAllText(path, JsonSerializer.Serialize(settings, JsonOptions)); // 先写临时文件再原子替换。
//
// 设置页的地址/令牌输入框是 TwoWay 绑定(逐字符提交),直接 `File.WriteAllText`
// 会就地截断原文件;一旦此刻进程被杀或断电,留下的是半截 JSON,而 LoadSettings 的
// catch 会**静默回退到默认设置** —— 用户看到的是"令牌和地址莫名其妙没了",
// 而且原文件已被覆盖,无从恢复。
var temp = path + ".tmp";
File.WriteAllText(temp, JsonSerializer.Serialize(settings, JsonOptions));
File.Move(temp, path, overwrite: true);
} }
catch (Exception exception) catch (Exception exception)
{ {
@@ -1,5 +1,7 @@
using System.ComponentModel; using System.ComponentModel;
using System.Runtime.CompilerServices; using System.Runtime.CompilerServices;
using System.Text;
using Avalonia.Threading;
using ClassHelper.ClassIslandPlugin.Interop; using ClassHelper.ClassIslandPlugin.Interop;
using ClassHelper.ClassIslandPlugin.Models; using ClassHelper.ClassIslandPlugin.Models;
using ClassIsland.Core; using ClassIsland.Core;
@@ -39,6 +41,11 @@ public sealed class BridgeService : INotifyPropertyChanged, IDisposable
private bool _reporting; private bool _reporting;
private bool _pulling; private bool _pulling;
private bool _eventsHooked; private bool _eventsHooked;
/// <summary>
/// 上次成功镜像的课表内容指纹。内容没变就完全跳过镜像:既省掉每分钟一次的全量重建 + 落盘,
/// 也把"跨线程改档案"的窗口从"每分钟一次"降回"只在课表真的变化时"。
/// </summary>
private volatile string? _lastMirrorSignature;
public BridgeService(PluginSettings settings, ILogger<BridgeService> logger) public BridgeService(PluginSettings settings, ILogger<BridgeService> logger)
{ {
@@ -237,6 +244,8 @@ public sealed class BridgeService : INotifyPropertyChanged, IDisposable
{ {
PluginVersion = PluginVersion, PluginVersion = PluginVersion,
ClassIslandVersion = SafeAppVersion(), ClassIslandVersion = SafeAppVersion(),
// 机器码:设备创建时服务端只能用 pending-… 占位,靠这里回填,Web 端设备列表才能与教室机器对上
DeviceKey = _settings.DeviceKey,
State = BuildState(lessons), State = BuildState(lessons),
}; };
@@ -274,7 +283,9 @@ public sealed class BridgeService : INotifyPropertyChanged, IDisposable
layoutCount = items.Count; layoutCount = items.Count;
request.TimeLayout = new TimeLayoutPayloadDto request.TimeLayout = new TimeLayoutPayloadDto
{ {
Name = string.IsNullOrWhiteSpace(layout.Name) ? "ClassIsland 时间表" : layout.Name, Name = ScheduleMapper.Truncate(
string.IsNullOrWhiteSpace(layout.Name) ? "ClassIsland 时间表" : layout.Name,
ScheduleMapper.PlanNameMaxLength)!,
Mode = "replace", Mode = "replace",
Items = items, Items = items,
}; };
@@ -321,6 +332,16 @@ public sealed class BridgeService : INotifyPropertyChanged, IDisposable
return true; return true;
} }
catch (Exception exception)
{
// ReportAsync 是通过 `_ = ReportAsync(reason)` 这种 fire-and-forget 方式发起的
// (事件回调与定时器都是),没有这个 catch,中途抛出的异常(例如跨线程改档案时的
// "Collection was modified")会被 unobserved task 静默吞掉:日志里一条都没有,
// 而 LastReportMessage 还停在上一次的成功结果,用户以为一切正常。
_logger.LogError(exception, "班级小助手联动:上报异常({Reason})", reason);
SetState(false, $"上报异常:{exception.Message}", 0, 0, null);
return false;
}
finally finally
{ {
Busy = false; Busy = false;
@@ -397,23 +418,48 @@ public sealed class BridgeService : INotifyPropertyChanged, IDisposable
return; return;
} }
// 内容没变就直接返回:上报是"启动 + 每个课程事件 + 每 N 秒"触发的,原先每次都要
// 重建全部课表对象并整体落盘 —— 无谓的网络/磁盘 I/O,还会把档案页刷得不停重绘。
var signature = MirrorSignature(plan);
if (signature == _lastMirrorSignature)
{
_logger.LogDebug("班级小助手联动:课表内容与上次一致,跳过镜像");
return;
}
try try
{ {
var applied = ClassPlanWriter.Apply(profile, plan); // **必须在 UI 线程上改写档案**:ClassIsland 的档案是 ObservableDictionary /
if (!applied.Applied) // ObservableCollection,落盘是"属性变化即整体序列化 + FileStream 就地截断"。
// 而本方法是从线程池线程继续执行的(ReportAsync 里 ConfigureAwait(false) 之后,
// 定时器回调本就在线程池上),在线程池上改集合会与 UI 线程的保存/绑定并发:
// 轻则 InvalidOperationException(Collection was modified),重则两次写入互相截断,
// **把整个档案写成半截 JSON**(老师的课表/科目全丢,只能靠 .bak 兜底)。
var outcome = await Dispatcher.UIThread.InvokeAsync(() =>
{
var applied = ClassPlanWriter.Apply(profile, plan);
if (!applied.Applied)
{
return applied;
}
// 改写的是 Profile 里的集合,ClassIsland 会靠 INotifyCollectionChanged 落盘;
// 这里显式 SaveProfile() 是为了"打开开关马上就能在课表里看到",不用等下一次自动保存。
IAppHost.TryGetService<IProfileService>()?.SaveProfile();
return applied;
});
if (!outcome.Applied)
{ {
_logger.LogInformation("班级小助手联动:课表镜像未生效({Reason})", _logger.LogInformation("班级小助手联动:课表镜像未生效({Reason})",
applied.Warnings.FirstOrDefault() ?? "服务端课表为空"); outcome.Warnings.FirstOrDefault() ?? "服务端课表为空");
return; return;
} }
// 改写的是 Profile 里的集合,ClassIsland 会靠 INotifyCollectionChanged 落盘; _lastMirrorSignature = signature;
// 这里显式 SaveProfile() 是为了"打开开关马上就能在课表里看到",不用等下一次自动保存。
IAppHost.TryGetService<IProfileService>()?.SaveProfile();
_logger.LogInformation("班级小助手联动:已把班级课表写入 ClassIsland({Plans})", _logger.LogInformation("班级小助手联动:已把班级课表写入 ClassIsland({Plans})",
string.Join("、", applied.PlanNames.Select(name => $"「{name}」"))); string.Join("、", outcome.PlanNames.Select(name => $"「{name}」")));
foreach (var warning in applied.Warnings) foreach (var warning in outcome.Warnings)
{ {
_logger.LogWarning("班级小助手联动镜像提示:{Warning}", warning); _logger.LogWarning("班级小助手联动镜像提示:{Warning}", warning);
} }
@@ -424,10 +470,32 @@ public sealed class BridgeService : INotifyPropertyChanged, IDisposable
} }
} }
/// <summary>镜像载荷的内容指纹(只用于"内容没变就跳过",不参与任何业务判断)</summary>
private static string MirrorSignature(ClassPlanMirrorDto plan)
{
var builder = new StringBuilder();
foreach (var entry in plan.Entries)
{
builder.Append(entry.WeekDay).Append('|').Append(entry.WeekCountDiv).Append('|')
.Append(entry.WeekCountDivTotal).Append('|').Append(entry.Subject).Append('|')
.Append(entry.StartTime).Append('|').Append(entry.EndTime).Append(';');
}
foreach (var layout in plan.TimeLayouts)
{
builder.Append('#').Append(layout.Id).Append(':');
foreach (var item in layout.Layouts)
{
builder.Append(item.StartTime).Append('-').Append(item.EndTime).Append('@')
.Append(item.TimeType).Append(',');
}
}
return builder.ToString();
}
/* ---------------------------------------------------------------- 内部实现 */ /* ---------------------------------------------------------------- 内部实现 */
/// <summary>插件版本(与 manifest.yml / csproj 保持一致)。</summary> /// <summary>插件版本(与 manifest.yml / csproj 保持一致)。</summary>
private const string PluginVersion = "0.1.0.0"; private const string PluginVersion = "1.1.0.0";
/// <summary>ClassIsland 版本读不到时不该让上报失败(开发版可能为 null)。</summary> /// <summary>ClassIsland 版本读不到时不该让上报失败(开发版可能为 null)。</summary>
private static string SafeAppVersion() private static string SafeAppVersion()
@@ -63,6 +63,7 @@ public sealed class ClassHelperNotificationProvider : NotificationProviderBase
private readonly List<PushNotificationDto> _deferred = new(); private readonly List<PushNotificationDto> _deferred = new();
private ILessonsService? _lessons; private ILessonsService? _lessons;
private bool _lessonsHooked;
public ClassHelperNotificationProvider( public ClassHelperNotificationProvider(
BridgeService bridge, BridgeService bridge,
@@ -74,26 +75,43 @@ public sealed class ClassHelperNotificationProvider : NotificationProviderBase
_logger = logger; _logger = logger;
_bridge.NotificationReceived += OnNotificationReceived; _bridge.NotificationReceived += OnNotificationReceived;
// 订阅课程事件:下课后把上课时段暂存的提醒补弹出来 // 尽力而为地先订阅一次;拿不到也没关系,后面每次需要判定时都会重试
// (本类的构造函数可能在课程服务建好之前就被 DI 调用)
EnsureLessons();
}
/// <summary>
/// 惰性获取课程服务并**只订阅一次**课程事件(下课后补弹上课时段暂存的提醒)。
///
/// 为什么不能只在构造函数里订阅:提供方是随主机启动被构造的,而课程服务在启动流程里的
/// 创建时机并不固定。一旦构造函数里拿到 null,原先的实现既不重试、也不打日志,
/// 于是 `IsInClass()` 恒为 false —— "上课时段先暂存、下课再补弹"这条规则**永久失效**,
/// 老师在课上发的通知会直接全屏打断课堂,而且完全静默、无从排查。
/// </summary>
private void EnsureLessons()
{
if (_lessonsHooked) return;
try try
{ {
_lessons = IAppHost.TryGetService<ILessonsService>(); _lessons = IAppHost.TryGetService<ILessonsService>();
if (_lessons is not null) if (_lessons is null) return;
{
_lessons.OnBreakingTime += (_, _) => Dispatcher.UIThread.Post(FlushDeferred); _lessons.OnBreakingTime += (_, _) => Dispatcher.UIThread.Post(FlushDeferred);
_lessons.OnAfterSchool += (_, _) => Dispatcher.UIThread.Post(FlushDeferred); _lessons.OnAfterSchool += (_, _) => Dispatcher.UIThread.Post(FlushDeferred);
_lessons.CurrentTimeStateChanged += (_, _) => Dispatcher.UIThread.Post(FlushDeferred); _lessons.CurrentTimeStateChanged += (_, _) => Dispatcher.UIThread.Post(FlushDeferred);
} _lessonsHooked = true;
_logger.LogInformation("班级小助手联动:提醒提供方已订阅课程事件(上课时段暂存、下课补弹)");
} }
catch (Exception exception) catch (Exception exception)
{ {
_logger.LogWarning(exception, "班级小助手联动:订阅课程事件失败,上课暂存将退化为「立即弹出」"); _logger.LogWarning(exception, "班级小助手联动:订阅课程事件失败,将在下次提醒时重试");
} }
} }
/// <summary>当前是否处于上课时段(读不到课程服务时按"不在上课"处理,宁可弹也不静默丢)</summary> /// <summary>当前是否处于上课时段(读不到课程服务时按"不在上课"处理,宁可弹也不静默丢)</summary>
private bool IsInClass() private bool IsInClass()
{ {
EnsureLessons();
try try
{ {
return _lessons?.CurrentState == TimeState.OnClass; return _lessons?.CurrentState == TimeState.OnClass;
@@ -79,9 +79,22 @@ public static class ClassPlanWriter
{ {
var planName = BuildPlanName(source.ProfileName, group.WeekDay, group.WeekCountDiv, var planName = BuildPlanName(source.ProfileName, group.WeekDay, group.WeekCountDiv,
group.WeekCountDivTotal, groups.Count); group.WeekCountDivTotal, groups.Count);
// 时间非法的条目必须**在这里**就整批丢掉:`Classes` 与时间表里的上课点必须等长且同序,
// 只在一处跳过会让整份课表错位。原先 ParseTime 把无法解析的值悄悄变成 00:00,
// 于是档案里凭空出现 00:00-00:00 的课次(时间轴显示与当前节次判断都会乱),还没有任何日志。
var usable = group.Entries
.Where(entry => IsValidTime(entry.StartTime) && IsValidTime(entry.EndTime))
.ToList();
if (usable.Count < group.Entries.Count)
{
result.Warnings.Add(
$"「{planName}」有 {group.Entries.Count - usable.Count} 节的时间无法解析(需要 HH:mm),已跳过");
}
if (usable.Count == 0) continue;
var planId = FindPlanId(profile, planName); var planId = FindPlanId(profile, planName);
var (timeLayoutId, timeLayout) = BuildTimeLayout( var (timeLayoutId, timeLayout) = BuildTimeLayout(profile, planName, usable);
profile, planName, group.Entries);
var plan = profile.ClassPlans.TryGetValue(planId, out var existing) var plan = profile.ClassPlans.TryGetValue(planId, out var existing)
? existing ? existing
@@ -102,7 +115,7 @@ public static class ClassPlanWriter
// 档案不会重新触发刷新,课次就会停留在旧时间点上。 // 档案不会重新触发刷新,课次就会停留在旧时间点上。
var classes = new ObservableCollection<ClassInfo>(); var classes = new ObservableCollection<ClassInfo>();
var index = 0; var index = 0;
foreach (var entry in group.Entries) foreach (var entry in usable)
{ {
var subjectId = profile.Subjects var subjectId = profile.Subjects
.FirstOrDefault(pair => pair.Value.Name == entry.Subject).Key; .FirstOrDefault(pair => pair.Value.Name == entry.Subject).Key;
@@ -251,4 +264,19 @@ public static class ClassPlanWriter
{ {
return TimeSpan.TryParse(value, out var parsed) ? parsed : TimeSpan.Zero; return TimeSpan.TryParse(value, out var parsed) ? parsed : TimeSpan.Zero;
} }
/// <summary>
/// 时间字符串是否可用(HH:mm / HH:mm:ss)。
///
/// 服务端输出侧没有校验 `Schedule.startTime`(老数据/异常数据可能是空串),
/// 而 <see cref="ParseTime"/> 会把非法值变成 0 点 —— 因此调用方必须先用本方法过滤,
/// 并把 Classes 与时间表**同时**按过滤后的列表构造,保证索引仍然一致。
/// </summary>
private static bool IsValidTime(string? value)
{
if (string.IsNullOrWhiteSpace(value)) return false;
return TimeSpan.TryParse(value, out var parsed)
&& parsed >= TimeSpan.Zero
&& parsed < TimeSpan.FromDays(1);
}
} }
@@ -61,9 +61,16 @@ public static class ScheduleMapper
/// 把档案里的一张课表(ClassPlan)展开成"每个上课时间点一条"的课表条目。 /// 把档案里的一张课表(ClassPlan)展开成"每个上课时间点一条"的课表条目。
/// ///
/// 与 ClassIsland 的语义严格对齐:<c>ClassPlan.Classes[i]</c> 对应 /// 与 ClassIsland 的语义严格对齐:<c>ClassPlan.Classes[i]</c> 对应
/// <c>TimeLayout.Layouts</c> 里**第 i 个 TimeType=0(上课)的点**, /// <c>TimeLayout.Layouts</c> 里**第 i 个 TimeType=0(上课)的点**,课间 / 分割线 / 行动不占位。
/// 课间 / 分割线 / 行动不占 Classes 的位置。因此这里必须按 TimeType 过滤后再配对, ///
/// 否则整张课表会错位。 /// **注意不要用 `plan.ValidTimeLayoutItems`**:它的口径与 `Classes` 不同 ——
/// `GetValidTimeLayoutItems()`(ClassIsland ClassPlan.cs)会正反两遍扫描,
/// 把 `ClassInfo.IsEnabled == false`(老师在课表编辑里"停用"这一节)的课**连同其后的课间**
/// 一起从结果里剔除;而 `RefreshClassesList()` 只按 `TimeType == 0` 的**总数**对齐
/// `Classes` 的长度,`ClassInfo.CurrentTimeLayoutItem` 也是按原始列表的第 `Index` 个取的。
/// 于是只要停用过任意一节,用 ValidTimeLayoutItems 配对就会让索引整体前移:
/// 第 i 节配上第 i+1 节的时间点、最后一节丢失,且 `Math.Min` 会把缺口静默吃掉 ——
/// 表现就是"课表看着有内容、每节课都对不上",极难排查。
/// </summary> /// </summary>
public static List<ScheduleEntryDto> MapClassPlan(ClassPlan plan, Profile profile, out string? warning) public static List<ScheduleEntryDto> MapClassPlan(ClassPlan plan, Profile profile, out string? warning)
{ {
@@ -77,11 +84,8 @@ public static class ScheduleMapper
return entries; return entries;
} }
// 只保留上课类型的时间点,顺序必须与 Classes 的索引一致 // 只保留上课类型的时间点,顺序必须与 Classes 的索引一致(见上面注释)
var classPoints = timeLayout.Layouts.Where(item => item.TimeType == 0).ToList(); var classPoints = timeLayout.Layouts.Where(item => item.TimeType == 0).ToList();
var validPoints = plan.ValidTimeLayoutItems.Count > 0
? plan.ValidTimeLayoutItems.Where(item => item.TimeType == 0).ToList()
: classPoints;
var weekDay = ToServerDayOfWeek(plan.TimeRule.WeekDay); var weekDay = ToServerDayOfWeek(plan.TimeRule.WeekDay);
var parity = ToWeekParity(plan.TimeRule.WeekCountDiv, plan.TimeRule.WeekCountDivTotal); var parity = ToWeekParity(plan.TimeRule.WeekCountDiv, plan.TimeRule.WeekCountDivTotal);
@@ -91,12 +95,15 @@ public static class ScheduleMapper
} }
var classes = plan.Classes; var classes = plan.Classes;
var count = Math.Min(classes.Count, validPoints.Count); var count = Math.Min(classes.Count, classPoints.Count);
for (var index = 0; index < count; index++) for (var index = 0; index < count; index++)
{ {
var info = classes[index]; var info = classes[index];
var point = validPoints[index]; // 索引必须与 Classes 对齐:这里按下标取时间点,**不能**先用 Where 过滤再取
var point = classPoints[index];
if (info is null) continue; if (info is null) continue;
// 老师停用的一节:本系统没有"停用"概念,不上报(否则学生端会看到一节实际上不上的课)
if (!info.IsEnabled) continue;
// 空课(未安排科目)不上报:服务端的科目是必填的,空课由课表里的缺席表达 // 空课(未安排科目)不上报:服务端的科目是必填的,空课由课表里的缺席表达
var subject = ResolveSubjectName(info.SubjectId, profile); var subject = ResolveSubjectName(info.SubjectId, profile);
@@ -107,18 +114,33 @@ public static class ScheduleMapper
DayOfWeek = weekDay, DayOfWeek = weekDay,
StartTime = ToHhMm(point.StartTime), StartTime = ToHhMm(point.StartTime),
EndTime = ToHhMm(point.EndTime), EndTime = ToHhMm(point.EndTime),
Subject = subject, // 服务端对这几个字段有 zod 长度上限,且是**整批**校验:一个超长名字会让整次上报
TeacherName = ResolveSubjectTeacher(info.SubjectId, profile), // 400,连"现在上什么课"的状态与心跳都不更新,Web 端把教室显示成离线。
Subject = Truncate(subject, SubjectMaxLength)!,
TeacherName = Truncate(ResolveSubjectTeacher(info.SubjectId, profile), NameMaxLength),
WeekParity = parity, WeekParity = parity,
WeekCountDiv = plan.TimeRule.WeekCountDiv, WeekCountDiv = plan.TimeRule.WeekCountDiv,
WeekCountDivTotal = plan.TimeRule.WeekCountDivTotal, WeekCountDivTotal = plan.TimeRule.WeekCountDivTotal,
PlanName = plan.Name, PlanName = Truncate(plan.Name, PlanNameMaxLength),
}); });
} }
return entries; return entries;
} }
/// <summary>服务端 zod 对各类名称的长度上限(超出会让整批上报 400,所以要截断) */
public const int SubjectMaxLength = 40;
public const int NameMaxLength = 40;
public const int PlanNameMaxLength = 60;
/// <summary>按服务端上限截断(null / 空串原样返回)</summary>
public static string? Truncate(string? value, int max)
{
if (string.IsNullOrEmpty(value)) return value;
var trimmed = value.Trim();
return trimmed.Length <= max ? trimmed : trimmed[..max];
}
/// <summary>把时间表(TimeLayout)转成本系统的节次时间配置。</summary> /// <summary>把时间表(TimeLayout)转成本系统的节次时间配置。</summary>
public static List<TimeLayoutItemDto> MapTimeLayout(TimeLayout layout) public static List<TimeLayoutItemDto> MapTimeLayout(TimeLayout layout)
{ {
@@ -131,7 +153,8 @@ public static class ScheduleMapper
items.Add(new TimeLayoutItemDto items.Add(new TimeLayoutItemDto
{ {
Index = index + 1, Index = index + 1,
Name = BuildTimePointName(point, ref classPointIndex), // 节次名同样是服务端有上限的字段(max 40),超长会让整批上报失败
Name = Truncate(BuildTimePointName(point, ref classPointIndex), NameMaxLength)!,
StartTime = ToHhMm(point.StartTime), StartTime = ToHhMm(point.StartTime),
EndTime = ToHhMm(point.EndTime), EndTime = ToHhMm(point.EndTime),
Type = ToTimeLayoutType(point.TimeType), Type = ToTimeLayoutType(point.TimeType),
@@ -26,6 +26,10 @@
Watermark="chci_..." Watermark="chci_..."
PasswordChar="●" PasswordChar="●"
Text="{Binding Settings.DeviceToken, Mode=TwoWay}" /> Text="{Binding Settings.DeviceToken, Mode=TwoWay}" />
<!-- 令牌是设备级长期凭证(只有管理员在 Web 端重置才会失效),而 ClassIsland 的插件配置
是明文 JSON 且会随档案备份/迁移一起被带走,所以这里明确提示用户别外传。 -->
<TextBlock Margin="0 6 0 0" TextWrapping="Wrap" Opacity="0.7"
Text="令牌是这台教室机器的长期凭证(仅管理员在 Web 端重置才会失效),会明文保存在本机配置文件里并随 ClassIsland 档案备份一起复制,请不要外传或提交到版本库。" />
<StackPanel Orientation="Horizontal" Margin="0 12 0 0" Spacing="8"> <StackPanel Orientation="Horizontal" Margin="0 12 0 0" Spacing="8">
<Button Content="立即上报" Command="{Binding ReportCommand}" IsEnabled="{Binding !Bridge.Busy}" /> <Button Content="立即上报" Command="{Binding ReportCommand}" IsEnabled="{Binding !Bridge.Busy}" />
@@ -2,10 +2,27 @@ appId: com.classhelper.desktop
productName: 班级小助手 productName: 班级小助手
copyright: Copyright © 2026 Class Helper copyright: Copyright © 2026 Class Helper
# 语言包:Electron 发行版自带 55 个 `locales/*.pak`(实测 48.3MB 未压缩 / 约 10MB 压缩后),
# 而本应用界面文案只有中文,其余 54 个语言包纯属白占体积(`win-unpacked` 372MB → 约 324MB)。
# 这是 electron-builder 的官方选项:`app-builder-lib` 的 removeUnusedLanguagesIfNeeded()
# 会对 `locales/*.pak` 做精确匹配删除,只留 `zh-CN.pak`(0.6MB)。
#
# 注意:**不要**为了继续压体积去删 dxcompiler/vk_swiftshader/d3dcompiler_47 这些 GPU 回退组件,
# 或 LICENSES.chromium.html —— 前者是教室老显卡/虚拟机上的 D3D12/D3D11/Vulkan 渲染回退,
# 后者是 Chromium 的许可证声明,合计只能再省约 12MB,风险不成比例。
# 另外安装包有硬底:`班级小助手.exe`(就是 electron.exe)压缩后本身就有 85~90MB,别再指望压到 60MB。
electronLanguages:
- zh-CN
directories: directories:
output: release output: release
buildResources: build buildResources: build
# 注意:这里**不要**加 afterPack 去改 appOutDir 的完整性标签。
# 归档内部的载荷标签不会被还原(装到正常位置拿到的是默认 Medium 文件),
# 而在打包前把 appOutDir 改成 Medium 会让 7za(自身带 Low 标签、进程被降到 Low)
# 因"不能向上读"而无法生成归档。交付物的标签统一在 scripts/dist-win.mjs 收尾时修正。
# 渲染进程产物已由 Vite 打包、主进程/preload 已由 esbuild 打包, # 渲染进程产物已由 Vite 打包、主进程/preload 已由 esbuild 打包,
# 运行时不需要任何 node_modules(electron 模块由 Electron 运行时提供)。 # 运行时不需要任何 node_modules(electron 模块由 Electron 运行时提供)。
files: files:
+18 -1
View File
@@ -3,7 +3,24 @@
<head> <head>
<meta charset="UTF-8" /> <meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" />
<!-- Electron 渲染进程安全策略:只允许加载本地资源与后端 HTTP/WS 连接 --> <!--
内容安全策略(Electron 渲染进程)。
为什么必须有:渲染进程通过 preload 桥能拿到 `getConfig()` 返回的**明文登录令牌**
(代表该班全班身份),因此一旦出现一次注入(未来某个 v-html、某个依赖被投毒),
脚本就能把令牌发到外网。CSP 是唯一能拦住"加载并执行远程脚本"的那一层。
各指令口径:
- default-src/script-src 'self':只允许执行本应用自己的脚本(挡住远程脚本注入);
- style-src 需要 'unsafe-inline':Vue SFC 与 Element Plus 运行时会注入行内样式;
- connect-src 放开 http/https/ws/wss:服务器地址由用户在设置页填写(可能是内网 IP、域名、
HTTPS 反代),无法预先枚举,且连接本身不是"执行代码"的入口;
- object-src/frame-src/form-action 一律关掉:本应用不需要插件、内嵌页面与表单提交。
-->
<meta
http-equiv="Content-Security-Policy"
content="default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data: blob:; font-src 'self' data:; connect-src 'self' http: https: ws: wss:; object-src 'none'; frame-src 'none'; form-action 'none'; base-uri 'self'"
/>
<title>班级小助手</title> <title>班级小助手</title>
</head> </head>
<body> <body>
+5
View File
@@ -3,6 +3,11 @@
<head> <head>
<meta charset="UTF-8" /> <meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" />
<!-- 与主窗口同一套 CSP(理由见 index.html):灵动岛同样是持有 preload 桥的渲染进程 -->
<meta
http-equiv="Content-Security-Policy"
content="default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data: blob:; font-src 'self' data:; connect-src 'self' http: https: ws: wss:; object-src 'none'; frame-src 'none'; form-action 'none'; base-uri 'self'"
/>
<title>班级小助手 · 灵动岛</title> <title>班级小助手 · 灵动岛</title>
<style> <style>
/* 透明背景:窗口本身无边框透明,由页面绘制圆角卡片 */ /* 透明背景:窗口本身无边框透明,由页面绘制圆角卡片 */
+3 -3
View File
@@ -1,15 +1,16 @@
{ {
"name": "@classhelper/desktop-client", "name": "@classhelper/desktop-client",
"version": "0.1.0", "version": "1.1.0",
"private": true, "private": true,
"description": "班级小助手 EXE 客户端(Electron + Vue 3 + Element Plus + Socket.IO + IndexedDB 离线缓存)", "description": "班级小助手 EXE 客户端(Electron + Vue 3 + Element Plus + Socket.IO + IndexedDB 离线缓存)",
"author": "Class Helper", "author": "Class Helper",
"main": "dist/main/index.js", "main": "dist/main/index.js",
"scripts": { "scripts": {
"dev": "node scripts/dev.mjs", "dev": "node scripts/dev.mjs",
"build": "npm run build:main && npm run build:renderer", "build": "node ../../scripts/check-icons.mjs && npm run build:main && npm run build:renderer && npm run check:secrets",
"build:main": "node scripts/build-main.mjs", "build:main": "node scripts/build-main.mjs",
"build:renderer": "vite build", "build:renderer": "vite build",
"check:secrets": "node scripts/check-bundle-secrets.mjs",
"start": "electron .", "start": "electron .",
"smoke": "node scripts/smoke.mjs", "smoke": "node scripts/smoke.mjs",
"typecheck": "vue-tsc --noEmit -p tsconfig.json && tsc --noEmit -p tsconfig.node.json", "typecheck": "vue-tsc --noEmit -p tsconfig.json && tsc --noEmit -p tsconfig.node.json",
@@ -20,7 +21,6 @@
"@classhelper/shared": "workspace:*", "@classhelper/shared": "workspace:*",
"@element-plus/icons-vue": "^2.3.2", "@element-plus/icons-vue": "^2.3.2",
"axios": "^1.20.0", "axios": "^1.20.0",
"echarts": "^6.1.0",
"element-plus": "^2.14.5", "element-plus": "^2.14.5",
"pinia": "^4.0.3", "pinia": "^4.0.3",
"socket.io-client": "^4.8.3", "socket.io-client": "^4.8.3",
@@ -0,0 +1,75 @@
#!/usr/bin/env node
/**
* 构建产物凭据自检:`dist` 里不允许出现种子账号 / 口令字面量。
*
* 为什么单独立一条门禁:`dist/main/index.js` 与 `dist/renderer/assets/*.js` 会被 electron-builder
* 打进 `app.asar`,随安装包发到每台学生机,而 **asar 可以直接解包**。
* 冒烟/自检代码里写死 `teacher1 / teacher123` 这类字面量,等于把教师账号随安装包一起发出去
* (历史上真的发生过:`grep teacher123 dist/main/index.js` 命中 3 次)。
*
* 凭据一律由 `scripts/smoke.mjs` / `scripts/verify-packaged.mjs` 通过环境变量提供
* (`ELECTRON_SMOKE_USER` / `ELECTRON_SMOKE_PASSWORD` / `ELECTRON_SMOKE_CLASS_CODE` / `..._CLASS_PASSWORD`),
* 那两个脚本不进安装包。
*
* 命中即构建失败(exit 1)。
*/
import fs from 'node:fs';
import path from 'node:path';
import { fileURLToPath } from 'node:url';
const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
const distDir = path.join(root, 'dist');
/** 明确的种子口令:任何情况下都不该出现在产物里 */
const FORBIDDEN_STRINGS = ['teacher123', 'admin123', 'student123'];
/** 组合形态:把种子班级码 / 默认班级密码当凭据使用的写法 */
const FORBIDDEN_PATTERNS = [
{ label: '种子班级码当凭据', pattern: /["'](?:code|classCode)["']\s*[:=]\s*["']G(?:101|102|203)["']/ },
{
label: '默认班级密码当凭据',
pattern: /["'](?:password|classPassword)["']\s*[:=]\s*["']123456["']/,
},
];
/** 递归收集文件(跳过 sourcemap 与二进制) */
function collectFiles(dir) {
const found = [];
for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
const full = path.join(dir, entry.name);
if (entry.isDirectory()) {
found.push(...collectFiles(full));
} else if (/\.(?:js|mjs|cjs|html|json|css)$/i.test(entry.name)) {
found.push(full);
}
}
return found;
}
if (!fs.existsSync(distDir)) {
console.log('[check-secrets] 未找到 dist(尚未构建),跳过凭据自检');
process.exit(0);
}
const hits = [];
for (const file of collectFiles(distDir)) {
const content = fs.readFileSync(file, 'utf8');
const relative = path.relative(root, file);
for (const needle of FORBIDDEN_STRINGS) {
if (content.includes(needle)) hits.push(`${relative}:出现种子口令「${needle}」`);
}
for (const { label, pattern } of FORBIDDEN_PATTERNS) {
if (pattern.test(content)) hits.push(`${relative}:${label}`);
}
}
if (hits.length > 0) {
console.error('[check-secrets] 构建产物里出现了种子凭据(asar 可被解包,不能随包分发):');
for (const hit of hits) console.error(` - ${hit}`);
console.error(
'\n请把凭据改为从环境变量读取(见 scripts/smoke.mjs 的 ELECTRON_SMOKE_USER 等),不要写进源码。',
);
process.exit(1);
}
console.log(`[check-secrets] 通过:${collectFiles(distDir).length} 个产物文件里没有任何种子凭据字面量`);
+55 -1
View File
@@ -12,7 +12,7 @@
* node scripts/dist-win.mjs # nsis 安装包 + portable 单文件 * node scripts/dist-win.mjs # nsis 安装包 + portable 单文件
* node scripts/dist-win.mjs --dir # 仅生成免安装目录 release/win-unpacked * node scripts/dist-win.mjs --dir # 仅生成免安装目录 release/win-unpacked
*/ */
import { spawn } from 'node:child_process'; import { execFileSync, spawn } from 'node:child_process';
import fs from 'node:fs'; import fs from 'node:fs';
import path from 'node:path'; import path from 'node:path';
import { fileURLToPath } from 'node:url'; import { fileURLToPath } from 'node:url';
@@ -24,8 +24,17 @@ const args = process.argv.slice(2);
const dirOnly = args.includes('--dir'); const dirOnly = args.includes('--dir');
const passthrough = args.filter((item) => item !== '--dir'); const passthrough = args.filter((item) => item !== '--dir');
// makensis 会在 %TEMP% 所在位置建临时文件:Git Bash 里 TEMP=/tmp 是 MSYS 路径,
// 原生程序会把它当成「当前盘根下的 tmp」(D:\tmp,不存在)而报
// `!tempfile: Unable to create temporary file!`,NSIS 那一步就失败(磁盘并不紧张)。
// 统一指到仓库内的真实目录,避开宿主终端带来的环境差异。
const tmpDir = path.join(repoRoot, '.cache', 'tmp');
fs.mkdirSync(tmpDir, { recursive: true });
const env = { const env = {
...process.env, ...process.env,
TEMP: tmpDir,
TMP: tmpDir,
ELECTRON_MIRROR: process.env.ELECTRON_MIRROR ?? 'https://cdn.npmmirror.com/binaries/electron/', ELECTRON_MIRROR: process.env.ELECTRON_MIRROR ?? 'https://cdn.npmmirror.com/binaries/electron/',
ELECTRON_BUILDER_BINARIES_MIRROR: ELECTRON_BUILDER_BINARIES_MIRROR:
process.env.ELECTRON_BUILDER_BINARIES_MIRROR ?? process.env.ELECTRON_BUILDER_BINARIES_MIRROR ??
@@ -60,11 +69,56 @@ console.log('[dist] electron-builder', cliArgs.slice(1).join(' '));
const runtime = resolveNodeRuntime(); const runtime = resolveNodeRuntime();
console.log(`[dist] Node 运行时:${runtime.path}(${runtime.version})`); console.log(`[dist] Node 运行时:${runtime.path}(${runtime.version})`);
// 清理上一轮产物:本仓库目录树带沙箱 ACL(含 Everyone 的 DENY(delete child)),
// 已存在的产物会被工具(makensis / 7za)判为"Can't open output file / 拒绝访问"而失败,
// 手动删掉再打包即可 —— 顺手也保证产物集合确定,不会残留上一轮的旧安装包。
const outputDir = path.join(root, 'release');
if (fs.existsSync(outputDir)) {
for (const name of fs.readdirSync(outputDir)) {
if (!/\.(exe|7z|blockmap|yml)$/i.test(name)) continue;
try {
fs.rmSync(path.join(outputDir, name), { force: true });
} catch (error) {
console.warn(`[dist] 无法清理旧产物 ${name}:${error.message}`);
}
}
console.log('[dist] 已清理上一轮的安装包 / 归档');
}
const child = spawn(runtime.path, cliArgs, { cwd: root, stdio: 'inherit', env }); const child = spawn(runtime.path, cliArgs, { cwd: root, stdio: 'inherit', env });
/**
* 把交付产物的完整性标签修正为 Medium(Windows)。
*
* 背景(踩过一次,代价是"客户端装不上、便捷版也双击没反应"):
* 本仓库目录树被宿主沙箱打上了 `Low Mandatory Level` 标签(可继承),
* 因此在仓库内构建出的 exe 自身也带 Low 标签。Windows 会把这类进程降到 Low 完整性,
* 于是 setup.exe 写不进 `%LOCALAPPDATA%`(报"拒绝访问"→ 装不上)、
* 便捷版解不出 `%TEMP%`(→ 起不来);即使装上了,Low 标签的应用文件也会让
* Chromium 的 AppContainer 子进程读不到(0x80000003 秒崩)。
*
* 要点:**只有交付物自身的标签要紧**。归档内部的载荷标签不会被还原
* (装到正常位置得到的是默认 Medium 文件),所以打包完成后再统一修正即可 ——
* 反过来说,不能在打包前把 appOutDir 改成 Medium:那样 7za(自身 Low)
* 会因"不能向上读/写"而无法生成归档。
*/
function normalizeIntegrityLabel(dir) {
if (process.platform !== 'win32') return;
const run = (args) => execFileSync('icacls', args, { stdio: 'pipe', windowsHide: true });
try {
run([dir, '/setintegritylevel', 'Medium', '/T', '/C']);
// 目录自身恢复为"继承父目录的 Low",保证下次构建时 Low 的 7za 仍能写入归档
run([dir, '/setintegritylevel', '(OI)(CI)Low']);
console.log('[dist] 已修正交付物完整性标签为 Medium,目录恢复继承:', dir);
} catch (error) {
console.warn('[dist] 完整性标签修正跳过:', error.message);
}
}
child.on('exit', (code) => { child.on('exit', (code) => {
if (code === 0) { if (code === 0) {
const output = path.join(root, 'release'); const output = path.join(root, 'release');
normalizeIntegrityLabel(output);
console.log('\n[dist] 打包完成,产物目录:', output); console.log('\n[dist] 打包完成,产物目录:', output);
} }
process.exit(code ?? 1); process.exit(code ?? 1);
@@ -169,6 +169,10 @@ function launchSmoke(extraEnv) {
ELECTRON_SMOKE_PROFILE: profileDir, ELECTRON_SMOKE_PROFILE: profileDir,
ELECTRON_SMOKE_CLASS_CODE: classCredentials?.code ?? '', ELECTRON_SMOKE_CLASS_CODE: classCredentials?.code ?? '',
ELECTRON_SMOKE_CLASS_PASSWORD: classCredentials?.password ?? '', ELECTRON_SMOKE_CLASS_PASSWORD: classCredentials?.password ?? '',
// 教师凭据只从这里传入:主进程的冒烟代码从环境变量读,
// 因此安装包(app.asar)里不会留下教师口令字面量(本脚本不进安装包)
ELECTRON_SMOKE_USER: process.env.ELECTRON_SMOKE_USER ?? 'teacher1',
ELECTRON_SMOKE_PASSWORD: process.env.ELECTRON_SMOKE_PASSWORD ?? 'teacher123',
...extraEnv, ...extraEnv,
}), }),
}); });
+433 -40
View File
@@ -5,9 +5,12 @@ import {
ISLAND_SHADOW_PAD, ISLAND_SHADOW_PAD,
ISLAND_SIZE_DELTA, ISLAND_SIZE_DELTA,
ISLAND_SLIVER_WIDTH, ISLAND_SLIVER_WIDTH,
PRIORITY_RANK,
islandListLayout,
type IslandAppearance, type IslandAppearance,
PRIORITY_LABELS, PRIORITY_LABELS,
formatDate, formatDate,
type IslandListLayout,
type IslandNotification, type IslandNotification,
type IslandNotificationKind, type IslandNotificationKind,
type IslandState, type IslandState,
@@ -39,9 +42,19 @@ const state = ref<IslandState>({
inClass: false, inClass: false,
currentPeriodEnd: null, currentPeriodEnd: null,
reason: null, reason: null,
listExpanded: false,
maxCardHeight: 1024,
updatedAt: 0, updatedAt: 0,
}); });
/**
* 渲染状态直接来自主进程(**与仓库版一致,不再有"收回"快照层**)。
*
* 早先这里有一层 `closing`/`closingSnapshot`:点"知道了 / 标为已读"后把卡片按"胶囊摘要"收回再淡出。
* 那套是自研的形变状态机,实测在触摸屏(窗口贴合岛体、形变时要动窗口)上会露出旧帧/重影,
* 用户明确要求"动画就用仓库里那套"—— 于是整段删掉:收起一律走主进程的 `hide()`(窗口淡出),
* 展开/收缩仍是弹簧形变(仓库机制,见 targetSize/progress)。
*/
const bridge = window.island; const bridge = window.island;
const notification = computed<IslandNotification | null>(() => state.value.active); const notification = computed<IslandNotification | null>(() => state.value.active);
@@ -52,6 +65,48 @@ const isCall = computed(() => kind.value === 'call');
const isHomework = computed(() => kind.value === 'homework'); const isHomework = computed(() => kind.value === 'homework');
const queueCount = computed(() => state.value.queued.length); const queueCount = computed(() => state.value.queued.length);
/**
* 这一批**未处理**的消息(正在展示的 + 队列里的),按「重要程度 → 时间」排序。
* 与主进程 `pendingNotifications()` 同一口径(同一份 `PRIORITY_RANK`)。
*/
const pendingNotifications = computed<IslandNotification[]>(() => {
const list: IslandNotification[] = [];
if (state.value.active) list.push(state.value.active);
for (const item of state.value.queued) {
if (!list.some((existing) => existing.id === item.id)) list.push(item);
}
return list.sort((a, b) => {
const rank = (PRIORITY_RANK[b.priority] ?? 0) - (PRIORITY_RANK[a.priority] ?? 0);
if (rank !== 0) return rank;
return String(b.createdAt ?? '').localeCompare(String(a.createdAt ?? ''));
});
});
const pendingCount = computed(() => pendingNotifications.value.length);
/**
* 多条消息时的**列表布局**:显示几条、要不要"展开更多"、卡片多高。
* 与主进程用同一个 `islandListLayout`(同一份度量)—— 主进程据此把窗口长高,两边必须算出一个数。
*/
const listLayout = computed<IslandListLayout | null>(() => {
if (mode.value !== 'expanded' || pendingCount.value < 2) return null;
return islandListLayout({
count: pendingCount.value,
fontSize: appearance.value.fontSize,
maxHeight: state.value.maxCardHeight,
expanded: state.value.listExpanded,
});
});
const isListMode = computed(() => listLayout.value !== null);
/** 列表里实际渲染出来的通知 */
const listItems = computed<IslandNotification[]>(() =>
listLayout.value ? pendingNotifications.value.slice(0, listLayout.value.rows) : [],
);
/** 没能展示出来的条数(点"展开更多"能看到一部分,剩下的只能去应用里看) */
const hiddenCount = computed(() => Math.max(0, pendingCount.value - listItems.value.length));
const listHint = computed<IslandListLayout['hint']>(() => listLayout.value?.hint ?? null);
/** 胶囊标题:按消息类型区分(新消息 / 新作业 / 叫人) */ /** 胶囊标题:按消息类型区分(新消息 / 新作业 / 叫人) */
const pillTitle = computed(() => { const pillTitle = computed(() => {
if (isCall.value) return '老师叫你'; if (isCall.value) return '老师叫你';
@@ -72,23 +127,12 @@ const TYPE_LABELS: Record<IslandNotificationKind, string> = {
/** 汇总展示顺序:叫人 > 作业 > 通知(与用户示例一致) */ /** 汇总展示顺序:叫人 > 作业 > 通知(与用户示例一致) */
const TYPE_ORDER: IslandNotificationKind[] = ['call', 'homework', 'notification']; const TYPE_ORDER: IslandNotificationKind[] = ['call', 'homework', 'notification'];
const pendingNotifications = computed<IslandNotification[]>(() => {
const list: IslandNotification[] = [];
if (state.value.active) list.push(state.value.active);
for (const item of state.value.queued) {
if (!list.some((existing) => existing.id === item.id)) list.push(item);
}
return list;
});
/** 这批未处理消息覆盖了哪些类型(按"叫人/作业/通知"顺序) */ /** 这批未处理消息覆盖了哪些类型(按"叫人/作业/通知"顺序) */
const pendingTypes = computed<string[]>(() => { const pendingTypes = computed<string[]>(() => {
const kinds = new Set(pendingNotifications.value.map((item) => item.kind ?? 'notification')); const kinds = new Set(pendingNotifications.value.map((item) => item.kind ?? 'notification'));
return TYPE_ORDER.filter((item) => kinds.has(item)).map((item) => TYPE_LABELS[item]); return TYPE_ORDER.filter((item) => kinds.has(item)).map((item) => TYPE_LABELS[item]);
}); });
const pendingCount = computed(() => pendingNotifications.value.length);
/** 多条消息时把类型摊开:`新消息:叫人/作业/通知(共 3 条)` */ /** 多条消息时把类型摊开:`新消息:叫人/作业/通知(共 3 条)` */
const pillSummaryTitle = computed(() => { const pillSummaryTitle = computed(() => {
if (pendingCount.value <= 1) return pillTitle.value; if (pendingCount.value <= 1) return pillTitle.value;
@@ -122,6 +166,45 @@ const subtitle = computed(() => {
/** 叫人消息下方的附加说明(例如"请到办公室找我") */ /** 叫人消息下方的附加说明(例如"请到办公室找我") */
const callHint = computed(() => notification.value?.subtitle ?? ''); const callHint = computed(() => notification.value?.subtitle ?? '');
/**
* 是否显示「标为已读」。
*
* 作业卡片的 id 是本地合成的 `homework-<作业id>`(见 renderer/island/bridge.ts),
* 库里并没有这条通知,点它会让通知中心去调 `POST /notifications/homework-xxx/read` 并弹「通知不存在」。
* 因此作业卡不提供该按钮(它本来也不是"通知",用「知道了」收起即可)。
* 列表形态下只要**至少有一条真通知**就提供(作业行会被主进程按 kind 过滤掉)。
*/
const canMarkRead = computed(() => {
if (isListMode.value) {
return pendingNotifications.value.some((item) => item.kind !== 'homework');
}
return notification.value?.kind !== 'homework';
});
/** 列表里单行的类型(徽标/图标配色) */
function rowKind(item: IslandNotification): IslandNotificationKind {
return item.kind ?? 'notification';
}
function rowBadgeText(item: IslandNotification): string {
const itemKind = rowKind(item);
if (itemKind === 'call') return '叫人';
if (itemKind === 'homework') return '新作业';
return PRIORITY_LABELS[item.priority] ?? item.priority;
}
function rowBadgeClass(item: IslandNotification): string {
const itemKind = rowKind(item);
if (itemKind === 'call') return 'badge-call';
if (itemKind === 'homework') return 'badge-homework';
return `badge-${item.priority.toLowerCase()}`;
}
function rowSubText(item: IslandNotification): string {
const teacher = item.teacherName ? `${item.teacherName} · ` : '';
return `${teacher}${formatDate(item.createdAt, true)}`;
}
/** 下课补发时提示"其实上课期间就到了" */ /** 下课补发时提示"其实上课期间就到了" */
const showAfterClassHint = computed(() => state.value.reason === 'after-class' && !state.value.inClass); const showAfterClassHint = computed(() => state.value.reason === 'after-class' && !state.value.inClass);
@@ -150,10 +233,20 @@ function onCardClick(event: MouseEvent): void {
} }
function dismiss(): void { function dismiss(): void {
bridge?.sendAction('dismiss'); // 多条消息时"知道了"是**整批**处理:卡片上就一排按钮,点它就是把这批都放下去
bridge?.sendAction(isListMode.value ? 'dismiss-all' : 'dismiss');
}
/** "展开更多":把列表铺到屏幕放得下的程度(主进程负责把窗口长高) */
function expandList(): void {
bridge?.sendAction('expand-list');
} }
function markRead(): void { function markRead(): void {
if (isListMode.value) {
bridge?.sendAction('mark-all-read');
return;
}
if (notification.value) bridge?.sendAction('mark-read', notification.value.id); if (notification.value) bridge?.sendAction('mark-read', notification.value.id);
} }
@@ -184,6 +277,9 @@ function targetSize(): { width: number; height: number } {
return { width: ISLAND_SLIVER_WIDTH, height: Math.max(12, Math.min(28, height - 22)) }; return { width: ISLAND_SLIVER_WIDTH, height: Math.max(12, Math.min(28, height - 22)) };
} }
if (mode.value !== 'expanded') return { width, height }; if (mode.value !== 'expanded') return { width, height };
// 多条消息的列表:高度由共享的列表布局算出(与主进程算的窗口包围盒同一个数)
const layout = listLayout.value;
if (layout) return { width: width + EXTRA.expanded.width, height: layout.height };
const extra = isCall.value ? EXTRA.call : isUrgent.value ? EXTRA.urgent : EXTRA.expanded; const extra = isCall.value ? EXTRA.call : isUrgent.value ? EXTRA.urgent : EXTRA.expanded;
return { width: width + extra.width, height: height + extra.height }; return { width: width + extra.width, height: height + extra.height };
} }
@@ -324,6 +420,12 @@ const expandedAlpha = computed(() => progress.value * progress.value);
* 岛在**固定窗口**内的定位(照搬 WinIsland:窗口不动,岛在画布内居中/贴边形变)。 * 岛在**固定窗口**内的定位(照搬 WinIsland:窗口不动,岛在画布内居中/贴边形变)。
* 水平:居中锚点用 `left: 50% + translateX(-50%)`;左/右锚点贴边(留阴影余量)。 * 水平:居中锚点用 `left: 50% + translateX(-50%)`;左/右锚点贴边(留阴影余量)。
*/ */
/** 水平锚点(供 CSS 决定胶囊内容贴哪条边:左贴左、右贴右、居中则居中对齐) */
const anchorName = computed<'left' | 'center' | 'right'>(() => {
const position = appearance.value.position;
return position.endsWith('left') ? 'left' : position.endsWith('right') ? 'right' : 'center';
});
const islandStyle = computed(() => { const islandStyle = computed(() => {
const position = appearance.value.position; const position = appearance.value.position;
const style: Record<string, string> = { const style: Record<string, string> = {
@@ -484,6 +586,18 @@ function applyAppearance(next: IslandAppearance | null | undefined): void {
onMounted(async () => { onMounted(async () => {
window.addEventListener('mousemove', (event) => updateInteractive(event.clientX, event.clientY)); window.addEventListener('mousemove', (event) => updateInteractive(event.clientX, event.clientY));
/**
* 触摸屏上报:主进程据此把窗口改为**贴合岛体**并始终接收输入。
*
* 为什么必须报:触摸屏上"点不开"是机制性的 —— 打开命中的两条链路(本进程的 mousemove 转发、
* 主进程读系统光标)都以"鼠标指针移动"为前提,而手指触摸既不产生 mousemove、也不移动系统光标,
* 窗口会永远停在 `setIgnoreMouseEvents(true)` 的穿透态,手指点下去只落到桌面。
* Chromium 在带触摸数字化仪的机器上会把 `maxTouchPoints` 置为非 0,用它当判据。
*/
const reportTouchMode = (): void => bridge?.setTouchMode?.(true);
if ((navigator.maxTouchPoints ?? 0) > 0) reportTouchMode();
// 兜底:个别设备 maxTouchPoints 判定不到(或接的是外接触摸屏),真收到触摸事件时再补报一次
window.addEventListener('touchstart', reportTouchMode, { passive: true, once: true });
// 心跳:主进程据此判断本渲染进程是否还活着。一旦卡死/崩溃,主进程会隐藏这扇"幽灵窗口" // 心跳:主进程据此判断本渲染进程是否还活着。一旦卡死/崩溃,主进程会隐藏这扇"幽灵窗口"
// 并重建(否则 Windows 会把最后一帧留在屏幕上:岛看着还在,怎么点都没反应)。 // 并重建(否则 Windows 会把最后一帧留在屏幕上:岛看着还在,怎么点都没反应)。
bridge?.alive?.(); bridge?.alive?.();
@@ -516,6 +630,7 @@ onMounted(async () => {
<div <div
class="island-card" class="island-card"
:class="islandClass" :class="islandClass"
:data-anchor="anchorName"
:data-style="appearance.style" :data-style="appearance.style"
:style="islandStyle" :style="islandStyle"
@click="mode === 'expanded' ? onCardClick($event) : expand()" @click="mode === 'expanded' ? onCardClick($event) : expand()"
@@ -540,6 +655,12 @@ onMounted(async () => {
<!-- 胶囊层(WinIsland compact):进度 > 2/3 时完全退净 --> <!-- 胶囊层(WinIsland compact):进度 > 2/3 时完全退净 -->
<span class="layer pill-layer" :style="{ opacity: pillAlpha }"> <span class="layer pill-layer" :style="{ opacity: pillAlpha }">
<!--
胶囊内容固定成"胶囊自己的几何"(宽 = 外观宽度、贴合停靠边/中线):
卡片在开合时会变宽变窄,若让内容跟着卡片宽度走,文字会先按宽卡片铺开、
再随卡片变窄被省略号收回(用户反馈的"新消息那行字往右跳一下再缩回")。
-->
<span class="pill-inner">
<span class="pill-icon" :class="{ urgent: isUrgent, call: isCall, homework: isHomework }"> <span class="pill-icon" :class="{ urgent: isUrgent, call: isCall, homework: isHomework }">
<svg v-if="isHomework" viewBox="0 0 24 24" aria-hidden="true"> <svg v-if="isHomework" viewBox="0 0 24 24" aria-hidden="true">
<path <path
@@ -571,23 +692,31 @@ onMounted(async () => {
<span v-if="pendingCount > 1 && pendingTypes.length > 1" class="pill-types" aria-hidden="true"> <span v-if="pendingCount > 1 && pendingTypes.length > 1" class="pill-types" aria-hidden="true">
<span v-for="item in pendingTypes" :key="item" class="pill-type">{{ item }}</span> <span v-for="item in pendingTypes" :key="item" class="pill-type">{{ item }}</span>
</span> </span>
<span class="pill-chevron" aria-hidden="true"> <span class="pill-chevron" aria-hidden="true">
<svg viewBox="0 0 24 24"> <svg viewBox="0 0 24 24">
<path <path
fill="none" fill="none"
stroke="currentColor" stroke="currentColor"
stroke-width="2.6" stroke-width="2.6"
stroke-linecap="round" stroke-linecap="round"
d="m9 6 6 6-6 6" d="m9 6 6 6-6 6"
/> />
</svg> </svg>
</span>
</span> </span>
</span> </span>
<!-- 展开层(WinIsland expanded):进度²淡入 --> <!-- 展开层(WinIsland expanded):进度²淡入 -->
<span class="layer expanded-layer" :style="{ opacity: expandedAlpha }"> <span
class="layer expanded-layer"
:class="{ 'list-mode': isListMode }"
:style="{ opacity: expandedAlpha }"
>
<header class="head"> <header class="head">
<span class="head-icon" :class="{ urgent: isUrgent, call: isCall, homework: isHomework }"> <span
class="head-icon"
:class="{ urgent: isUrgent, call: isCall, homework: isHomework, list: isListMode }"
>
<svg v-if="isHomework" viewBox="0 0 24 24" aria-hidden="true"> <svg v-if="isHomework" viewBox="0 0 24 24" aria-hidden="true">
<path <path
fill="currentColor" fill="currentColor"
@@ -608,11 +737,19 @@ onMounted(async () => {
</svg> </svg>
</span> </span>
<div class="head-meta"> <div class="head-meta">
<span class="badge" :class="badgeClass">{{ badgeText }}</span> <span class="badge" :class="isListMode ? 'badge-normal' : badgeClass">
<span v-if="isCall" class="live-dot call">老师正在等你</span> {{ isListMode ? `共 ${pendingCount} 条` : badgeText }}
<span v-else-if="isUrgent" class="live-dot">需立即查看</span> </span>
<span v-else-if="showAfterClassHint" class="live-dot muted">下课后补发</span> <template v-if="isListMode">
<span class="head-sub">{{ subtitle }}</span> <span v-if="pendingTypes.length > 1" class="head-sub">{{ pendingTypes.join(' / ') }}</span>
<span v-else class="head-sub">按重要程度排列</span>
</template>
<template v-else>
<span v-if="isCall" class="live-dot call">老师正在等你</span>
<span v-else-if="isUrgent" class="live-dot">需立即查看</span>
<span v-else-if="showAfterClassHint" class="live-dot muted">下课后补发</span>
<span class="head-sub">{{ subtitle }}</span>
</template>
</div> </div>
<button type="button" class="icon-btn" title="收起" @click.stop="collapse"> <button type="button" class="icon-btn" title="收起" @click.stop="collapse">
<svg viewBox="0 0 24 24" aria-hidden="true"> <svg viewBox="0 0 24 24" aria-hidden="true">
@@ -627,21 +764,75 @@ onMounted(async () => {
</button> </button>
</header> </header>
<h3 class="title">{{ notification?.title ?? '' }}</h3> <!-- 多条消息:竖向排列,按重要程度排序,默认只显示前三条 -->
<div class="body"> <template v-if="isListMode">
<p class="content-text">{{ notification?.content ?? '' }}</p> <h3 class="title">{{ pendingCount }} 条待处理通知</h3>
<p v-if="callHint" class="call-hint">{{ callHint }}</p> <div class="body list-body">
<p v-else-if="notification?.subtitle" class="call-hint">{{ notification?.subtitle }}</p> <button
</div> v-for="item in listItems"
:key="item.id"
type="button"
class="list-row"
:title="`打开应用查看:${item.title}`"
@click.stop="openApp"
>
<span class="row-icon" :class="rowKind(item)">
<svg v-if="rowKind(item) === 'homework'" viewBox="0 0 24 24" aria-hidden="true">
<path
fill="currentColor"
d="M6 3h9a3 3 0 0 1 3 3v13.5a.5.5 0 0 1-.75.43L15 18.5l-2.25 1.43a.5.5 0 0 1-.53 0L10 18.5l-2.25 1.43a.5.5 0 0 1-.53 0L5 18.5V5a2 2 0 0 1 1-2Zm2 4v1.6h7V7H8Zm0 3.4V12h7v-1.6H8Z"
/>
</svg>
<svg v-else-if="rowKind(item) === 'call'" viewBox="0 0 24 24" aria-hidden="true">
<path
fill="currentColor"
d="M4 10v4a1 1 0 0 0 1 1h2l4 3.5a1 1 0 0 0 1.65-.76V5.26A1 1 0 0 0 11 4.5L7 8H5a1 1 0 0 0-1 1Zm12.5-2.9a1 1 0 0 1 1.4.1 8 8 0 0 1 0 9.6 1 1 0 1 1-1.5-1.3 6 6 0 0 0 0-7 1 1 0 0 1 .1-1.4Z"
/>
</svg>
<svg v-else viewBox="0 0 24 24" aria-hidden="true">
<path
fill="currentColor"
d="M12 2a6 6 0 0 0-6 6v3.1L4.6 14a1 1 0 0 0 .9 1.5h13a1 1 0 0 0 .9-1.5L18 11.1V8a6 6 0 0 0-6-6Zm0 20a3 3 0 0 0 3-2.6H9A3 3 0 0 0 12 22Z"
/>
</svg>
</span>
<span class="row-text">
<span class="row-title">{{ item.title }}</span>
<span class="row-sub">{{ rowSubText(item) }}</span>
</span>
<span class="row-badge" :class="rowBadgeClass(item)">{{ rowBadgeText(item) }}</span>
</button>
<!-- 还有没显示出来的:能展开就"展开更多",屏幕到任务栏了就只能去应用里看 -->
<div v-if="listHint" class="list-hint">
<button v-if="listHint === 'more'" type="button" class="more-btn" @click.stop="expandList">
展开更多(还有 {{ hiddenCount }} 条)
</button>
<span v-else class="more-app">更多请前往应用内操作</span>
</div>
</div>
</template>
<template v-else>
<h3 class="title">{{ notification?.title ?? '' }}</h3>
<div class="body">
<p class="content-text">{{ notification?.content ?? '' }}</p>
<p v-if="callHint" class="call-hint">{{ callHint }}</p>
<p v-else-if="notification?.subtitle" class="call-hint">{{ notification?.subtitle }}</p>
</div>
</template>
<!-- 一排按钮(多条消息时也是这一排):展开态的操作都收在这里 -->
<footer class="foot"> <footer class="foot">
<span v-if="queueCount > 0" class="more">还有 {{ queueCount }} 条通知</span> <span v-if="isListMode" class="more">共 {{ pendingCount }} 条待处理</span>
<span v-else-if="queueCount > 0" class="more">还有 {{ queueCount }} 条通知</span>
<span v-else class="more muted">来自班级小助手</span> <span v-else class="more muted">来自班级小助手</span>
<span class="actions"> <span class="actions">
<button type="button" class="ghost-btn" @click.stop="openApp">打开应用</button> <button type="button" class="ghost-btn" @click.stop="openApp">打开应用</button>
<button type="button" class="ghost-btn" @click.stop="markRead">标为已读</button> <button v-if="canMarkRead" type="button" class="ghost-btn" @click.stop="markRead">
标为已读
</button>
<button type="button" class="solid-btn" @click.stop="dismiss"> <button type="button" class="solid-btn" @click.stop="dismiss">
{{ isCall ? '收到' : '知道了' }} {{ isCall && !isListMode ? '收到' : '知道了' }}
</button> </button>
</span> </span>
</footer> </footer>
@@ -743,6 +934,16 @@ body {
fill: var(--wn-bg); fill: var(--wn-bg);
stroke: var(--wn-border); stroke: var(--wn-border);
stroke-width: 1; stroke-width: 1;
/*
投影**始终声明**,形态切换只改参数 —— 不要写成"只在 .expanded 上挂 filter"。
给元素加 / 去 CSS filter 会让 Chromium 新建或销毁它的渲染表面(effect node),
而首帧的合成可能发生在新表面栅格化完成之前,那一帧会被当作空内容画出去;
卡片的底色恰恰就画在这个被过滤的元素上(fill 在本元素),于是**开/合的那一瞬间
底座会闪掉一帧、只剩未过滤的文字层**(用户反馈的"开合时一瞬间的闪动")。
胶囊态用 0 0 0:硬轮廓投影正好压在路径底下,肉眼等同无投影,与 WinIsland
"只有展开态有投影"的观感一致。
*/
filter: drop-shadow(0 var(--card-shadow-y, 0px) var(--card-shadow-blur, 0px) rgba(0, 0, 0, 0.11));
} }
/* 内容层裁切到同一形状内;内部两层(胶囊层 / 展开层)交叉淡入 */ /* 内容层裁切到同一形状内;内部两层(胶囊层 / 展开层)交叉淡入 */
@@ -767,9 +968,11 @@ body {
pointer-events: auto; pointer-events: auto;
} }
/* 展开态投影(WinIsland: rgba(0,0,0,.11)、y+2、σ=3 → CSS 0 2px 3px) */ /* 展开态投影(WinIsland: rgba(0,0,0,.11)、y+2、σ=3 → CSS 0 2px 3px)。
只改参数、不动 filter 声明本身,理由见上面的 .shape path。 */
.island-card.expanded .shape path { .island-card.expanded .shape path {
filter: drop-shadow(0 2px 3px rgba(0, 0, 0, 0.11)); --card-shadow-y: 2px;
--card-shadow-blur: 3px;
} }
/* 状态色:只做"内层微染 + 描边",不外溢(保持桌面干净,也不会有光晕硬边) */ /* 状态色:只做"内层微染 + 描边",不外溢(保持桌面干净,也不会有光晕硬边) */
@@ -809,10 +1012,40 @@ body {
.pill-layer { .pill-layer {
flex-direction: row; flex-direction: row;
align-items: center; align-items: center;
/* 水平对齐交给 .pill-inner(它固定为胶囊几何,且按停靠方式贴边/居中) */
justify-content: flex-start;
}
/**
* 胶囊内容盒:**固定为胶囊自己的宽高与内边距**,不随卡片形变重排。
*
* 为什么必须固定:卡片在开合时 268 ⇄ 424 变宽变窄,而中心停靠下卡片的左右边都会动。
* 内容若跟着卡片宽度走,就会出现"文字先按宽卡片铺开、再随卡片收窄被省略号收回"
* (用户反馈的"新消息那行字往右跳一下再缩回"),底部也会被收缩的形状裁掉一块。
* 固定成胶囊几何后:文字在整段动画里位置与省略号都不变,只是随卡片一起淡出/淡入。
*
* 贴哪条边与卡片停靠方式一致(左停靠贴左、右停靠贴右、居中则居中对齐)——
* 这样卡片变宽时内容也不会横移,静止态外观与之前完全一致。
*/
.pill-inner {
display: inline-flex;
flex-direction: row;
align-items: center;
flex: 0 0 auto;
gap: calc(var(--island-font, 13px) * 0.62); gap: calc(var(--island-font, 13px) * 0.62);
width: var(--island-w, 268px);
height: 100%;
padding: 0 calc(var(--island-font, 13px) * 0.78); padding: 0 calc(var(--island-font, 13px) * 0.78);
} }
.island-card[data-anchor='center'] .pill-layer {
justify-content: center;
}
.island-card[data-anchor='right'] .pill-layer {
justify-content: flex-end;
}
.pill-icon { .pill-icon {
display: inline-flex; display: inline-flex;
align-items: center; align-items: center;
@@ -912,6 +1145,166 @@ body {
justify-content: center; justify-content: center;
} }
/*
* 多条通知的列表形态。
*
* 这里的每个尺寸都必须与 @classhelper/shared 的 `ISLAND_LIST_METRICS` 一一对应:
* 主进程按那份度量算出**窗口包围盒**(列表比普通展开卡高,窗口不够高会把底部按钮裁掉),
* 渲染进程按同一份度量排布。改这里就必须改那里,否则会出现"最后一行被切掉"。
* 选择器一律写成 `.expanded-layer.list-mode ...`(比基类的单类选择器更具体),
* 免得被后面定义的 `.title` / `.body` 覆盖掉尺寸——那样高度就对不上算出来的值了。
*/
.expanded-layer.list-mode {
/* 高度已经算准,改 flex-start:居中排版一旦有像素级误差会把上下两端同时切掉 */
justify-content: flex-start;
}
.expanded-layer.list-mode .head {
height: calc(var(--island-font, 13px) * 1.7);
}
.expanded-layer.list-mode .title {
flex: 0 0 auto;
display: block;
height: calc(var(--island-font, 13px) * 1.4);
line-height: 1.4;
-webkit-line-clamp: unset;
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis;
}
.expanded-layer.list-mode .body {
flex: 1 1 auto;
min-height: 0;
gap: calc(var(--island-font, 13px) * 0.4);
justify-content: flex-start;
overflow: hidden;
}
.head-icon.list {
background: color-mix(in srgb, var(--island-accent) 20%, transparent);
color: var(--island-accent);
}
.list-row {
display: flex;
align-items: center;
gap: calc(var(--island-font, 13px) * 0.55);
flex: 0 0 auto;
width: 100%;
height: calc(var(--island-font, 13px) * 2.7);
padding: 0 calc(var(--island-font, 13px) * 0.6);
border: none;
border-radius: calc(var(--island-font, 13px) * 0.5);
background: rgba(255, 255, 255, 0.045);
color: var(--wn-text-1);
text-align: left;
cursor: pointer;
transition: background 0.15s ease;
}
.list-row:hover {
background: var(--wn-surface);
}
.row-icon {
display: inline-flex;
align-items: center;
justify-content: center;
flex: 0 0 auto;
width: calc(var(--island-font, 13px) * 1.3);
height: calc(var(--island-font, 13px) * 1.3);
border-radius: calc(var(--island-font, 13px) * 0.36);
background: var(--wn-surface);
color: var(--wn-text-2);
}
.row-icon svg {
width: calc(var(--island-font, 13px) * 0.86);
height: calc(var(--island-font, 13px) * 0.86);
}
.row-icon.call {
color: #ff9f0a;
}
.row-icon.homework {
color: var(--island-accent);
}
.row-text {
display: flex;
flex-direction: column;
justify-content: center;
gap: 1px;
min-width: 0;
flex: 1 1 auto;
}
.row-title {
font-size: calc(var(--island-font, 13px) * 0.9);
font-weight: 600;
line-height: 1.2;
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis;
}
.row-sub {
font-size: calc(var(--island-font, 13px) * 0.68);
line-height: 1.1;
color: var(--wn-text-3);
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis;
}
.row-badge {
display: inline-flex;
align-items: center;
flex: 0 0 auto;
height: calc(var(--island-font, 13px) * 1.25);
padding: 0 calc(var(--island-font, 13px) * 0.5);
border-radius: 999px;
font-size: calc(var(--island-font, 13px) * 0.68);
font-weight: 600;
background: rgba(255, 255, 255, 0.12);
color: rgba(255, 255, 255, 0.78);
}
/* 列表底部的提示行:能展开时是按钮,屏幕到任务栏了就是一句"去应用里看" */
.list-hint {
display: flex;
align-items: center;
justify-content: center;
flex: 0 0 auto;
height: calc(var(--island-font, 13px) * 2.1);
}
.more-btn {
border: none;
background: var(--wn-surface);
color: var(--wn-text-1);
height: 100%;
width: 100%;
border-radius: calc(var(--island-font, 13px) * 0.5);
font-size: calc(var(--island-font, 13px) * 0.76);
font-weight: 600;
cursor: pointer;
transition: background 0.15s ease;
}
.more-btn:hover {
background: var(--wn-surface-hover);
}
.more-app {
font-size: calc(var(--island-font, 13px) * 0.76);
color: var(--wn-text-3);
white-space: nowrap;
}
.head { .head {
display: flex; display: flex;
align-items: center; align-items: center;
+205 -18
View File
@@ -12,6 +12,7 @@ import {
type ClassIslandNotificationChannel, type ClassIslandNotificationChannel,
type IslandAppearance, type IslandAppearance,
} from '@classhelper/shared'; } from '@classhelper/shared';
import { logger } from './logger.js';
import type { DesktopStoredConfig, HomeworkBoardSettings } from '../types/desktop.js'; import type { DesktopStoredConfig, HomeworkBoardSettings } from '../types/desktop.js';
/** 作业页展示偏好默认值(看板 + 不显示时间 + 15px) */ /** 作业页展示偏好默认值(看板 + 不显示时间 + 15px) */
@@ -35,6 +36,14 @@ interface PersistedConfig {
notificationChannel?: ClassIslandNotificationChannel; notificationChannel?: ClassIslandNotificationChannel;
/** 作业录入快捷短语(向后兼容:旧配置没有该字段时用默认那一组) */ /** 作业录入快捷短语(向后兼容:旧配置没有该字段时用默认那一组) */
homeworkPhrases?: string[]; homeworkPhrases?: string[];
/** 是否已看过初次启动引导(向后兼容:旧配置没有该字段视为没看过,首启弹一次) */
onboardingDone?: boolean;
/** 界面主题(向后兼容:旧配置没有该字段用浅色) */
theme?: 'light' | 'dark';
/** 主侧边栏是否折叠(向后兼容:旧配置没有该字段视为展开) */
sidebarCollapsed?: boolean;
/** 用户选择「忽略此版本」的版本号(向后兼容:旧配置没有该字段视为没忽略过任何版本) */
ignoredUpdateVersion?: string;
} }
const DEFAULT_CONFIG: PersistedConfig = { const DEFAULT_CONFIG: PersistedConfig = {
@@ -46,8 +55,17 @@ const DEFAULT_CONFIG: PersistedConfig = {
homeworkBoard: { ...DEFAULT_HOMEWORK_BOARD }, homeworkBoard: { ...DEFAULT_HOMEWORK_BOARD },
notificationChannel: DEFAULT_CLASSISLAND_NOTIFICATION_CHANNEL, notificationChannel: DEFAULT_CLASSISLAND_NOTIFICATION_CHANNEL,
homeworkPhrases: [...HOMEWORK_PHRASE_DEFAULTS], homeworkPhrases: [...HOMEWORK_PHRASE_DEFAULTS],
onboardingDone: false,
theme: 'light',
sidebarCollapsed: false,
ignoredUpdateVersion: '',
}; };
/** 主题白名单:非法值一律回落浅色 */
function normalizeTheme(input?: 'light' | 'dark'): 'light' | 'dark' {
return input === 'dark' ? 'dark' : 'light';
}
/** /**
* 作业快捷短语的合法化:去空白、去重、限长限量。 * 作业快捷短语的合法化:去空白、去重、限长限量。
* 空数组是**合法值**(老师把短语全删了 = 不想用快捷短语),因此不能拿默认值顶回去。 * 空数组是**合法值**(老师把短语全删了 = 不想用快捷短语),因此不能拿默认值顶回去。
@@ -142,8 +160,15 @@ function encryptToken(token: string | null): { token: string | null; tokenEncryp
return { token: safeStorage.encryptString(token).toString('base64'), tokenEncrypted: true }; return { token: safeStorage.encryptString(token).toString('base64'), tokenEncrypted: true };
} }
} catch { } catch {
// 某些环境下 DPAPI 不可用,降级为明文存储(仅本地开发场景) // 见下方降级分支
} }
// 降级为明文存储(DPAPI 不可用,一般只在本地开发环境出现)。
// 必须留下日志:明文 token 代表该班的全班身份,任何能读用户目录的进程/备份/同步盘都能拿到,
// 静默降级会让"为什么换个环境就得重新登录/凭据是怎么泄露的"无从查起。
logger.warn(
`系统加密存储不可用,登录令牌将以**明文**写入配置(${configFilePath()});` +
'如需加密请确认 Windows 凭据保护(DPAPI)可用',
);
return { token, tokenEncrypted: false }; return { token, tokenEncrypted: false };
} }
@@ -157,14 +182,14 @@ function decryptToken(raw: PersistedConfig): string | null {
} }
} }
function readPersisted(): PersistedConfig { function readPersistedFromDisk(): PersistedConfig {
try { try {
const content = fs.readFileSync(configFilePath(), 'utf8'); const content = fs.readFileSync(configFilePath(), 'utf8');
const parsed = JSON.parse(content) as Partial<PersistedConfig>; const parsed = JSON.parse(content) as Partial<PersistedConfig>;
return { return {
serverUrl: serverUrl:
typeof parsed.serverUrl === 'string' && parsed.serverUrl typeof parsed.serverUrl === 'string' && parsed.serverUrl
? parsed.serverUrl ? (normalizeServerUrl(parsed.serverUrl) ?? DEFAULT_CONFIG.serverUrl)
: DEFAULT_CONFIG.serverUrl, : DEFAULT_CONFIG.serverUrl,
username: typeof parsed.username === 'string' ? parsed.username : '', username: typeof parsed.username === 'string' ? parsed.username : '',
token: typeof parsed.token === 'string' ? parsed.token : null, token: typeof parsed.token === 'string' ? parsed.token : null,
@@ -173,38 +198,181 @@ function readPersisted(): PersistedConfig {
homeworkBoard: normalizeHomeworkBoard(parsed.homeworkBoard), homeworkBoard: normalizeHomeworkBoard(parsed.homeworkBoard),
notificationChannel: normalizeNotificationChannel(parsed.notificationChannel), notificationChannel: normalizeNotificationChannel(parsed.notificationChannel),
homeworkPhrases: normalizeHomeworkPhrases(parsed.homeworkPhrases), homeworkPhrases: normalizeHomeworkPhrases(parsed.homeworkPhrases),
onboardingDone: parsed.onboardingDone === true,
theme: normalizeTheme(parsed.theme),
sidebarCollapsed: parsed.sidebarCollapsed === true,
ignoredUpdateVersion:
typeof parsed.ignoredUpdateVersion === 'string' ? parsed.ignoredUpdateVersion : '',
}; };
} catch { } catch {
return { ...DEFAULT_CONFIG }; return { ...DEFAULT_CONFIG };
} }
} }
function writePersisted(config: PersistedConfig): void { /* ------------------------------------------------------------ 内存缓存 + 异步合并写
const target = configFilePath(); *
fs.mkdirSync(path.dirname(target), { recursive: true }); * 为什么不能每次 saveConfig 都同步读写盘(原来的写法):
fs.writeFileSync(target, JSON.stringify(config, null, 2), 'utf8'); * 侧栏折叠(`stores/ui.ts` 的 toggleSidebar)、主题切换、通知渠道、作业看板偏好、登录/登出
* 全都走 `saveConfig`,而它一次调用要做「readFileSync + JSON.parse + 8 个 normalize」**两遍**
* (开头读一遍、结尾 `getConfig()` 又读一遍)+ `writeFileSync` 一遍 + DPAPI 解密一遍,
* **全部同步跑在主进程主线程上**。主进程是 Electron 的消息泵进程,被它摁住的那一拍
* 渲染进程也跟着掉帧 —— 用户反馈的"点汉堡展开/收回侧栏时卡一下"就是这一拍。
*
* 现在:配置常驻内存(连已解密的 token 一起缓存),写盘改成**异步 + 合并** ——
* 同一拍内的多次改动只落最后一次,写入串行不会互相覆盖;退出前由 `flushConfigSync()` 兜底。
*
* **语义变化(有意为之)**:`saveConfig()` 返回时数据可能还没落盘(延迟 CONFIG_WRITE_DEBOUNCE_MS)。
* 正常退出(托盘 → 退出)会走 `flushConfigSync()`,不会丢最后一次改动;只有进程被强杀
* 才可能丢这最后 120ms 内的改动。
*/
/** 写入合并窗口:拖动同类控件(滑块/连续点击)时的连续改动只落最后一次 */
const CONFIG_WRITE_DEBOUNCE_MS = 120;
interface ConfigCache {
config: PersistedConfig;
/** 已解密的登录令牌(null = 未登录 / 解密失败)。缓存它是为了不再每次都走一遍 DPAPI */
token: string | null;
} }
/** 读取配置(token 已解密),供渲染进程使用 */ /**
export function getConfig(): DesktopStoredConfig { * 内存配置。**必须懒初始化**:`main/index.ts` 会先 `app.setPath('userData', smokeProfile)`
const persisted = readPersisted(); * 把配置目录指到冒烟专用 profile,之后才第一次读配置;在模块顶层立即读盘会读错文件。
*/
let cache: ConfigCache | null = null;
function loadCache(): ConfigCache {
if (cache) return cache;
const config = readPersistedFromDisk();
cache = { config, token: decryptToken(config) };
return cache;
}
/** 待写入的配置快照(合并窗口内只保留最后一次) */
let pendingWrite: PersistedConfig | null = null;
let writeTimer: ReturnType<typeof setTimeout> | null = null;
/** 是否有一次异步写入正在进行(用它把写入串行化,避免两次写互相覆盖) */
let writing = false;
/** 排一次落盘。合并窗口内的多次调用只会写最后一次;`immediate` 用于不该被延迟的场景 */
function scheduleWrite(config: PersistedConfig, immediate = false): void {
pendingWrite = config;
if (immediate) {
if (writeTimer !== null) {
clearTimeout(writeTimer);
writeTimer = null;
}
void flushConfigAsync();
return;
}
// 已有待写任务(定时器在跑或正在写):内容已经记在 pendingWrite 里,等它自己收尾即可。
// 正在写的那次结束后会再检查一次 pendingWrite(见 flushConfigAsync 的 finally)。
if (writeTimer !== null || writing) return;
writeTimer = setTimeout(() => {
writeTimer = null;
void flushConfigAsync();
}, CONFIG_WRITE_DEBOUNCE_MS);
}
/** 异步落盘(不阻塞主进程消息泵)。失败只记日志 —— 与 readPersistedFromDisk 的容错口径一致 */
async function flushConfigAsync(): Promise<void> {
if (writing) return;
const target = pendingWrite;
if (!target) return;
pendingWrite = null;
writing = true;
// 先把内容序列化下来:写入期间的后续改动由 pendingWrite 负责补一次,
// 不会出现"这一次写的是半新半旧的对象"
const payload = JSON.stringify(target, null, 2);
try {
const file = configFilePath();
await fs.promises.mkdir(path.dirname(file), { recursive: true });
await fs.promises.writeFile(file, payload, 'utf8');
} catch (error) {
logger.warn(`写入配置失败(${configFilePath()}):${error instanceof Error ? error.message : error}`);
} finally {
writing = false;
// 写入期间又有改动:再写一次(内容已被 pendingWrite 合并成最后一次)
if (pendingWrite) void flushConfigAsync();
}
}
/**
* 退出前同步落地一次(`main/index.ts` 的 shutdownResources 调用)。
*
* 即使没有待写内容也把内存里的配置重写一遍:那一时刻可能正有一次异步写在进行中,
* 它未必来得及完成;退出时多写一次的代价可以忽略。
*/
export function flushConfigSync(): void {
if (writeTimer !== null) {
clearTimeout(writeTimer);
writeTimer = null;
}
const target = pendingWrite ?? cache?.config ?? null;
if (!target) return;
pendingWrite = null;
try {
const file = configFilePath();
fs.mkdirSync(path.dirname(file), { recursive: true });
fs.writeFileSync(file, JSON.stringify(target, null, 2), 'utf8');
} catch (error) {
logger.warn(
`退出前写入配置失败(${configFilePath()}):${error instanceof Error ? error.message : error}`,
);
}
}
/**
* 服务器地址只接受 http/https 绝对地址。
*
* 渲染进程的输入框走 `normalizeServerUrl` 校验过,但 IPC(`saveConfig`)与手工改过的
* config.json 都会绕过它,而该值随后会作为 axios baseURL 与 Socket.IO 地址使用 ——
* 因此必须在**主进程这一侧也收口**,非法值一律丢弃(保留原值)。
*/
function normalizeServerUrl(input: string): string | null {
const trimmed = input.trim().replace(/\/+$/, '');
if (!trimmed) return null;
try {
const url = new URL(trimmed);
if (url.protocol !== 'http:' && url.protocol !== 'https:') return null;
return trimmed;
} catch {
return null;
}
}
/** 由内存缓存组装对渲染进程暴露的配置(不再读盘、不再解密) */
function toDesktopConfig(state: ConfigCache): DesktopStoredConfig {
const persisted = state.config;
return { return {
serverUrl: persisted.serverUrl, serverUrl: persisted.serverUrl,
username: persisted.username, username: persisted.username,
token: decryptToken(persisted), token: state.token,
island: normalizeIslandAppearance(persisted.island), island: normalizeIslandAppearance(persisted.island),
homeworkBoard: normalizeHomeworkBoard(persisted.homeworkBoard), homeworkBoard: normalizeHomeworkBoard(persisted.homeworkBoard),
notificationChannel: normalizeNotificationChannel(persisted.notificationChannel), notificationChannel: normalizeNotificationChannel(persisted.notificationChannel),
homeworkPhrases: normalizeHomeworkPhrases(persisted.homeworkPhrases), homeworkPhrases: normalizeHomeworkPhrases(persisted.homeworkPhrases),
onboardingDone: persisted.onboardingDone === true,
theme: normalizeTheme(persisted.theme),
sidebarCollapsed: persisted.sidebarCollapsed === true,
ignoredUpdateVersion: persisted.ignoredUpdateVersion ?? '',
}; };
} }
/** 读取配置(token 已解密),供渲染进程使用 */
export function getConfig(): DesktopStoredConfig {
return toDesktopConfig(loadCache());
}
/** 局部更新配置:只覆盖传入的字段 */ /** 局部更新配置:只覆盖传入的字段 */
export function saveConfig(patch: Partial<DesktopStoredConfig>): DesktopStoredConfig { export function saveConfig(patch: Partial<DesktopStoredConfig>): DesktopStoredConfig {
const persisted = readPersisted(); const state = loadCache();
const persisted = state.config;
if (typeof patch.serverUrl === 'string' && patch.serverUrl.trim()) { if (typeof patch.serverUrl === 'string' && patch.serverUrl.trim()) {
persisted.serverUrl = patch.serverUrl.trim().replace(/\/+$/, ''); const normalized = normalizeServerUrl(patch.serverUrl);
if (normalized) persisted.serverUrl = normalized;
else logger.warn(`忽略非法的服务器地址(只接受 http/https):${patch.serverUrl}`);
} }
if (typeof patch.username === 'string') { if (typeof patch.username === 'string') {
persisted.username = patch.username; persisted.username = patch.username;
@@ -224,20 +392,39 @@ export function saveConfig(patch: Partial<DesktopStoredConfig>): DesktopStoredCo
if (patch.notificationChannel !== undefined) { if (patch.notificationChannel !== undefined) {
persisted.notificationChannel = normalizeNotificationChannel(patch.notificationChannel); persisted.notificationChannel = normalizeNotificationChannel(patch.notificationChannel);
} }
// 引导只接受"已看过":重看入口不走这里(看过与否只有 true 与"没看过"两种状态,
// 想 re-arm 只能清配置 clearConfig)。传 false 一律忽略,避免任何调用点误把用户退回首启状态。
if (patch.onboardingDone === true) {
persisted.onboardingDone = true;
}
if (patch.theme !== undefined) {
persisted.theme = normalizeTheme(patch.theme);
}
if (patch.sidebarCollapsed !== undefined) {
persisted.sidebarCollapsed = patch.sidebarCollapsed === true;
}
// 空串是合法值(= 没有忽略任何版本),因此这里只判类型不判空
if (typeof patch.ignoredUpdateVersion === 'string') {
persisted.ignoredUpdateVersion = patch.ignoredUpdateVersion;
}
if (patch.token !== undefined) { if (patch.token !== undefined) {
const encrypted = encryptToken(patch.token); const encrypted = encryptToken(patch.token);
persisted.token = encrypted.token; persisted.token = encrypted.token;
persisted.tokenEncrypted = encrypted.tokenEncrypted; persisted.tokenEncrypted = encrypted.tokenEncrypted;
// 明文一并进缓存:既省掉一次 DPAPI 解密,也保证紧接着的 getConfig() 读到的就是刚存的令牌
state.token = patch.token;
} }
writePersisted(persisted); scheduleWrite(persisted);
return getConfig(); return toDesktopConfig(state);
} }
/** 清空为默认配置(退出登录 / 重置) */ /** 清空为默认配置(退出登录 / 重置)。立即落盘:它对应退出登录,不该被合并窗口延迟 */
export function clearConfig(): DesktopStoredConfig { export function clearConfig(): DesktopStoredConfig {
writePersisted({ ...DEFAULT_CONFIG }); const state: ConfigCache = { config: { ...DEFAULT_CONFIG }, token: null };
return getConfig(); cache = state;
scheduleWrite(state.config, true);
return toDesktopConfig(state);
} }
export function getConfigPath(): string { export function getConfigPath(): string {
+53 -10
View File
@@ -1,10 +1,13 @@
import path from 'node:path'; import path from 'node:path';
import { pathToFileURL } from 'node:url';
import { BrowserWindow, app, shell } from 'electron'; import { BrowserWindow, app, shell } from 'electron';
import { flushConfigSync, getConfig } from './config.js';
import { registerIpcHandlers } from './ipc.js'; import { registerIpcHandlers } from './ipc.js';
import { island, registerIslandIpc } from './island.js'; import { island, registerIslandIpc } from './island.js';
import { logger } from './logger.js'; import { logger } from './logger.js';
import { runSmokeTest } from './smoke.js'; import { runSmokeTest } from './smoke.js';
import { createTray, destroyTray, isTrayReady } from './tray.js'; import { createTray, destroyTray, isTrayReady } from './tray.js';
import { scheduleStartupUpdateCheck } from './update.js';
// 主进程由 esbuild 打包为 CommonJS,因此这里可以直接使用 __dirname // 主进程由 esbuild 打包为 CommonJS,因此这里可以直接使用 __dirname
// (dist/main/index.js -> dist/preload/index.js 与 dist/renderer/index.html) // (dist/main/index.js -> dist/preload/index.js 与 dist/renderer/index.html)
@@ -23,17 +26,45 @@ let mainWindow: BrowserWindow | null = null;
/** 是否正在退出:用于区分「关闭窗口 = 隐藏到托盘」与「真正退出」 */ /** 是否正在退出:用于区分「关闭窗口 = 隐藏到托盘」与「真正退出」 */
let isQuitting = false; let isQuitting = false;
/** 生产环境下主窗口加载的本页地址(用于导航白名单的精确比对) */
const prodRendererUrl = pathToFileURL(path.join(currentDir, '../renderer/index.html')).href;
/**
* 是否允许窗口导航到这个地址。
*
* 为什么不能用 `url.startsWith(...)`:
* - 开发态 `url.startsWith(devServerUrl)` 没有主机边界,`http://localhost:5174.evil.com` 也会被放行;
* - 生产态 `url.startsWith('file://')` 等于放行**任意本地页面**。
* 而 preload 是挂在窗口上的(不是挂在 URL 上):一旦窗口被导航到别处,那个页面照样持有
* `window.desktop`(含 `getConfig` 返回的明文 token)。因此这里按"精确同源 / 精确同一文件"比对。
*/
function isAllowedNavigation(url: string): boolean {
try {
const target = new URL(url);
if (devServerUrl) return target.origin === new URL(devServerUrl).origin;
target.hash = '';
target.search = '';
return target.href === prodRendererUrl;
} catch {
return false;
}
}
function createWindow(): BrowserWindow { function createWindow(): BrowserWindow {
// 启动底色跟主题走:深色主题下若仍用浅色底,窗口先白后黑会"闪一下"
const theme = getConfig().theme;
const win = new BrowserWindow({ const win = new BrowserWindow({
width: 1200, // 初始尺寸与 ClassIsland 主窗口对齐(实测其可视区 1242x582),保持同一观感
height: 800, width: 1242,
minWidth: 980, height: 582,
minHeight: 640, minWidth: 1000,
minHeight: 540,
center: true,
title: '班级小助手', title: '班级小助手',
// 冒烟验证时不弹窗,避免打扰使用者 // 冒烟验证时不弹窗,避免打扰使用者
show: !isSmokeTest, show: !isSmokeTest,
autoHideMenuBar: true, autoHideMenuBar: true,
backgroundColor: '#f5f7fa', backgroundColor: theme === 'dark' ? '#161719' : '#f3f3f3',
webPreferences: { webPreferences: {
preload: path.join(currentDir, '../preload/index.js'), preload: path.join(currentDir, '../preload/index.js'),
contextIsolation: true, contextIsolation: true,
@@ -49,11 +80,10 @@ function createWindow(): BrowserWindow {
return { action: 'deny' }; return { action: 'deny' };
}); });
win.webContents.on('will-navigate', (event, url) => { win.webContents.on('will-navigate', (event, url) => {
const allowed = devServerUrl ? url.startsWith(devServerUrl) : url.startsWith('file://'); if (isAllowedNavigation(url)) return;
if (!allowed) { event.preventDefault();
event.preventDefault(); if (/^https?:\/\//i.test(url)) void shell.openExternal(url);
if (/^https?:\/\//i.test(url)) void shell.openExternal(url); logger.warn(`主窗口拒绝了页面导航:${url}`);
}
}); });
win.on('closed', () => { win.on('closed', () => {
@@ -106,6 +136,11 @@ if (!gotLock) {
if (!mainWindow || mainWindow.isDestroyed()) return; if (!mainWindow || mainWindow.isDestroyed()) return;
mainWindow.webContents.send('island:mark-read', id); mainWindow.webContents.send('island:mark-read', id);
}); });
// 多条通知时的"标为已读"是**整批**操作:一次把列表里的通知都标上
island.setMarkAllReadHandler((ids) => {
if (!mainWindow || mainWindow.isDestroyed()) return;
mainWindow.webContents.send('island:mark-all-read', ids);
});
} catch (error) { } catch (error) {
logger.error('灵动岛初始化失败(不影响主功能)', error); logger.error('灵动岛初始化失败(不影响主功能)', error);
} }
@@ -129,6 +164,9 @@ if (!gotLock) {
logger.warn(`系统托盘初始化失败(不影响主功能):${error instanceof Error ? error.message : error}`); logger.warn(`系统托盘初始化失败(不影响主功能):${error instanceof Error ? error.message : error}`);
} }
// 启动后自动查一次更新(延迟几秒,不跟首屏抢带宽);冒烟模式下自动跳过,见 main/update.ts
scheduleStartupUpdateCheck(() => mainWindow);
if (isSmokeTest) { if (isSmokeTest) {
try { try {
await runSmokeTest(mainWindow); await runSmokeTest(mainWindow);
@@ -156,6 +194,11 @@ if (!gotLock) {
*/ */
function shutdownResources(): string { function shutdownResources(): string {
const done: string[] = []; const done: string[] = [];
// 配置是**异步合并写**的(见 main/config.ts):退出前必须同步落地一次,
// 否则"刚改完设置就退出"这一类操作会丢掉最后一次改动。
// 放在最前面:后面会销毁窗口与灵动岛,先落盘不依赖任何窗口是否还在。
flushConfigSync();
done.push('配置已落盘');
if (isTrayReady()) { if (isTrayReady()) {
destroyTray(); destroyTray();
done.push('托盘已销毁'); done.push('托盘已销毁');
+20
View File
@@ -1,5 +1,7 @@
import { app, ipcMain, shell } from 'electron'; import { app, ipcMain, shell } from 'electron';
import type { UpdateInfo } from '@classhelper/shared';
import { clearConfig, getConfig, getConfigPath, saveConfig } from './config.js'; import { clearConfig, getConfig, getConfigPath, saveConfig } from './config.js';
import { checkForUpdates, ignoreUpdateVersion } from './update.js';
import type { DesktopAppInfo, DesktopStoredConfig } from '../types/desktop.js'; import type { DesktopAppInfo, DesktopStoredConfig } from '../types/desktop.js';
/** IPC 通道名集中管理,preload 与主进程共用同一份字符串 */ /** IPC 通道名集中管理,preload 与主进程共用同一份字符串 */
@@ -9,6 +11,8 @@ export const IPC_CHANNELS = {
clearConfig: 'classhelper:config:clear', clearConfig: 'classhelper:config:clear',
appInfo: 'classhelper:app:info', appInfo: 'classhelper:app:info',
openExternal: 'classhelper:shell:open-external', openExternal: 'classhelper:shell:open-external',
updateCheck: 'classhelper:update:check',
updateIgnore: 'classhelper:update:ignore',
} as const; } as const;
export function registerIpcHandlers(): void { export function registerIpcHandlers(): void {
@@ -30,6 +34,7 @@ export function registerIpcHandlers(): void {
node: process.versions.node ?? '', node: process.versions.node ?? '',
platform: `${process.platform} ${process.arch}`, platform: `${process.platform} ${process.arch}`,
userDataPath: app.getPath('userData'), userDataPath: app.getPath('userData'),
configPath: getConfigPath(),
smokeTest: process.env.ELECTRON_SMOKE_TEST === '1', smokeTest: process.env.ELECTRON_SMOKE_TEST === '1',
})); }));
@@ -38,6 +43,21 @@ export function registerIpcHandlers(): void {
await shell.openExternal(url); await shell.openExternal(url);
return true; return true;
}); });
/**
* 检查更新(走主进程直连 GitHub,见 main/update.ts 的说明)。
*
* `force` 为 true 时绕过主进程缓存 —— 对应「关于」页里用户主动点的那次检查;
* 启动自动检查一律用缓存(避免同一分钟内重复请求打满匿名限流)。
*/
ipcMain.handle(IPC_CHANNELS.updateCheck, (_event, force?: boolean): Promise<UpdateInfo> => {
return checkForUpdates(force === true);
});
/** 忽略某个版本的更新提示(记入 config.json,启动自动检查不再提示它) */
ipcMain.handle(IPC_CHANNELS.updateIgnore, (_event, version: string): void => {
if (typeof version === 'string') ignoreUpdateVersion(version);
});
} }
export function getDiagnostics(): { configPath: string; config: DesktopStoredConfig } { export function getDiagnostics(): { configPath: string; config: DesktopStoredConfig } {
+457 -55
View File
@@ -1,4 +1,5 @@
import path from 'node:path'; import path from 'node:path';
import { pathToFileURL } from 'node:url';
import { BrowserWindow, ipcMain, screen } from 'electron'; import { BrowserWindow, ipcMain, screen } from 'electron';
import { import {
DEFAULT_ISLAND_APPEARANCE, DEFAULT_ISLAND_APPEARANCE,
@@ -7,7 +8,10 @@ import {
ISLAND_SIZE_DELTA, ISLAND_SIZE_DELTA,
ISLAND_SLIVER_WIDTH, ISLAND_SLIVER_WIDTH,
ISLAND_STYLES, ISLAND_STYLES,
PRIORITY_RANK,
islandListLayout,
type IslandAppearance, type IslandAppearance,
type IslandListLayout,
type IslandMode, type IslandMode,
type IslandNotification, type IslandNotification,
type IslandState, type IslandState,
@@ -15,6 +19,26 @@ import {
import { logger } from './logger.js'; import { logger } from './logger.js';
import { getConfig } from './config.js'; import { getConfig } from './config.js';
/** 生产环境的灵动岛页面地址(导航白名单的精确比对用) */
const prodIslandUrl = pathToFileURL(path.join(__dirname, '../renderer/island.html')).href;
/**
* 是否允许灵动岛窗口导航到这个地址。
* 与主窗口同一套理由:preload 挂在窗口上而不是 URL 上,被导航走就等于把 `window.desktop`
* 交给了一个陌生页面;而灵动岛还是置顶窗口,陌生页面会停在屏幕最上层。
*/
function isAllowedIslandNavigation(url: string, devUrl: string | null): boolean {
try {
const target = new URL(url);
if (devUrl) return target.origin === new URL(devUrl).origin;
target.hash = '';
target.search = '';
return target.href === prodIslandUrl;
} catch {
return false;
}
}
/** /**
* 灵动岛(Dynamic Island)主进程控制器。 * 灵动岛(Dynamic Island)主进程控制器。
* *
@@ -102,7 +126,18 @@ export interface IslandClassStatePayload {
week?: number; week?: number;
} }
type IslandActionName = 'expand' | 'collapse' | 'dismiss' | 'mark-read' | 'open-app'; type IslandActionName =
| 'expand'
| 'collapse'
/** 多条通知时点"展开更多":把列表铺到屏幕放得下的程度 */
| 'expand-list'
| 'dismiss'
/** 多条通知时点"知道了":整批关闭,但不改通知中心的已读状态 */
| 'dismiss-all'
| 'mark-read'
/** 多条通知时点"标为已读":整批已读并关闭 */
| 'mark-all-read'
| 'open-app';
interface IslandActionPayload { interface IslandActionPayload {
action: IslandActionName; action: IslandActionName;
@@ -127,12 +162,35 @@ class IslandController {
/** 是否允许"失焦自动收起"(冒烟可临时关闭,避免焦点抖动干扰断言) */ /** 是否允许"失焦自动收起"(冒烟可临时关闭,避免焦点抖动干扰断言) */
private blurCollapseEnabled = true; private blurCollapseEnabled = true;
private interactive = false; private interactive = false;
/**
* 触摸模式:触摸屏机器上由渲染进程按 `navigator.maxTouchPoints` 上报(见 `setTouchMode`)。
*
* 为什么触摸屏必须单独一套:触摸屏上"点不动"是**机制性**的,不是偶发 —— 打开命中的两条链路
* (渲染进程的 mousemove 转发、主进程读系统光标位置)都以"鼠标指针移动"为前提,而手指触摸
* 既不产生 mousemove、也不移动系统光标。于是窗口永远停在 `setIgnoreMouseEvents(true)` 的
* 穿透态,手指点下去只落到桌面(用户反馈:希沃白板上触摸灵动岛无法展开)。
*
* 修法只有一条:**窗口在触摸点处必须可命中**。Electron 没有 SetWindowRgn 那种"窗口区域"能力,
* 所以改成在触摸模式下让窗口**贴合岛体**(岛体 + 阴影留白)并始终接收输入 —— 贴身后多出来的
* 只有投影所需的 10px 留白,不再吞掉桌面点击。
*/
private touchMode = false;
/** 渲染进程上报的岛体矩形(窗口内 CSS px):主进程据此做光标命中兜底轮询 */ /** 渲染进程上报的岛体矩形(窗口内 CSS px):主进程据此做光标命中兜底轮询 */
private hitRect: { x: number; y: number; width: number; height: number } | null = null; private hitRect: { x: number; y: number; width: number; height: number } | null = null;
/** 光标命中兜底轮询定时器(见 syncHitFromCursor 注释) */ /** 光标命中兜底轮询定时器(见 syncHitFromCursor 注释) */
private hitTimer: ReturnType<typeof setInterval> | null = null; private hitTimer: ReturnType<typeof setInterval> | null = null;
/** 诊断/冒烟用:覆盖光标位置(屏幕坐标),null 表示使用真实光标 */ /** 诊断/冒烟用:覆盖光标位置(屏幕坐标),null 表示使用真实光标 */
private cursorOverride: { x: number; y: number } | null = null; private cursorOverride: { x: number; y: number } | null = null;
/**
* 冒烟/诊断用:让窗口**不接收真实鼠标**(真实点击穿透到桌面)。
*
* 为什么需要:自动化验证时长分钟计,而岛上那套命中逻辑是按"真实光标位置"开的 ——
* 若此时用户正在用同一块屏幕(他自己的客户端和冒烟窗口都在屏幕顶部居中、互相叠着),
* 他点到的是**冒烟这个窗口**,冒烟就会收到人的点击(实测:冒烟从未发出的 collapse / mark-read
* 混进了断言,把「点胶囊展开」「点空白处收起」等用例整片弄红)。
* 打开后所有命中请求一律按"穿透"处理;合成 DOM 点击(executeJavaScript)不受影响。
*/
private testInputPassthrough = false;
/** 上次按矩形立即校正命中的时刻(限流用) */ /** 上次按矩形立即校正命中的时刻(限流用) */
private lastHitSyncAt = 0; private lastHitSyncAt = 0;
/** 设置页"预览效果"的示例通知 id(预览期间失焦不收起) */ /** 设置页"预览效果"的示例通知 id(预览期间失焦不收起) */
@@ -147,7 +205,10 @@ class IslandController {
private recovering = false; private recovering = false;
/** 最近的窗口重建时刻(限流用) */ /** 最近的窗口重建时刻(限流用) */
private recoverAt: number[] = []; private recoverAt: number[] = [];
/** 上一次计算锚点所依据的显示器 id:用于发现"光标换屏 / 显示器插拔"并重排窗口 */
private anchorDisplayId: number | null = null;
/** 展开卡可用高度上限(CSS px):由工作区/停靠位置算出,随状态下发给渲染进程 */
private maxCardHeight = 1024;
private state: IslandState = { private state: IslandState = {
mode: 'hidden', mode: 'hidden',
active: null, active: null,
@@ -155,6 +216,8 @@ class IslandController {
inClass: false, inClass: false,
currentPeriodEnd: null, currentPeriodEnd: null,
reason: null, reason: null,
listExpanded: false,
maxCardHeight: 1024,
updatedAt: Date.now(), updatedAt: Date.now(),
}; };
@@ -164,6 +227,9 @@ class IslandController {
/** 灵动岛点"标为已读"时交给外部(主窗口渲染进程)同步通知中心 */ /** 灵动岛点"标为已读"时交给外部(主窗口渲染进程)同步通知中心 */
private markReadHandler: ((id: string) => void) | null = null; private markReadHandler: ((id: string) => void) | null = null;
/** 灵动岛一次"标为已读"要标记的多条通知(多条列表时的整批已读) */
private markAllReadHandler: ((ids: string[]) => void) | null = null;
setOpenAppHandler(handler: () => void): void { setOpenAppHandler(handler: () => void): void {
this.openAppHandler = handler; this.openAppHandler = handler;
} }
@@ -172,6 +238,10 @@ class IslandController {
this.markReadHandler = handler; this.markReadHandler = handler;
} }
setMarkAllReadHandler(handler: (ids: string[]) => void): void {
this.markAllReadHandler = handler;
}
async init(rendererUrl: string | null): Promise<void> { async init(rendererUrl: string | null): Promise<void> {
this.rendererUrl = rendererUrl; this.rendererUrl = rendererUrl;
// 恢复用户保存的个性化外观(尺寸/位置/透明度/动画…),失败则用默认值 // 恢复用户保存的个性化外观(尺寸/位置/透明度/动画…),失败则用默认值
@@ -181,6 +251,7 @@ class IslandController {
this.appearance = { ...DEFAULT_ISLAND_APPEARANCE }; this.appearance = { ...DEFAULT_ISLAND_APPEARANCE };
} }
recomputeSizes(this.appearance); recomputeSizes(this.appearance);
this.refreshViewport();
if (this.win && !this.win.isDestroyed()) return; if (this.win && !this.win.isDestroyed()) return;
const win = new BrowserWindow({ const win = new BrowserWindow({
@@ -219,6 +290,13 @@ class IslandController {
win.setAlwaysOnTop(this.appearance.alwaysOnTop, 'screen-saver'); win.setAlwaysOnTop(this.appearance.alwaysOnTop, 'screen-saver');
win.setVisibleOnAllWorkspaces(true, { visibleOnFullScreen: true }); win.setVisibleOnAllWorkspaces(true, { visibleOnFullScreen: true });
// 拒绝一切导航与新开窗口(理由见 isAllowedIslandNavigation)
win.webContents.setWindowOpenHandler(() => ({ action: 'deny' }));
win.webContents.on('will-navigate', (event, url) => {
if (isAllowedIslandNavigation(url, this.rendererUrl)) return;
event.preventDefault();
logger.warn(`灵动岛拒绝了页面导航:${url}`);
});
// 注意:这里**不能**调用 `win.setBackgroundMaterial()`(亚克力/mica), // 注意:这里**不能**调用 `win.setBackgroundMaterial()`(亚克力/mica),
// 见 `applyBackgroundMaterial` 移除处的说明。 // 见 `applyBackgroundMaterial` 移除处的说明。
// 默认整块窗口不接收鼠标(避免大面积透明窗口吞掉桌面点击), // 默认整块窗口不接收鼠标(避免大面积透明窗口吞掉桌面点击),
@@ -254,7 +332,10 @@ class IslandController {
); );
return; return;
} }
if (sinceActivated < BLUR_GRACE_MS) { // 触摸屏上没有"指针"可依据(isCursorOnIsland 恒为 false),只能用更宽的宽限期覆盖
// 上面实测到的 70~520ms 抖动区间,否则手指点开后约 0.5s 会莫名缩回胶囊。
const grace = this.touchMode ? BLUR_GRACE_TOUCH_MS : BLUR_GRACE_MS;
if (sinceActivated < grace) {
logger.info(`灵动岛:忽略激活后 ${sinceActivated}ms 内的失焦(宽限期内不收起)`); logger.info(`灵动岛:忽略激活后 ${sinceActivated}ms 内的失焦(宽限期内不收起)`);
return; return;
} }
@@ -360,13 +441,10 @@ class IslandController {
): IslandNotification { ): IslandNotification {
if (!existing || existing.id !== incoming.id) return incoming; if (!existing || existing.id !== incoming.id) return incoming;
const kind = existing.kind === 'call' || incoming.kind === 'call' ? 'call' : incoming.kind; const kind = existing.kind === 'call' || incoming.kind === 'call' ? 'call' : incoming.kind;
const rank: Record<IslandNotification['priority'], number> = { const priority =
LOW: 0, (PRIORITY_RANK[incoming.priority] ?? 0) >= (PRIORITY_RANK[existing.priority] ?? 0)
NORMAL: 1, ? incoming.priority
HIGH: 2, : existing.priority;
URGENT: 3,
};
const priority = rank[incoming.priority] >= rank[existing.priority] ? incoming.priority : existing.priority;
return { ...incoming, kind, priority }; return { ...incoming, kind, priority };
} }
@@ -376,6 +454,61 @@ class IslandController {
return this.state.queued.find((item) => item.id === id) ?? null; return this.state.queued.find((item) => item.id === id) ?? null;
} }
/**
* 当前**未处理**的消息(正在展示的 + 队列里的),按「重要程度 → 时间」倒序。
*
* 排序口径与共享常量 `PRIORITY_RANK` 一致:紧急 > 重要 > 普通 > 低,同级按时间新的在前。
* 用户在展开卡里看到的就是这个顺序("默认按重要程度排列")。
*/
private pendingNotifications(): IslandNotification[] {
const merged: IslandNotification[] = [];
if (this.state.active) merged.push(this.state.active);
for (const item of this.state.queued) {
if (!merged.some((existing) => existing.id === item.id)) merged.push(item);
}
return merged.sort((a, b) => {
const rank = (PRIORITY_RANK[b.priority] ?? 0) - (PRIORITY_RANK[a.priority] ?? 0);
if (rank !== 0) return rank;
return String(b.createdAt ?? '').localeCompare(String(a.createdAt ?? ''));
});
}
/**
* 多条通知时的列表布局(几条、要不要"展开更多"、卡片多高)。
* 只有展开态且待处理 ≥ 2 条时才有列表形态,单条通知仍然是原来那张详情卡。
*/
private listLayout(): IslandListLayout | null {
if (this.state.mode !== 'expanded') return null;
const count = this.pendingNotifications().length;
if (count < 2) return null;
return islandListLayout({
count,
fontSize: this.appearance.fontSize,
maxHeight: this.maxCardHeight,
expanded: this.state.listExpanded,
});
}
/**
* 展开卡在当前屏幕 / 停靠位置下的可用高度上限:
* 从"岛被锚定的那条边"量到屏幕工作区的另一端(也就是任务栏上方)。
*
* 用锚点 `vValue` 而不是窗口矩形来算:锚点与窗口尺寸无关,因此**列表长高后再算还是同一个数**
* (用窗口矩形会自引用:窗口高度取决于列表高度,列表高度又取决于可用高度)。
*/
private refreshViewport(): void {
const area = this.targetDisplay().workArea;
const anchor = this.resolveAnchor();
const marginY = Math.round(this.appearance.marginY ?? ISLAND_MARGIN);
const available =
anchor.vMode === 'bottom'
? anchor.vValue - (area.y + marginY)
: area.y + area.height - marginY - anchor.vValue;
// 下限兜底:屏幕再小也不能用 0 去算布局(否则连一行都排不出来)
this.maxCardHeight = Math.max(MIN_CARD_HEIGHT, Math.floor(available));
this.state.maxCardHeight = this.maxCardHeight;
}
/** /**
* 收到一条消息。 * 收到一条消息。
* - 紧急(含紧急叫人):立刻展开(无视上课时段) * - 紧急(含紧急叫人):立刻展开(无视上课时段)
@@ -384,6 +517,7 @@ class IslandController {
* - 其它:显示"新消息/新作业/叫人"胶囊,等待点击展开 * - 其它:显示"新消息/新作业/叫人"胶囊,等待点击展开
*/ */
pushNotification(raw: IslandNotification, context: IslandPushContext = {}): void { pushNotification(raw: IslandNotification, context: IslandPushContext = {}): void {
this.state.listExpanded = false;
// 同一 id 的第二条链路(通知/叫人双播):合并而不是覆盖,保住"叫人/紧急"语义 // 同一 id 的第二条链路(通知/叫人双播):合并而不是覆盖,保住"叫人/紧急"语义
const notification = this.mergeNotification(this.findKnownNotification(raw.id), raw); const notification = this.mergeNotification(this.findKnownNotification(raw.id), raw);
const inClass = context.inClass ?? this.state.inClass; const inClass = context.inClass ?? this.state.inClass;
@@ -398,7 +532,7 @@ class IslandController {
this.state.queued = this.state.queued.filter((item) => item.id !== notification.id); this.state.queued = this.state.queued.filter((item) => item.id !== notification.id);
this.state.active = notification; this.state.active = notification;
this.state.updatedAt = Date.now(); this.state.updatedAt = Date.now();
this.setState({ mode: 'expanded' }); this.setState({ mode: 'expanded', listExpanded: false });
this.previewTimer = setTimeout(() => { this.previewTimer = setTimeout(() => {
this.previewTimer = null; this.previewTimer = null;
this.endPreview(notification.id); this.endPreview(notification.id);
@@ -561,7 +695,8 @@ class IslandController {
// 记下这条 id,syncWindow 的上课守卫对它是放行的(否则展开后会被立刻隐藏, // 记下这条 id,syncWindow 的上课守卫对它是放行的(否则展开后会被立刻隐藏,
// 表现为"点不开新作业"——用户反馈的联合通知场景)。 // 表现为"点不开新作业"——用户反馈的联合通知场景)。
this.explicitShowId = this.state.inClass ? active.id : null; this.explicitShowId = this.state.inClass ? active.id : null;
this.setState({ mode: 'expanded' }); // 每次重新点开都从"只显示前三条"开始(上文的 setState 只在离开 expanded 时复位)
this.setState({ mode: 'expanded', listExpanded: false });
this.scheduleCollapse( this.scheduleCollapse(
this.isImmediate(active) this.isImmediate(active)
? active.kind === 'call' ? active.kind === 'call'
@@ -572,6 +707,18 @@ class IslandController {
} }
break; break;
} }
case 'expand-list': {
// 多条通知时点"展开更多":把列表铺到屏幕放得下的程度(窗口跟着长高,见 setState)
if (this.state.mode === 'hidden' || this.state.listExpanded) break;
const layout = this.listLayout();
if (!layout) break;
logger.info(
`灵动岛:展开更多(共 ${this.pendingNotifications().length} 条,显示 ${layout.rows} 条,提示=${layout.hint ?? '无'})`,
);
this.setState({ mode: 'expanded', listExpanded: true });
this.scheduleCollapse(TIMEOUTS.expanded);
break;
}
case 'collapse': case 'collapse':
// 点击卡片空白处 / 右上角收起按钮 / 点击屏幕任意位置:回缩到灵动岛(胶囊) // 点击卡片空白处 / 右上角收起按钮 / 点击屏幕任意位置:回缩到灵动岛(胶囊)
// 上课时段:普通通知彻底隐藏;**叫人 / 紧急消息**回缩为胶囊(保持可见,允许再次展开) // 上课时段:普通通知彻底隐藏;**叫人 / 紧急消息**回缩为胶囊(保持可见,允许再次展开)
@@ -589,6 +736,11 @@ class IslandController {
case 'dismiss': case 'dismiss':
this.dismissActive(); this.dismissActive();
break; break;
case 'dismiss-all':
// 多条通知时点"知道了":整批关闭(通知中心仍是未读,学生回应用里再看)
logger.info(`灵动岛:整批知道了(${this.pendingNotifications().length} 条)`);
this.clearPendingForClose();
break;
case 'mark-read': { case 'mark-read': {
const id = payload.id; const id = payload.id;
const queue = this.state.queued.filter((item) => item.id !== id); const queue = this.state.queued.filter((item) => item.id !== id);
@@ -604,6 +756,18 @@ class IslandController {
} }
break; break;
} }
case 'mark-all-read': {
// 多条通知时点"标为已读":**默认把这一批全部标记已读**再关闭。
// 作业卡的 id 是本地合成的(`homework-<id>`,库里没有这条通知),交给通知中心只会报"通知不存在",
// 因此这里先按 kind 过滤掉,单条模式的 canMarkRead 守卫同理。
const ids = this.pendingNotifications()
.filter((item) => item.kind !== 'homework')
.map((item) => item.id);
logger.info(`灵动岛:整批标为已读(${ids.length} 条)`);
if (ids.length > 0) this.markAllReadHandler?.(ids);
this.clearPendingForClose();
break;
}
case 'open-app': case 'open-app':
this.openAppHandler?.(); this.openAppHandler?.();
break; break;
@@ -676,6 +840,19 @@ class IslandController {
this.hide(); this.hide();
} }
/**
* 整批清空并关闭("知道了 / 标为已读"的多条场景)。
* 状态同步落地(渲染进程随之收起卡片,窗口由 `hide()` 淡出)。
*/
private clearPendingForClose(): void {
this.clearTimers();
this.state.active = null;
this.state.queued = [];
this.state.listExpanded = false;
this.hide();
}
private activate(notification: IslandNotification, reason: IslandState['reason'], mode: IslandMode): void { private activate(notification: IslandNotification, reason: IslandState['reason'], mode: IslandMode): void {
this.clearTimers(); this.clearTimers();
// 正在展示的通知从队列中移出,queue 只保留"尚未看过"的 // 正在展示的通知从队列中移出,queue 只保留"尚未看过"的
@@ -756,9 +933,7 @@ class IslandController {
*/ */
private resolveAnchor(): IslandAnchor { private resolveAnchor(): IslandAnchor {
// 多显示器教室电脑:打开"跟随鼠标屏幕"后,岛出现在鼠标所在的那块屏(讲台切换投影时不用改设置) // 多显示器教室电脑:打开"跟随鼠标屏幕"后,岛出现在鼠标所在的那块屏(讲台切换投影时不用改设置)
const display = this.appearance.followCursorDisplay const display = this.targetDisplay();
? screen.getDisplayNearestPoint(screen.getCursorScreenPoint())
: screen.getPrimaryDisplay();
const area = display.workArea; const area = display.workArea;
const marginX = Math.round(this.appearance.marginX ?? ISLAND_MARGIN); const marginX = Math.round(this.appearance.marginX ?? ISLAND_MARGIN);
const marginY = Math.round(this.appearance.marginY ?? ISLAND_MARGIN); const marginY = Math.round(this.appearance.marginY ?? ISLAND_MARGIN);
@@ -782,9 +957,41 @@ class IslandController {
return { hMode, hValue, vMode, vValue }; return { hMode, hValue, vMode, vValue };
} }
/** 当前应该把岛放在哪块屏上:跟随鼠标时用光标所在屏,否则用主屏 */
private targetDisplay(cursor?: { x: number; y: number } | null): Electron.Display {
return this.appearance.followCursorDisplay
? screen.getDisplayNearestPoint(cursor ?? this.cursorOverride ?? screen.getCursorScreenPoint())
: screen.getPrimaryDisplay();
}
/**
* 锚点所在屏幕变化时重排窗口("跟随鼠标屏幕"、主屏切换、显示器插拔都会走到这里)。
*
* 原先锚点只在 `setAppearance()` 里算一次,于是"跟随鼠标屏幕"实际上**只在改设置的那一瞬间**
* 生效:讲台从投影切回来之后,岛还留在原来那块屏上,直到用户再动一次外观设置。
* 这里挂在已有的 60ms 命中轮询上(不新增定时器),并且只在目标屏幕真的变了、且窗口可见时才动窗口。
*
* 不需要额外监听 `screen` 的 display-* 事件:目标屏是由**当前光标位置**或主屏推出来的,
* 插拔/切主屏之后下一轮 tick 自然会算出不同的 id,一样能触发重排。
*/
private syncAnchorDisplay(cursor?: { x: number; y: number } | null): void {
if (!this.win || this.win.isDestroyed()) return;
const displayId = this.targetDisplay(cursor).id;
if (this.anchorDisplayId === displayId) return;
this.anchorDisplayId = displayId;
// 换屏了:可用高度(工作区)也跟着换,列表"能放几行"要重算
this.refreshViewport();
if (!this.win.isVisible()) return;
this.relayout();
}
/** 状态变更:先通知渲染进程,再驱动窗口尺寸/透明度动画 */ /** 状态变更:先通知渲染进程,再驱动窗口尺寸/透明度动画 */
private setState(patch: Partial<IslandState>, options: { skipWindow?: boolean } = {}): void { private setState(patch: Partial<IslandState>, options: { skipWindow?: boolean } = {}): void {
this.state = { ...this.state, ...patch, updatedAt: Date.now() }; this.state = { ...this.state, ...patch, updatedAt: Date.now() };
// 离开展开态就把"展开更多"复位:下次再点开时默认回到"只显示前三条"
if (this.state.mode !== 'expanded') this.state.listExpanded = false;
// 列表形态比普通展开卡高:窗口要**先**长高,卡片才开始形变,否则底部会被窗口裁掉
if (!options.skipWindow) this.relayout();
this.emit(); this.emit();
if (!options.skipWindow) this.syncWindow(); if (!options.skipWindow) this.syncWindow();
} }
@@ -825,6 +1032,11 @@ class IslandController {
// 展开态才允许获得焦点,这样点击屏幕其他位置会 blur → 自动收起 // 展开态才允许获得焦点,这样点击屏幕其他位置会 blur → 自动收起
this.applyFocusable(); this.applyFocusable();
// 窗口不可见时先把包围盒对齐到当前形态:列表形态留下的"高窗口"在这里收回去。
// 必须挑"不可见"的时刻做 —— 可见时改大小会把正在形变的卡片裁掉一截。
if (!this.win.isVisible()) this.applyWindowLayout();
// 触摸模式:形态变了,窗口要立刻跟着变大(缩小交给岛体矩形上报后判定,避免裁掉形变中的卡片)
this.syncTouchLayout();
if (this.state.mode === 'hidden') { if (this.state.mode === 'hidden') {
// 空闲"细缝"(参考 WinIsland):打开后空闲不再完全隐藏,而是留一条很窄的圆角柱; // 空闲"细缝"(参考 WinIsland):打开后空闲不再完全隐藏,而是留一条很窄的圆角柱;
@@ -857,9 +1069,69 @@ class IslandController {
this.syncHitFromCursor(); this.syncHitFromCursor();
} }
/**
* 窗口包围盒:
* - 普通(鼠标)模式:固定取"最大形态 + 2×阴影留白",**开合过程中一帧都不动**(照搬 WinIsland);
* 唯一的例外是**多条通知的列表**:它比任何普通形态都高,窗口必须当场长高,否则卡片底部
* (那排按钮)会被窗口裁掉。窗口是在卡片开始形变**之前**改的,用户看不到这一步。
* - 触摸模式:贴合当前形态(岛体 + 2×阴影留白),否则大包围盒的透明区会吞掉桌面的触摸。
*/
private windowBox(): { width: number; height: number } {
const size = this.formSize();
if (!this.touchMode) {
return {
width: Math.round(Math.max(BBOX_SIZE.width, size.width + ISLAND_SHADOW_PAD * 2)),
height: Math.round(Math.max(BBOX_SIZE.height, size.height + ISLAND_SHADOW_PAD * 2)),
};
}
return {
width: Math.round(size.width + ISLAND_SHADOW_PAD * 2),
height: Math.round(size.height + ISLAND_SHADOW_PAD * 2),
};
}
/**
* 触摸模式下重排窗口(贴合岛体):
* **变大立刻生效**(否则形变中的卡片会被窗口裁掉一半);**变小要等岛真的收小**——
* 判据是渲染进程上报的真实岛体矩形已经装得下,见 `cardFitsFormSize`。
*/
private syncTouchLayout(): void {
if (!this.touchMode || !this.win || this.win.isDestroyed()) return;
const target = this.windowBox();
const current = this.win.getBounds();
const shrinking = target.width < current.width || target.height < current.height;
/**
* **窗口可见期间只增不减**(触摸模式)。
*
* 为什么:触摸模式下窗口是"贴合岛体"的(手指要能点到岛),所以形态变化时窗口本该跟着变
* —— 但**收小会让出一块区域**,Windows/DWM 在那一瞬间可能还留着上一帧的内容,
* 用户看到的就是"一缩回/一展开就闪一下、像旧画面残留在那里"(反复反馈、逐帧抓过的那一类)。
* 变大属于"只增不减",不会让出任何区域;所以:
* - 需要**变大**就立刻变大(否则形变中的卡片会被窗口裁掉);
* - 需要**变小**一律等窗口隐藏之后再收(`syncWindow` 里"不可见时对齐包围盒",
* 不可见时改尺寸不会有残影),这也顺带修掉"隐藏态改停靠/边距不生效"那条。
*/
if (shrinking && this.win.isVisible()) return;
this.applyWindowLayout();
}
/** 渲染进程上报的岛体是否已经收进"当前形态"的尺寸里(触摸模式下判断能否缩小窗口) */
private cardFitsFormSize(): boolean {
const rect = this.hitRect;
if (!rect) return false;
const size = this.formSize();
return rect.width <= size.width + 1 && rect.height <= size.height + 1;
}
/** 外观 / 锚点变化后的窗口重排:普通模式按固定包围盒重排,触摸模式走贴合逻辑 */
private relayout(): void {
if (this.touchMode) this.syncTouchLayout();
else this.applyWindowLayout();
}
/** /**
* 按当前外观把窗口放到锚点上(**只在尺寸/位置设置变化时调用**,开合时不调用)。 * 按当前外观把窗口放到锚点上(**只在尺寸/位置设置变化时调用**,开合时不调用)。
* 窗口尺寸 = 最大形态 + 2×阴影留白,因此任何形态的岛都能完整容纳。 * 尺寸见 `windowBox`:普通模式恒为"最大形态 + 阴影留白",触摸模式贴合当前形态。
*/ */
private applyWindowLayout(): void { private applyWindowLayout(): void {
if (!this.win || this.win.isDestroyed()) return; if (!this.win || this.win.isDestroyed()) return;
@@ -876,10 +1148,11 @@ class IslandController {
this.win.setBounds(next); this.win.setBounds(next);
} }
/** 固定包围盒窗口的矩形:以锚点定位,尺寸恒为"最大形态 + 阴影留白" */ /** 窗口矩形:以锚点定位(尺寸由 `windowBox` 决定,触摸模式随形态变化) */
private windowBounds(): Bounds { private windowBounds(): Bounds {
const width = Math.round(BBOX_SIZE.width); const box = this.windowBox();
const height = Math.round(BBOX_SIZE.height); const width = box.width;
const height = box.height;
const anchor = this.resolveAnchor(); const anchor = this.resolveAnchor();
// 窗口比岛大 ISLAND_SHADOW_PAD(给投影留白),因此窗口要再偏移一个 pad, // 窗口比岛大 ISLAND_SHADOW_PAD(给投影留白),因此窗口要再偏移一个 pad,
@@ -1005,8 +1278,16 @@ class IslandController {
* 窗口只在尺寸/位置变化时**重排一次**(`applyWindowLayout`),开合过程不碰窗口。 * 窗口只在尺寸/位置变化时**重排一次**(`applyWindowLayout`),开合过程不碰窗口。
*/ */
setAppearance(patch: Partial<IslandAppearance>): void { setAppearance(patch: Partial<IslandAppearance>): void {
this.appearance = normalizeAppearance({ ...this.appearance, ...patch }); // 先丢掉显式 undefined 的键:设置页/冒烟脚本传的都是**部分补丁**,
// 一个残缺字段不该把对应外观重置成默认值(NaN 的兜底在 normalizeAppearance 里)
const clean: Record<string, unknown> = {};
for (const [key, value] of Object.entries(patch ?? {})) {
if (value !== undefined) clean[key] = value;
}
this.appearance = normalizeAppearance({ ...this.appearance, ...clean } as IslandAppearance);
recomputeSizes(this.appearance); recomputeSizes(this.appearance);
// 字号/边距会影响"列表能放几行",可用高度也随停靠位置变化 —— 重算一次并随状态下发
this.refreshViewport();
if (this.win && !this.win.isDestroyed()) { if (this.win && !this.win.isDestroyed()) {
this.win.setAlwaysOnTop(this.appearance.alwaysOnTop, 'screen-saver'); this.win.setAlwaysOnTop(this.appearance.alwaysOnTop, 'screen-saver');
@@ -1017,7 +1298,7 @@ class IslandController {
} }
this.emitAppearance(); this.emitAppearance();
// 包围盒/锚点可能变化:窗口重排一次(**不是逐帧**,开合过程中绝不会再碰窗口) // 包围盒/锚点可能变化:窗口重排一次(**不是逐帧**,开合过程中绝不会再碰窗口)
this.applyWindowLayout(); this.relayout();
// 外观变化后按新尺寸重新同步(隐藏态不显示,不做额外动作) // 外观变化后按新尺寸重新同步(隐藏态不显示,不做额外动作)
if (this.state.mode !== 'hidden') this.syncWindow(); if (this.state.mode !== 'hidden') this.syncWindow();
logger.info( logger.info(
@@ -1039,10 +1320,17 @@ class IslandController {
* "点开了再收起,就再也点不开了"。 * "点开了再收起,就再也点不开了"。
*/ */
setInteractive(interactive: boolean, source = '未知'): void { setInteractive(interactive: boolean, source = '未知'): void {
if (this.interactive === interactive) return; // 触摸模式:窗口已贴合岛体,必须**始终**接收输入。触摸不会产生光标移动,按光标判定命中的
this.interactive = interactive; // 那套逻辑在触摸屏上永远不会打开,一旦让它把命中关掉,手指就再也点不到("点不动")。
// 测试输入穿透:真实鼠标一律不接收(理由见 testInputPassthrough 字段);
// 但**注入光标**(冒烟用 setHitTestCursor 模拟指针在岛上/岛外)照常生效,
// 否则「光标轮询校正命中」「岛外穿透」这类断言全会被自己的开关弄红。
const passthrough = this.testInputPassthrough && this.cursorOverride === null;
const next = passthrough ? false : this.touchMode ? true : interactive;
if (this.interactive === next) return;
this.interactive = next;
logger.info( logger.info(
`灵动岛:鼠标命中=${interactive}(来自${source})mode=${this.state.mode} ` + `灵动岛:鼠标命中=${next}(请求=${interactive},来自${source})mode=${this.state.mode} ` +
`窗口可见=${this.win?.isVisible() ?? false} 岛体矩形=${ `窗口可见=${this.win?.isVisible() ?? false} 岛体矩形=${
this.hitRect ? `${Math.round(this.hitRect.width)}x${Math.round(this.hitRect.height)}` : '无' this.hitRect ? `${Math.round(this.hitRect.width)}x${Math.round(this.hitRect.height)}` : '无'
}`, }`,
@@ -1050,7 +1338,9 @@ class IslandController {
if (!this.win || this.win.isDestroyed()) return; if (!this.win || this.win.isDestroyed()) return;
// forward: true 让窗口在"忽略鼠标"时仍把 mousemove 转发给渲染进程, // forward: true 让窗口在"忽略鼠标"时仍把 mousemove 转发给渲染进程,
// 这样渲染进程才能发现指针进入岛体并重新打开命中。 // 这样渲染进程才能发现指针进入岛体并重新打开命中。
this.win.setIgnoreMouseEvents(!interactive, { forward: true }); // 注意传的是 next 而不是入参:触摸模式下入参可能是 false(按光标判定),
// 直接用它会把窗口又打回穿透态 —— 那正是"手指点不开"的根因。
this.win.setIgnoreMouseEvents(!next, { forward: true });
} }
/** 渲染进程上报的岛体矩形(窗口内 CSS px,坐标系与窗口 DIP 一致) */ /** 渲染进程上报的岛体矩形(窗口内 CSS px,坐标系与窗口 DIP 一致) */
@@ -1062,6 +1352,9 @@ class IslandController {
this.lastHitSyncAt = now; this.lastHitSyncAt = now;
this.syncHitFromCursor(); this.syncHitFromCursor();
} }
// 触摸模式:窗口要一直贴合岛体,而"收小"必须等岛真的收小之后再做(否则形变中的卡片被窗口裁掉)。
// 渲染进程每 ≥50ms 就会上报一次真实几何,正好拿来当这个判据。
this.syncTouchLayout();
} }
/** 当前岛体矩形(供冒烟验证) */ /** 当前岛体矩形(供冒烟验证) */
@@ -1069,6 +1362,42 @@ class IslandController {
return this.hitRect ? { ...this.hitRect } : null; return this.hitRect ? { ...this.hitRect } : null;
} }
/**
* 设置触摸模式(触摸屏机器由渲染进程上报,冒烟也可显式开关)。
*
* 开启后:窗口贴合岛体(见 `windowBox`)且不再穿透(见 `setInteractive`)——
* 这是让"手指按在岛上"能被 Windows 命中到本窗口的唯一办法(详见 `touchMode` 字段的注释)。
* 关闭后回到"固定大包围盒 + 按光标命中"的原行为,因此非触摸屏机器的表现完全不变。
*/
setTouchMode(enabled: boolean): void {
if (this.touchMode === enabled) return;
this.touchMode = enabled;
logger.info(
`灵动岛:触摸模式=${enabled}(窗口${enabled ? '贴合岛体并始终接收输入' : '回到固定包围盒穿透'})`,
);
// 直接重排到目标包围盒:开启时贴合岛体,关闭时回到"最大形态 + 阴影留白"的固定大包围盒
this.applyWindowLayout();
if (enabled) this.setInteractive(true, '触摸模式');
else this.syncHitFromCursor();
}
/** 是否处于触摸模式(供冒烟验证) */
getTouchMode(): boolean {
return this.touchMode;
}
/**
* 开关"测试输入穿透"(冒烟用,见 `testInputPassthrough`):
* 打开后真实鼠标点击穿透到桌面,不会污染自动化断言;关闭后立刻按真实光标位置恢复命中。
*/
setTestInputPassthrough(enabled: boolean): void {
if (this.testInputPassthrough === enabled) return;
this.testInputPassthrough = enabled;
logger.info(`灵动岛:测试输入穿透=${enabled}(供自动化验证不被并行人工操作打扰)`);
if (enabled) this.setInteractive(false, '测试输入穿透');
else this.syncHitFromCursor();
}
/** /**
* 诊断 / 冒烟专用:覆盖"光标位置"(屏幕坐标),让命中兜底轮询按指定坐标校正。 * 诊断 / 冒烟专用:覆盖"光标位置"(屏幕坐标),让命中兜底轮询按指定坐标校正。
* *
@@ -1083,11 +1412,14 @@ class IslandController {
/** /**
* 光标相对窗口左上角的本地坐标(CSS px / DIP,与渲染进程上报的岛体矩形同一坐标系)。 * 光标相对窗口左上角的本地坐标(CSS px / DIP,与渲染进程上报的岛体矩形同一坐标系)。
* 冒烟里用 `setHitTestCursor` 注入,真实场景读系统光标。 * 冒烟里用 `setHitTestCursor` 注入,真实场景读系统光标。
*
* `cursor`:调用方在本轮 tick 里已经读过的光标位置(见 `startHitPoll`)。
* 传进来就复用它,避免同一个 tick 里重复调 `screen.getCursorScreenPoint()`。
*/ */
private cursorLocal(): { x: number; y: number } | null { private cursorLocal(cursor?: { x: number; y: number } | null): { x: number; y: number } | null {
if (!this.win || this.win.isDestroyed()) return null; if (!this.win || this.win.isDestroyed()) return null;
const bounds = this.win.getBounds(); const bounds = this.win.getBounds();
const point = this.cursorOverride ?? screen.getCursorScreenPoint(); const point = cursor ?? this.cursorOverride ?? screen.getCursorScreenPoint();
return { x: point.x - bounds.x, y: point.y - bounds.y }; return { x: point.x - bounds.x, y: point.y - bounds.y };
} }
@@ -1099,23 +1431,39 @@ class IslandController {
return this.hitRect ?? this.expectedHitRect(); return this.hitRect ?? this.expectedHitRect();
} }
/** 按当前形态/停靠位置算出岛体目标矩形(窗口内 CSS px),仅作兜底 */ /** 当前形态下**岛本身**的尺寸(不是窗口尺寸;响应进程的 `.island-card` 宽高) */
private expectedHitRect(): { x: number; y: number; width: number; height: number } { private formSize(): { width: number; height: number } {
let size = SIZES.pill; // 多条通知的列表形态:高度由统一布局算法算出(渲染进程算的是同一个数)
const layout = this.listLayout();
if (layout) return { width: SIZES.expanded.width, height: layout.height };
if (this.state.mode === 'expanded') { if (this.state.mode === 'expanded') {
size = return this.state.active?.kind === 'call'
this.state.active?.kind === 'call' ? CALL_SIZE
? CALL_SIZE : this.state.active?.priority === 'URGENT'
: this.state.active?.priority === 'URGENT' ? URGENT_SIZE
? URGENT_SIZE : SIZES.expanded;
: SIZES.expanded;
} else if (this.state.mode === 'hidden' && this.appearance.idleSliver) {
size = SLIVER_SIZE;
} }
if (this.state.mode === 'hidden' && this.appearance.idleSliver) return SLIVER_SIZE;
return SIZES.pill;
}
/**
* 按当前形态/停靠位置算出岛体目标矩形(窗口内 CSS px),仅作兜底。
*
* 定位规则必须与渲染进程的 CSS 完全一致(`islandStyle`):左/右停靠贴边留 pad,
* 居中则水平居中;上/下停靠同理。这里用**窗口实际尺寸**而不是 BBOX_SIZE 计算 ——
* 触摸模式下窗口会贴合岛体,用固定的 BBOX_SIZE 会算出错误偏移。
*/
private expectedHitRect(): { x: number; y: number; width: number; height: number } {
const size = this.formSize();
const pad = ISLAND_SHADOW_PAD; const pad = ISLAND_SHADOW_PAD;
const position = this.appearance.position; const position = this.appearance.position;
const width = Math.round(BBOX_SIZE.width); const bounds =
const height = Math.round(BBOX_SIZE.height); this.win && !this.win.isDestroyed()
? this.win.getBounds()
: { width: Math.round(BBOX_SIZE.width), height: Math.round(BBOX_SIZE.height) };
const width = bounds.width;
const height = bounds.height;
const x = position.endsWith('left') const x = position.endsWith('left')
? pad ? pad
: position.endsWith('right') : position.endsWith('right')
@@ -1152,7 +1500,7 @@ class IslandController {
} }
/** 按光标位置校正命中(不依赖渲染进程是否收到 mousemove) */ /** 按光标位置校正命中(不依赖渲染进程是否收到 mousemove) */
private syncHitFromCursor(): void { private syncHitFromCursor(cursor?: { x: number; y: number } | null): void {
if (!this.win || this.win.isDestroyed() || !this.win.isVisible()) { if (!this.win || this.win.isDestroyed() || !this.win.isVisible()) {
this.setInteractive(false, '窗口不可见'); this.setInteractive(false, '窗口不可见');
return; return;
@@ -1163,15 +1511,34 @@ class IslandController {
this.setInteractive(false, '隐藏态'); this.setInteractive(false, '隐藏态');
return; return;
} }
this.setInteractive(this.isInsideHitRect(this.cursorLocal()), '光标轮询'); this.setInteractive(this.isInsideHitRect(this.cursorLocal(cursor)), '光标轮询');
} }
private startHitPoll(): void { private startHitPoll(): void {
if (this.hitTimer) return; if (this.hitTimer) return;
// 60ms:渲染进程的 mousemove 转发在 Windows 上并不可靠,这里是命中的**权威来源**, // 60ms:渲染进程的 mousemove 转发在 Windows 上并不可靠,这里是命中的**权威来源**,
// 间隔必须足够小,否则"指针移上胶囊后立刻点击"会因窗口还没接收鼠标而点空(用户反馈过)。 // 间隔必须足够小,否则"指针移上胶囊后立刻点击"会因窗口还没接收鼠标而点空(用户反馈过)。
//
// 每一跳的成本要压到最低(这个定时器从岛初始化一直跑到进程退出):
// 1) 光标位置**每跳只读一次**,命中判定与"跟随鼠标屏幕"共用 —— 原先 cursorLocal() 与
// targetDisplay() 各读一次,等于每跳两次 `screen.getCursorScreenPoint()`;
// 2) 窗口不可见时直接返回:此时命中判定与心跳检查本来就各自早退(窗口不可见 ⇒ 无命中可言),
// 留着那两次系统调用纯属白跑。
this.hitTimer = setInterval(() => { this.hitTimer = setInterval(() => {
this.syncHitFromCursor(); if (!this.win || this.win.isDestroyed()) return;
const visible = this.win.isVisible();
// 不可见、且不跟随鼠标屏幕时,连读光标都可省掉(targetDisplay 会走主屏分支)
const cursor =
visible || this.appearance.followCursorDisplay
? (this.cursorOverride ?? screen.getCursorScreenPoint())
: null;
// 先按目标屏幕校正窗口位置(换屏/插拔显示器),再算命中与心跳:
// 顺序不能反,否则命中判定会用上一块屏的窗口坐标
this.syncAnchorDisplay(cursor);
if (!visible) return;
this.syncHitFromCursor(cursor);
this.checkRendererAlive(); this.checkRendererAlive();
}, 60); }, 60);
// 定时器不应拖住进程退出 // 定时器不应拖住进程退出
@@ -1325,24 +1692,36 @@ export function getSliverSize(): { width: number; height: number } {
/** 夹紧外观取值(越界值直接收敛,避免用户配置破坏布局) */ /** 夹紧外观取值(越界值直接收敛,避免用户配置破坏布局) */
export function normalizeAppearance(input: IslandAppearance): IslandAppearance { export function normalizeAppearance(input: IslandAppearance): IslandAppearance {
const clamp = (value: number, min: number, max: number): number => /**
Math.min(max, Math.max(min, Math.round(value * 100) / 100)); * 夹紧数值:**非法值回落到该字段的默认值**,而不是变成 NaN。
*
* 注意 `Math.max(min, NaN)` 仍是 NaN、`Math.min(max, NaN)` 也是 NaN —— 也就是说"只夹紧"
* 并不能防住 NaN。而 `setAppearance()` 的入参来自 IPC(`island:set-appearance` 只判了 `if (patch)`),
* 渲染进程传一个显式 `undefined` 字段就会得到 NaN,随后 `setOpacity(NaN)` / `setBounds({x:NaN})`
* 抛异常;它在非 async 的 ipcMain 监听里抛出,主进程没有兜底,会直接崩掉
* (连带托盘、灵动岛、实时连接一起消失)。因此这里补上 fallback。
*/
const clamp = (value: number, min: number, max: number, fallback: number): number => {
if (typeof value !== 'number' || !Number.isFinite(value)) return fallback;
return Math.min(max, Math.max(min, Math.round(value * 100) / 100));
};
const fallbackOf = DEFAULT_ISLAND_APPEARANCE;
return { return {
height: clamp(input.height, 36, 72), height: clamp(input.height, 36, 72, fallbackOf.height),
width: clamp(input.width, 220, 420), width: clamp(input.width, 220, 420, fallbackOf.width),
radius: clamp(input.radius, 8, 32), radius: clamp(input.radius, 8, 32, fallbackOf.radius),
opacity: clamp(input.opacity, 0.4, 1), opacity: clamp(input.opacity, 0.4, 1, fallbackOf.opacity),
accent: /^#[0-9a-fA-F]{6}$/.test(input.accent) ? input.accent : DEFAULT_ISLAND_APPEARANCE.accent, accent: /^#[0-9a-fA-F]{6}$/.test(input.accent) ? input.accent : DEFAULT_ISLAND_APPEARANCE.accent,
fontSize: clamp(input.fontSize, 11, 20), fontSize: clamp(input.fontSize, 11, 20, fallbackOf.fontSize),
animations: input.animations !== false, animations: input.animations !== false,
speed: clamp(input.speed, 0.5, 2), speed: clamp(input.speed, 0.5, 2, fallbackOf.speed),
position: ISLAND_POSITIONS.includes(input.position) ? input.position : 'top-center', position: ISLAND_POSITIONS.includes(input.position) ? input.position : 'top-center',
alwaysOnTop: input.alwaysOnTop !== false, alwaysOnTop: input.alwaysOnTop !== false,
style: ISLAND_STYLES.includes(input.style) ? input.style : 'black', style: ISLAND_STYLES.includes(input.style) ? input.style : 'black',
idleSliver: input.idleSliver === true, idleSliver: input.idleSliver === true,
// 边距:0 表示贴着屏幕边缘,上限给到 200/160 是为了"多显示器 + 任务栏在侧面"这类布局 // 边距:0 表示贴着屏幕边缘,上限给到 200/160 是为了"多显示器 + 任务栏在侧面"这类布局
marginX: clamp(input.marginX ?? DEFAULT_ISLAND_APPEARANCE.marginX, 0, 200), marginX: clamp(input.marginX ?? DEFAULT_ISLAND_APPEARANCE.marginX, 0, 200, fallbackOf.marginX),
marginY: clamp(input.marginY ?? DEFAULT_ISLAND_APPEARANCE.marginY, 0, 160), marginY: clamp(input.marginY ?? DEFAULT_ISLAND_APPEARANCE.marginY, 0, 160, fallbackOf.marginY),
followCursorDisplay: input.followCursorDisplay === true, followCursorDisplay: input.followCursorDisplay === true,
}; };
} }
@@ -1370,16 +1749,33 @@ const ISLAND_MARGIN = 8;
*/ */
const BLUR_GRACE_MS = 500; const BLUR_GRACE_MS = 500;
/**
* 触摸屏上的失焦宽限期(触摸模式专用,见 `touchMode`)。
*
* 触摸没有光标,`isCursorOnIsland()` 这条"指针还在岛上就判定为激活抖动"的兜底恒为 false,
* 只剩宽限期这一层防线。而实测的假失焦出现在 focus 之后 70~520ms,正好跨过 500ms 的边界,
* 不放开的话手指点开后会偶发地立刻缩回胶囊。取 1200ms 给它 2 倍余量;
* 真正的"点屏幕别处收起"仍会在 1.2s 后生效。
*/
const BLUR_GRACE_TOUCH_MS = 1200;
/** 设置页"预览效果"的示例岛停留时长(到点自动收尾,避免一直挂在桌面上) */ /** 设置页"预览效果"的示例岛停留时长(到点自动收尾,避免一直挂在桌面上) */
const PREVIEW_DURATION_MS = 30_000; const PREVIEW_DURATION_MS = 30_000;
/** /**
* 渲染进程心跳(渲染进程每 5s 上报一次):超过这个时间没上报就认为它已经卡死/不响应。 * 展开卡可用高度的下限(CSS px):屏幕再矮也要留出这么多,
* 否则"列表能放几行"会算出负数。真正的工作区空间由 `refreshViewport` 算,这里只是防呆。
*/
const MIN_CARD_HEIGHT = 120;
/**
* 渲染进程心跳(渲染进程每 5s 上报一次,间隔写死在 `src/island/IslandApp.vue`):
* 超过这个时间没上报就认为它已经卡死/不响应。
* 岛是"无边框透明置顶窗口",渲染进程一旦挂掉,Windows 会把**最后一帧留在屏幕上** * 岛是"无边框透明置顶窗口",渲染进程一旦挂掉,Windows 会把**最后一帧留在屏幕上**
* 形成"幽灵胶囊":窗口还在、看着正常,但怎么点都没反应(实测复现:崩掉渲染进程后 * 形成"幽灵胶囊":窗口还在、看着正常,但怎么点都没反应(实测复现:崩掉渲染进程后
* 点击完全不产生任何动作)。所以必须有心跳 + 重建来兜底。 * 点击完全不产生任何动作)。所以必须有心跳 + 重建来兜底。
*/ */
const RENDERER_ALIVE_INTERVAL_MS = 5_000;
const RENDERER_ALIVE_TIMEOUT_MS = 20_000; const RENDERER_ALIVE_TIMEOUT_MS = 20_000;
/** 窗口重建限流:一段时间内最多重建几次,避免持续崩坏时无限重建 */ /** 窗口重建限流:一段时间内最多重建几次,避免持续崩坏时无限重建 */
const RECOVER_MAX_TIMES = 3; const RECOVER_MAX_TIMES = 3;
@@ -1446,6 +1842,12 @@ export function registerIslandIpc(): void {
}, },
); );
// 触摸屏上报(渲染进程按 navigator.maxTouchPoints 判定)→ 窗口改为贴合岛体并始终接收输入。
// 触摸屏上按光标判定命中的那套永远打不开命中,手指点不到岛(详见 IslandController.touchMode)。
ipcMain.on('island:set-touch-mode', (_event, enabled: boolean) => {
island.setTouchMode(enabled === true);
});
ipcMain.on('island:action', (_event, payload: IslandActionPayload) => { ipcMain.on('island:action', (_event, payload: IslandActionPayload) => {
if (!payload?.action) return; if (!payload?.action) return;
island.handleAction(payload); island.handleAction(payload);
File diff suppressed because it is too large. Load diff
+215
View File
@@ -0,0 +1,215 @@
import { app, type BrowserWindow } from 'electron';
import {
GITHUB_RELEASES_LATEST_API,
GITHUB_RELEASES_PAGE,
UPDATE_CHECK_CACHE_TTL_MS,
UPDATE_CHECK_TIMEOUT_MS,
UPDATE_CHECK_USER_AGENT,
isNewerVersion,
normalizeVersion,
type UpdateAssetDto,
type UpdateInfo,
} from '@classhelper/shared';
import { getConfig, saveConfig } from './config.js';
import { logger } from './logger.js';
/**
* 更新检查(桌面客户端)。
*
* **为什么在主进程做**:渲染进程通过 preload 能拿到 `getConfig()` 的明文 token(代表全班身份),
* 它的 CSP 与导航防线是整个安全模型里最要紧的一层;让它额外去连一个外部域名、
* 解析外部 JSON,等于把"外部数据"请进最有价值的那一侧。主进程本来就在做网络与文件,
* 放这里也顺带复用 Node 的 fetch(无需额外依赖)。
*
* 与 Web 管理端的差别:Web 端受服务端 CSP 的 `connect-src` 限制,只能走 `/api/update/check` 转发;
* 客户端没有这个限制,按用户选择**直连 GitHub**。两边归一化出的 `UpdateInfo` 结构一致。
*/
/** 主进程 → 渲染进程:发现新版本(渲染进程据此弹一次性提示) */
export const UPDATE_AVAILABLE_CHANNEL = 'classhelper:update:available';
/** 启动后多久自动查一次:等窗口与登录流程就绪,也不跟首屏请求抢带宽 */
const STARTUP_DELAY_MS = 5_000;
interface GithubReleasePayload {
tag_name?: unknown;
name?: unknown;
published_at?: unknown;
body?: unknown;
html_url?: unknown;
assets?: unknown;
}
let cache: { at: number; info: UpdateInfo } | null = null;
let startupTimer: ReturnType<typeof setTimeout> | null = null;
/** 冒烟断言用:启动自动检查是否被跳过(冒烟模式下必须是 true) */
let startupCheckSkipped = false;
/** 失败的统一出口:结构完整,界面不必做 null 判断 */
function failure(error: string): UpdateInfo {
return {
ok: false,
error,
currentVersion: app.getVersion(),
latestVersion: null,
hasUpdate: false,
releaseUrl: GITHUB_RELEASES_PAGE,
releaseName: null,
publishedAt: null,
notes: null,
assets: [],
checkedAt: new Date().toISOString(),
};
}
function toAssets(raw: unknown): UpdateAssetDto[] {
if (!Array.isArray(raw)) return [];
return raw
.map((item) => item as { name?: unknown; browser_download_url?: unknown; size?: unknown })
.filter(
(item): item is { name: string; browser_download_url: string; size?: unknown } =>
typeof item.name === 'string' && typeof item.browser_download_url === 'string',
)
.map((item) => ({
name: item.name,
downloadUrl: item.browser_download_url,
size: typeof item.size === 'number' && Number.isFinite(item.size) ? item.size : 0,
}));
}
function toInfo(payload: GithubReleasePayload, currentVersion: string): UpdateInfo {
const latestVersion = normalizeVersion(typeof payload.tag_name === 'string' ? payload.tag_name : '');
if (!latestVersion) {
logger.warn('更新检查:GitHub 返回的 Release 里没有可识别的 tag_name');
return failure('GitHub 返回的版本号无法识别');
}
return {
ok: true,
error: null,
currentVersion,
latestVersion,
hasUpdate: isNewerVersion(currentVersion, latestVersion),
releaseUrl:
typeof payload.html_url === 'string' && payload.html_url ? payload.html_url : GITHUB_RELEASES_PAGE,
releaseName: typeof payload.name === 'string' ? payload.name : null,
publishedAt: typeof payload.published_at === 'string' ? payload.published_at : null,
notes: typeof payload.body === 'string' ? payload.body : null,
assets: toAssets(payload.assets),
checkedAt: new Date().toISOString(),
};
}
/** 把各种失败翻译成一句用户能看懂的话(教室里最常见的就是"这台机器没有外网") */
function describeFailure(error: unknown): string {
const message = error instanceof Error ? error.message : String(error);
if (error instanceof Error && error.name === 'TimeoutError') {
return `连接 GitHub 超时(${UPDATE_CHECK_TIMEOUT_MS / 1000} 秒),本机可能没有外网`;
}
if (/fetch failed|ENOTFOUND|ECONNREFUSED|EAI_AGAIN|ETIMEDOUT|certificate|net::/i.test(message)) {
return '无法连接 GitHub,本机可能没有外网';
}
return `检查更新失败:${message}`;
}
/**
* 检查 GitHub 上有没有比本机新的版本(结果带缓存)。
*
* 缓存的意义:匿名调用 GitHub API 的限流是 60 次/小时/IP,而「关于」页的按钮可以随便点。
* 失败结果同样进缓存 —— 否则离线时每点一次都要白等一个超时。
*/
export async function checkForUpdates(force = false): Promise<UpdateInfo> {
const currentVersion = app.getVersion();
const now = Date.now();
if (!force && cache && now - cache.at < UPDATE_CHECK_CACHE_TTL_MS) {
return cache.info;
}
let info: UpdateInfo;
try {
const response = await fetch(GITHUB_RELEASES_LATEST_API, {
headers: {
// GitHub API 强制要求 User-Agent,不带会直接 403
'User-Agent': UPDATE_CHECK_USER_AGENT,
Accept: 'application/vnd.github+json',
},
signal: AbortSignal.timeout(UPDATE_CHECK_TIMEOUT_MS),
});
if (!response.ok) {
info =
response.status === 403 || response.status === 429
? failure('GitHub 暂时拒绝了请求(匿名查询次数过多),请过一会儿再试')
: failure(`GitHub 返回 HTTP ${response.status}`);
logger.warn(`更新检查失败:HTTP ${response.status}(本机版本 ${currentVersion})`);
} else {
info = toInfo((await response.json()) as GithubReleasePayload, currentVersion);
logger.info(
`更新检查:本机 ${currentVersion} / 最新 ${info.latestVersion ?? '-'}` +
`${info.hasUpdate ? '(有新版本)' : '(已是最新)'}`,
);
}
} catch (error) {
info = failure(describeFailure(error));
logger.warn(`更新检查失败:${info.error}(本机版本 ${currentVersion})`);
}
cache = { at: now, info };
return info;
}
/** 「知道了 / 忽略此版本」:记到配置里,同一个版本不再重复弹提示 */
export function ignoreUpdateVersion(version: string): void {
const normalized = normalizeVersion(version);
if (!normalized) return;
saveConfig({ ignoredUpdateVersion: normalized });
logger.info(`已忽略版本 ${normalized} 的更新提示`);
}
/** 该版本是否已被用户忽略 */
export function isUpdateIgnored(version: string): boolean {
return normalizeVersion(getConfig().ignoredUpdateVersion) === normalizeVersion(version);
}
/**
* 启动后的自动检查:延迟 `STARTUP_DELAY_MS` 查一次,有新版本(且没被忽略)就通知渲染进程弹提示。
*
* **冒烟模式直接跳过**:自动化验证不该每次都发真实网络请求(既抖动又依赖外网),
* 而且凭空多出来的提示条会撞坏既有 UI 断言。冒烟用例改为直接调 IPC 验证返回结构。
*/
export function scheduleStartupUpdateCheck(getWindow: () => BrowserWindow | null): void {
if (process.env.ELECTRON_SMOKE_TEST === '1') {
startupCheckSkipped = true;
logger.info('更新检查:冒烟模式下跳过启动自动检查');
return;
}
if (startupTimer) clearTimeout(startupTimer);
startupTimer = setTimeout(() => {
startupTimer = null;
void (async () => {
try {
const info = await checkForUpdates();
if (!info.ok || !info.hasUpdate || !info.latestVersion) return;
if (isUpdateIgnored(info.latestVersion)) {
logger.info(`更新检查:${info.latestVersion} 已被用户忽略,本次不提示`);
return;
}
const win = getWindow();
if (!win || win.isDestroyed()) return;
win.webContents.send(UPDATE_AVAILABLE_CHANNEL, info);
logger.info(`更新检查:已提示新版本 ${info.latestVersion}`);
} catch (error) {
// 自动检查失败不该打扰用户(手动检查才需要看到原因)
logger.warn(`启动自动检查更新失败:${error instanceof Error ? error.message : error}`);
}
})();
}, STARTUP_DELAY_MS);
// 不阻止进程退出:这个定时器只是"顺便查一下"
startupTimer.unref?.();
}
/** 冒烟断言用:启动自动检查是否被跳过(冒烟模式下应为 true —— 否则每次验证都会发真实网络请求) */
export function wasStartupCheckSkipped(): boolean {
return startupCheckSkipped;
}
+26 -1
View File
@@ -1,5 +1,6 @@
import { contextBridge, ipcRenderer } from 'electron'; import { contextBridge, ipcRenderer } from 'electron';
import { IPC_CHANNELS } from '../main/ipc.js'; import { IPC_CHANNELS } from '../main/ipc.js';
import { UPDATE_AVAILABLE_CHANNEL } from '../main/update.js';
import type { import type {
DesktopAppInfo, DesktopAppInfo,
DesktopBridge, DesktopBridge,
@@ -7,7 +8,7 @@ import type {
IslandClassStatePayload, IslandClassStatePayload,
IslandPushContext, IslandPushContext,
} from '../types/desktop.js'; } from '../types/desktop.js';
import type { IslandNotification } from '@classhelper/shared'; import type { IslandNotification, UpdateInfo } from '@classhelper/shared';
/** /**
* 预加载脚本:在开启了 contextIsolation + sandbox 的前提下, * 预加载脚本:在开启了 contextIsolation + sandbox 的前提下,
@@ -19,6 +20,17 @@ import type { IslandNotification } from '@classhelper/shared';
*/ */
const bridge: DesktopBridge = { const bridge: DesktopBridge = {
smokeTest: process.env.ELECTRON_SMOKE_TEST === '1', smokeTest: process.env.ELECTRON_SMOKE_TEST === '1',
// 冒烟凭据:只在冒烟模式下透传,供渲染进程的冒烟钩子构造测试数据用。
// **不走代码字面量**——本文件与渲染产物都会进 app.asar,写死账号等于随安装包把教师口令发出去。
smokeCredentials:
process.env.ELECTRON_SMOKE_TEST === '1'
? {
username: process.env.ELECTRON_SMOKE_USER ?? '',
password: process.env.ELECTRON_SMOKE_PASSWORD ?? '',
classCode: process.env.ELECTRON_SMOKE_CLASS_CODE ?? '',
classPassword: process.env.ELECTRON_SMOKE_CLASS_PASSWORD ?? '',
}
: undefined,
getConfig: (): Promise<DesktopStoredConfig> => ipcRenderer.invoke(IPC_CHANNELS.getConfig), getConfig: (): Promise<DesktopStoredConfig> => ipcRenderer.invoke(IPC_CHANNELS.getConfig),
saveConfig: (patch: Partial<DesktopStoredConfig>): Promise<DesktopStoredConfig> => saveConfig: (patch: Partial<DesktopStoredConfig>): Promise<DesktopStoredConfig> =>
ipcRenderer.invoke(IPC_CHANNELS.saveConfig, patch), ipcRenderer.invoke(IPC_CHANNELS.saveConfig, patch),
@@ -26,6 +38,15 @@ const bridge: DesktopBridge = {
getAppInfo: (): Promise<DesktopAppInfo> => ipcRenderer.invoke(IPC_CHANNELS.appInfo), getAppInfo: (): Promise<DesktopAppInfo> => ipcRenderer.invoke(IPC_CHANNELS.appInfo),
openExternal: (url: string): Promise<boolean> => ipcRenderer.invoke(IPC_CHANNELS.openExternal, url), openExternal: (url: string): Promise<boolean> => ipcRenderer.invoke(IPC_CHANNELS.openExternal, url),
/* 更新检查(主进程直连 GitHub,见 main/update.ts) */
checkForUpdates: (force = false): Promise<UpdateInfo> =>
ipcRenderer.invoke(IPC_CHANNELS.updateCheck, force),
ignoreUpdateVersion: (version: string): Promise<void> =>
ipcRenderer.invoke(IPC_CHANNELS.updateIgnore, version),
onUpdateAvailable: (handler: (info: UpdateInfo) => void): void => {
ipcRenderer.on(UPDATE_AVAILABLE_CHANNEL, (_event, info: UpdateInfo) => handler(info));
},
islandPush: (payload: { notification: IslandNotification; context?: IslandPushContext }): void => { islandPush: (payload: { notification: IslandNotification; context?: IslandPushContext }): void => {
ipcRenderer.send('island:push', payload); ipcRenderer.send('island:push', payload);
}, },
@@ -41,6 +62,10 @@ const bridge: DesktopBridge = {
onIslandMarkRead: (handler: (id: string) => void): void => { onIslandMarkRead: (handler: (id: string) => void): void => {
ipcRenderer.on('island:mark-read', (_event, id: string) => handler(id)); ipcRenderer.on('island:mark-read', (_event, id: string) => handler(id));
}, },
/** 灵动岛点了"标为已读"(多条通知的整批):一次同步这一批 */
onIslandMarkAllRead: (handler: (ids: string[]) => void): void => {
ipcRenderer.on('island:mark-all-read', (_event, ids: string[]) => handler(ids ?? []));
},
}; };
contextBridge.exposeInMainWorld('desktop', bridge); contextBridge.exposeInMainWorld('desktop', bridge);
+21 -1
View File
@@ -7,7 +7,18 @@ import type { IslandAppearance, IslandState } from '@classhelper/shared';
*/ */
export interface IslandBridge { export interface IslandBridge {
onState(handler: (state: IslandState) => void): void; onState(handler: (state: IslandState) => void): void;
sendAction(action: 'expand' | 'collapse' | 'dismiss' | 'mark-read' | 'open-app', id?: string): void; sendAction(
action:
| 'expand'
| 'expand-list'
| 'collapse'
| 'dismiss'
| 'dismiss-all'
| 'mark-read'
| 'mark-all-read'
| 'open-app',
id?: string,
): void;
getState(): Promise<IslandState>; getState(): Promise<IslandState>;
/** 订阅个性化外观(设置页改动后实时生效) */ /** 订阅个性化外观(设置页改动后实时生效) */
onAppearance(handler: (appearance: IslandAppearance) => void): void; onAppearance(handler: (appearance: IslandAppearance) => void): void;
@@ -16,6 +27,12 @@ export interface IslandBridge {
setInteractive(interactive: boolean): void; setInteractive(interactive: boolean): void;
/** 上报岛体矩形(窗口内 CSS px):主进程据此按光标位置兜底校正命中 */ /** 上报岛体矩形(窗口内 CSS px):主进程据此按光标位置兜底校正命中 */
setHitRect(rect: { x: number; y: number; width: number; height: number } | null): void; setHitRect(rect: { x: number; y: number; width: number; height: number } | null): void;
/**
* 上报"本机是触摸屏":主进程据此把窗口改为贴合岛体并始终接收输入。
* 触摸屏上按光标判定命中的那套永远打不开(触摸不产生 mousemove、也不动系统光标),
* 不上报的话手指点不到岛(希沃白板等触摸设备)。
*/
setTouchMode(enabled: boolean): void;
/** 心跳:主进程据此发现"渲染进程卡死的幽灵窗口"(岛还在屏幕上但点不动)并重建窗口 */ /** 心跳:主进程据此发现"渲染进程卡死的幽灵窗口"(岛还在屏幕上但点不动)并重建窗口 */
alive(): void; alive(): void;
} }
@@ -38,6 +55,9 @@ const bridge: IslandBridge = {
setHitRect: (rect) => { setHitRect: (rect) => {
ipcRenderer.send('island:set-hit-rect', rect); ipcRenderer.send('island:set-hit-rect', rect);
}, },
setTouchMode: (enabled) => {
ipcRenderer.send('island:set-touch-mode', enabled);
},
alive: () => { alive: () => {
ipcRenderer.send('island:alive'); ipcRenderer.send('island:alive');
}, },
+82 -3
View File
@@ -1,19 +1,77 @@
<script setup lang="ts"> <script setup lang="ts">
import { onMounted, onUnmounted, ref } from 'vue'; import { h, onMounted, onUnmounted, ref } from 'vue';
import { useRouter } from 'vue-router'; import { useRouter } from 'vue-router';
import { startIslandBridge, stopIslandBridge, subscribeIslandMarkRead } from './island/bridge.js'; import { ElButton, ElNotification } from 'element-plus';
import type { UpdateInfo } from '@classhelper/shared';
import {
startIslandBridge,
stopIslandBridge,
subscribeIslandMarkAllRead,
subscribeIslandMarkRead,
} from './island/bridge.js';
import OnboardingWelcome from './components/OnboardingWelcome.vue';
import { useAppStore } from './stores/app.js'; import { useAppStore } from './stores/app.js';
import { useAuthStore } from './stores/auth.js'; import { useAuthStore } from './stores/auth.js';
import { useOnboardingStore } from './stores/onboarding.js';
import { useRealtimeStore } from './stores/realtime.js'; import { useRealtimeStore } from './stores/realtime.js';
import { useUiStore } from './stores/ui.js';
const router = useRouter(); const router = useRouter();
const appStore = useAppStore(); const appStore = useAppStore();
const auth = useAuthStore(); const auth = useAuthStore();
const onboarding = useOnboardingStore();
const ui = useUiStore();
const realtime = useRealtimeStore(); const realtime = useRealtimeStore();
const booting = ref(true); const booting = ref(true);
const bootText = ref('正在读取本地配置...'); const bootText = ref('正在读取本地配置...');
/**
* 启动自动检查发现新版本时的提示(主进程查出后推过来,见 main/update.ts)。
*
* **为什么订阅放在 App.vue**:`onUpdateAvailable` 底层是 `ipcRenderer.on`,
* 桥接层没有对应的 off —— 挂在会随"登出 → 登录"反复挂载的 ClientLayout 里,
* 处理器会越堆越多(与灵动岛订阅同一个坑)。App.vue 整个应用生命周期只挂载一次。
*
* 提示是**一次性**且可永久消音:点「忽略此版本」写进 config.json,同一版本不再提示;
* 「关于」页里仍可随时手动检查。
*/
function showUpdateAvailable(info: UpdateInfo): void {
if (!info.latestVersion) return;
ElNotification({
title: `发现新版本 v${info.latestVersion}`,
type: 'info',
// 不自动消失:这是需要用户决定的事(去下载 / 忽略),滑过去就只能靠「关于」页再想起来
duration: 0,
message: h('div', { style: 'line-height: 1.7' }, [
h('p', { style: 'margin: 0 0 10px' }, `当前版本 ${info.currentVersion},可前往下载更新。`),
h('div', { style: 'display: flex; gap: 8px' }, [
h(
ElButton,
{
size: 'small',
type: 'primary',
onClick: () => {
void window.desktop?.openExternal(info.releaseUrl);
},
},
() => '前往下载',
),
h(
ElButton,
{
size: 'small',
onClick: () => {
void window.desktop?.ignoreUpdateVersion(info.latestVersion ?? '');
},
},
() => '忽略此版本',
),
]),
]),
});
}
/** /**
* 启动流程: * 启动流程:
* 1) 从主进程配置恢复服务器地址与登录令牌 * 1) 从主进程配置恢复服务器地址与登录令牌
@@ -22,6 +80,10 @@ const bootText = ref('正在读取本地配置...');
*/ */
onMounted(async () => { onMounted(async () => {
try { try {
bootText.value = '正在读取本地配置...';
// 主题与侧栏折叠最先恢复:在首屏渲染前挂好 html.dark,避免"先白后黑"闪一下
await ui.init();
bootText.value = '正在恢复登录状态...'; bootText.value = '正在恢复登录状态...';
const session = await auth.restore(); const session = await auth.restore();
@@ -41,11 +103,26 @@ onMounted(async () => {
// 灵动岛:开始按课表计算上课状态(上课隐藏、下课自动弹出) // 灵动岛:开始按课表计算上课状态(上课隐藏、下课自动弹出)
if (auth.token) startIslandBridge(); if (auth.token) startIslandBridge();
// 灵动岛"标为已读" → 同步通知中心(未读红点) // 灵动岛"标为已读" → 同步通知中心(未读红点);多条通知时是整批已读
subscribeIslandMarkRead(); subscribeIslandMarkRead();
subscribeIslandMarkAllRead();
// 启动自动检查发现新版本时由主进程推过来(订阅只挂一次,理由见 showUpdateAvailable)
window.desktop?.onUpdateAvailable?.(showUpdateAvailable);
if (auth.isAuthenticated) await router.replace('/schedule'); if (auth.isAuthenticated) await router.replace('/schedule');
else await router.replace('/login'); else await router.replace('/login');
// 初次启动引导:配置里没记「已看过」就自动弹一次(完成/跳过后由引导组件写入配置)。
// 稍等一拍再弹:让登录页/主界面先渲染完,避免和启动过渡的收尾抢帧。
window.setTimeout(() => {
void window.desktop
?.getConfig()
.then((config) => {
if (config.onboardingDone !== true) onboarding.open();
})
.catch(() => undefined);
}, 400);
} finally { } finally {
booting.value = false; booting.value = false;
} }
@@ -63,6 +140,8 @@ onUnmounted(() => {
<p class="boot-text">{{ bootText }}</p> <p class="boot-text">{{ bootText }}</p>
</div> </div>
<router-view v-else /> <router-view v-else />
<!-- 初次启动引导:常驻挂载,由 onboarding store 控制显隐(登录页/主界面/设置页都能唤起) -->
<OnboardingWelcome v-if="!booting" />
</template> </template>
<style scoped> <style scoped>
@@ -21,13 +21,22 @@ import { api } from './http.js';
/** 客户端只需用到学生视角的这批接口(与后端同一套 REST 契约) */ /** 客户端只需用到学生视角的这批接口(与后端同一套 REST 契约) */
export const authApi = { export const authApi = {
/** 个人账号登录(教师/管理员/个人学生;客户端界面已不再展示,保留以兼容旧流程与排障) */ /** 账号登录(教师/管理员用;客户端界面走班级登录,学生个人账号已清理不能登录) */
login: (payload: LoginRequest): Promise<LoginResponse> => api.post(API_PATHS.auth.login, payload), login: (payload: LoginRequest): Promise<LoginResponse> => api.post(API_PATHS.auth.login, payload),
/** 班级账号登录(学生端主入口):班级码 + 班级密码 */ /** 班级账号登录(学生端主入口):班级码 + 班级密码 */
classLogin: (payload: { code: string; password: string }): Promise<LoginResponse> => classLogin: (payload: { code: string; password: string }): Promise<LoginResponse> =>
api.post('/auth/class-login', payload), api.post('/auth/class-login', payload),
logout: (): Promise<{ loggedOut: boolean }> => api.post(API_PATHS.auth.logout, {}), logout: (): Promise<{ loggedOut: boolean }> => api.post(API_PATHS.auth.logout, {}),
me: (): Promise<StudentDto> => api.get(API_PATHS.auth.me), me: (): Promise<StudentDto> => api.get(API_PATHS.auth.me),
/**
* 修改密码(设置页「账号信息」里的入口)。
* 服务端同一个接口按会话类型分流:班级账号改的是**班级密码**,教师/管理员改的是本人登录密码 ——
* 因此这台机器无论以哪种身份登录,改密入口都走这一条。
*/
changePassword: (payload: {
currentPassword: string;
newPassword: string;
}): Promise<{ changed: boolean }> => api.patch(API_PATHS.auth.changePassword, payload),
}; };
export const classApi = { export const classApi = {
@@ -110,8 +119,10 @@ export const notificationApi = {
list: (params?: { classId?: string; unreadOnly?: boolean }): Promise<NotificationDto[]> => list: (params?: { classId?: string; unreadOnly?: boolean }): Promise<NotificationDto[]> =>
api.get(API_PATHS.notifications, params), api.get(API_PATHS.notifications, params),
unreadCount: (): Promise<{ count: number }> => api.get(`${API_PATHS.notifications}/unread-count`), unreadCount: (): Promise<{ count: number }> => api.get(`${API_PATHS.notifications}/unread-count`),
// id 来自服务端或灵动岛(作业卡是本地合成的 `homework-…`),一律 encodeURIComponent:
// 否则含 `/` 或 `..` 的 id 会改变实际请求的路径
markRead: (id: string): Promise<{ notificationId: string; readAt: string }> => markRead: (id: string): Promise<{ notificationId: string; readAt: string }> =>
api.post(`${API_PATHS.notifications}/${id}/read`, {}), api.post(`${API_PATHS.notifications}/${encodeURIComponent(id)}/read`, {}),
markAllRead: (): Promise<{ marked: number }> => api.post(`${API_PATHS.notifications}/read-all`, {}), markAllRead: (): Promise<{ marked: number }> => api.post(`${API_PATHS.notifications}/read-all`, {}),
}; };
+455 -20
View File
@@ -6,6 +6,31 @@ export interface SmokeCheckResult {
detail: string; detail: string;
} }
/**
* 冒烟用的教师凭据:**由 preload 从环境变量注入,不写死在代码里**。
*
* 本文件会进渲染进程产物(`dist/renderer/assets/*.js`)→ `app.asar` → 每台学生机,
* 而 asar 可以直接解包。因此任何口令字面量都不能留在这里;
* 凭据由 `scripts/smoke.mjs` / `scripts/verify-packaged.mjs` 通过环境变量提供
* (见 `main/smoke.ts` 顶部关于 app.asar 的完整说明)。
*/
let smokeTeacherCredentials: { username: string; password: string } = { username: '', password: '' };
/** 由 main.ts 在注册冒烟钩子时注入(来源:ELECTRON_SMOKE_USER / ELECTRON_SMOKE_PASSWORD) */
export function setSmokeTeacherCredentials(next: { username: string; password: string }): void {
smokeTeacherCredentials = {
username: next?.username ?? '',
password: next?.password ?? '',
};
}
/** 教师登录请求体;未注入凭据时返回 null(调用方据此跳过并说明原因) */
function teacherLoginBody(): { username: string; password: string } | null {
return smokeTeacherCredentials.username && smokeTeacherCredentials.password
? { username: smokeTeacherCredentials.username, password: smokeTeacherCredentials.password }
: null;
}
/** /**
* 冒烟自检 1:IndexedDB 写入 / 读回 / 统计 / 删除。 * 冒烟自检 1:IndexedDB 写入 / 读回 / 统计 / 删除。
* 由主进程通过 webContents.executeJavaScript 调用。 * 由主进程通过 webContents.executeJavaScript 调用。
@@ -68,19 +93,31 @@ async function waitUntil(predicate: () => boolean, timeoutMs = 3000, intervalMs
return predicate(); return predicate();
} }
/** 侧边栏菜单与期望路由的对应关系(按显示文案匹配) */ /** 侧边栏菜单与期望路由的对应关系(按显示文案匹配;侧边栏是「分组 + 子菜单」结构) */
const EXPECTED_MENU: Array<{ label: string; path: string }> = [ const EXPECTED_MENU: Array<{ label: string; path: string }> = [
{ label: '课表', path: '/schedule' }, { label: '课表', path: '/schedule' },
{ label: '作业', path: '/homeworks' }, { label: '作业', path: '/homeworks' },
{ label: '通知', path: '/notifications' }, { label: '通知', path: '/notifications' },
{ label: '成绩', path: '/grades' }, { label: '成绩', path: '/grades' },
{ label: '设置', path: '/settings' }, /** 设置组的代表子项:设置入口改成分组后,用「通用」验证设置子页导航可用 */
{ label: '通用', path: '/settings/general' },
]; ];
/** /**
* 冒烟自检 3:侧边栏点击导航。 * 一级菜单项:2026-10-05 起「学习」分组已拆掉,课表/作业/通知/成绩**直接铺在侧栏一级**。
* 直接对真实 DOM 触发 click,验证每次点击后路由与视图都发生切换 —— * 下面的结构自检会确认它们真的不在任何 `el-sub-menu` 里。
* 这是"点击左侧边栏没反应"这类问题的回归测试。 */
const PRIMARY_MENU_ITEMS = ['课表', '作业', '通知', '成绩'];
/** 分组标题(el-sub-menu)与应包含的子项,点击分组展开后再点子项。设置组自成一类,保留分组 */
const MENU_GROUPS: Array<{ title: string; labels: string[] }> = [
{ title: '设置', labels: ['通用', '外观', '灵动岛', '提醒', '账号', '关于'] },
];
/**
* 冒烟自检 3:侧边栏点击导航(分组结构版)。
* 先点分组标题展开,再逐个点击子项,验证每次点击后路由与视图都发生切换 ——
* 这是"点击左侧边栏没反应"这类问题的回归测试(侧边栏改为「学习/设置」分组后重写)。
*/ */
export async function layoutNavigationSelfTest(): Promise<SmokeCheckResult> { export async function layoutNavigationSelfTest(): Promise<SmokeCheckResult> {
const { router } = await import('../router/index.js'); const { router } = await import('../router/index.js');
@@ -88,20 +125,51 @@ export async function layoutNavigationSelfTest(): Promise<SmokeCheckResult> {
// 按**文案那一层 span 的完整文本**匹配,而不是整项 textContent: // 按**文案那一层 span 的完整文本**匹配,而不是整项 textContent:
// "通知"项里还有一个未读红点徽标(sup),整项 textContent 会变成 "2通知", // "通知"项里还有一个未读红点徽标(sup),整项 textContent 会变成 "2通知",
// 用 startsWith 匹配就会误报"菜单项缺失"(历史失败原因)。 // 用 startsWith 匹配就会误报"菜单项缺失"(历史失败原因)。
const findMenuItem = (label: string): HTMLElement | undefined => const findByLabel = (selector: string, label: string): HTMLElement | undefined =>
(Array.from(document.querySelectorAll('.el-menu-item')) as HTMLElement[]).find((element) => (Array.from(document.querySelectorAll(selector)) as HTMLElement[]).find((element) =>
Array.from(element.querySelectorAll('span')).some( Array.from(element.querySelectorAll('span')).some((span) => (span.textContent ?? '').trim() === label),
(span) => (span.textContent ?? '').trim() === label,
),
); );
const findMenuItem = (label: string): HTMLElement | undefined => findByLabel('.el-menu-item', label);
const findGroupTitle = (title: string): HTMLElement | undefined =>
findByLabel('.el-sub-menu__title', title);
if (!findMenuItem('课表')) { if (!findGroupTitle('设置')) {
return { ok: false, detail: '侧边栏未渲染(当前不在主布局或未登录)' }; return { ok: false, detail: '侧边栏「设置」分组未渲染(当前不在主布局或未登录)' };
}
const missingPrimary = PRIMARY_MENU_ITEMS.filter((label) => !findMenuItem(label));
if (missingPrimary.length > 0) {
return { ok: false, detail: `侧边栏缺少一级项:${missingPrimary.join('、')}` };
} }
const visited: string[] = []; const visited: string[] = [];
const failures: string[] = []; const failures: string[] = [];
// 展开分组:默认只展开"当前路由所在分组",其它组需要先点开。
// 判据用"子项是否可见"而不是"盲点一次标题" —— 标题点击是 toggle,
// 对已经展开的组再点一下会把它**收起**,后续点不到子项。
const isVisible = (element: HTMLElement | undefined): boolean =>
Boolean(element && element.offsetParent !== null);
for (const group of MENU_GROUPS) {
const firstItem = findMenuItem(group.labels[0] ?? '');
if (!isVisible(firstItem)) {
findGroupTitle(group.title)?.click();
await new Promise((resolve) => setTimeout(resolve, 250));
}
}
// 结构自检:
// ① 一级项必须**真的在一级** —— 不能还挂在某个 el-sub-menu 里(用户要求把"学习"拆掉);
// ② 分组各自应包含全部子项
for (const label of PRIMARY_MENU_ITEMS) {
const element = findMenuItem(label);
if (element?.closest('.el-sub-menu')) failures.push(`${label}(仍挂在分组里,应在一级)`);
}
for (const group of MENU_GROUPS) {
for (const label of group.labels) {
if (!findMenuItem(label)) failures.push(`${group.title}组缺少子项 ${label}`);
}
}
for (const { label, path } of EXPECTED_MENU) { for (const { label, path } of EXPECTED_MENU) {
const element = findMenuItem(label); const element = findMenuItem(label);
if (!element) { if (!element) {
@@ -144,10 +212,18 @@ async function seedSmokeContent(
const stamp = `自检 ${new Date().toLocaleTimeString('zh-CN')}`; const stamp = `自检 ${new Date().toLocaleTimeString('zh-CN')}`;
try { try {
// 凭据由环境变量注入(理由见文件顶部):没给就明确跳过,而不是拿种子账号兜底
const loginBody = teacherLoginBody();
if (!loginBody) {
return {
ok: false,
detail: '未提供冒烟教师凭据(ELECTRON_SMOKE_USER / ELECTRON_SMOKE_PASSWORD),无法自建测试数据',
};
}
const login = await fetch(`${serverUrl}/api/auth/login`, { const login = await fetch(`${serverUrl}/api/auth/login`, {
method: 'POST', method: 'POST',
headers: { 'content-type': 'application/json' }, headers: { 'content-type': 'application/json' },
body: JSON.stringify({ username: 'teacher1', password: 'teacher123' }), body: JSON.stringify(loginBody),
}).then((response) => response.json()); }).then((response) => response.json());
const token: string | undefined = login?.data?.token; const token: string | undefined = login?.data?.token;
if (!token) return { ok: false, detail: `教师登录失败:${JSON.stringify(login).slice(0, 120)}` }; if (!token) return { ok: false, detail: `教师登录失败:${JSON.stringify(login).slice(0, 120)}` };
@@ -239,10 +315,18 @@ export async function onlineScenario(credentials?: {
const detail: string[] = []; const detail: string[] = [];
try { try {
// 学生端已改为「班级账号」登录:凭据由 scripts/smoke.mjs 通过管理端接口准备并传入 // 学生端已改为「班级账号」登录:凭据由 scripts/smoke.mjs 通过管理端接口准备并传入。
const code = credentials?.code ?? 'G101'; // 这里**不再回退到种子班级码**(G101/123456 也是真实可用的登录凭据,不能写进安装包):
const password = credentials?.password ?? '123456'; // 没有凭据就明确跳过,由 scripts/smoke.mjs 打印"未能准备班级账号"。
if (!credentials?.code) detail.push('未收到班级凭据,回退到种子班级码 G101'); const code = credentials?.code ?? '';
const password = credentials?.password ?? '';
if (!code) {
return {
ok: false,
detail:
'未收到班级凭据(ELECTRON_SMOKE_CLASS_CODE / ELECTRON_SMOKE_CLASS_PASSWORD),已跳过联网集成自检',
};
}
await auth.login(serverUrl, code, password); await auth.login(serverUrl, code, password);
detail.push(`login=${auth.user?.name ?? '-'}`); detail.push(`login=${auth.user?.name ?? '-'}`);
@@ -363,10 +447,17 @@ export async function islandRealtimeScenario(): Promise<{
const title = `灵动岛真机链路自检 ${Date.now()}`; const title = `灵动岛真机链路自检 ${Date.now()}`;
try { try {
const loginBody = teacherLoginBody();
if (!loginBody) {
return {
ok: false,
detail: '未提供冒烟教师凭据(ELECTRON_SMOKE_USER / ELECTRON_SMOKE_PASSWORD),无法投递通知',
};
}
const login = await fetch(`${serverUrl}/api/auth/login`, { const login = await fetch(`${serverUrl}/api/auth/login`, {
method: 'POST', method: 'POST',
headers: { 'content-type': 'application/json' }, headers: { 'content-type': 'application/json' },
body: JSON.stringify({ username: 'teacher1', password: 'teacher123' }), body: JSON.stringify(loginBody),
}).then((response) => response.json()); }).then((response) => response.json());
const teacherToken: string | undefined = login?.data?.token; const teacherToken: string | undefined = login?.data?.token;
if (!teacherToken) return { ok: false, detail: `教师登录失败:${JSON.stringify(login).slice(0, 120)}` }; if (!teacherToken) return { ok: false, detail: `教师登录失败:${JSON.stringify(login).slice(0, 120)}` };
@@ -378,6 +469,8 @@ export async function islandRealtimeScenario(): Promise<{
classId, classId,
title, title,
content: '自动化验证:这条通知用于确认「服务端广播 → 客户端实时通道 → 灵动岛」整条链路可用。', content: '自动化验证:这条通知用于确认「服务端广播 → 客户端实时通道 → 灵动岛」整条链路可用。',
// 普通优先级:冒烟客户端登录的是**临时班级**(无课表 → 判定不在上课),
// 普通通知也会立刻弹出胶囊,链路断言与真实上课时段无关。
priority: 'NORMAL', priority: 'NORMAL',
}), }),
}).then((response) => response.json()); }).then((response) => response.json());
@@ -465,10 +558,17 @@ export async function scheduleTimelineSelfTest(): Promise<SmokeCheckResult> {
let teacherToken = ''; let teacherToken = '';
try { try {
const loginBody = teacherLoginBody();
if (!loginBody) {
return {
ok: false,
detail: '未提供冒烟教师凭据(ELECTRON_SMOKE_USER / ELECTRON_SMOKE_PASSWORD),无法构造课表',
};
}
const login = await fetch(`${serverUrl}/api/auth/login`, { const login = await fetch(`${serverUrl}/api/auth/login`, {
method: 'POST', method: 'POST',
headers: { 'content-type': 'application/json' }, headers: { 'content-type': 'application/json' },
body: JSON.stringify({ username: 'teacher1', password: 'teacher123' }), body: JSON.stringify(loginBody),
}).then((response) => response.json()); }).then((response) => response.json());
teacherToken = login?.data?.token ?? ''; teacherToken = login?.data?.token ?? '';
if (!teacherToken) return { ok: false, detail: '教师登录失败' }; if (!teacherToken) return { ok: false, detail: '教师登录失败' };
@@ -613,7 +713,9 @@ export async function homeworkBoardSelfTest(): Promise<SmokeCheckResult> {
// 今天可能恰好没有作业:切到「最近一个有作业的日期」保证看板一定有卡片(断言才有意义)。 // 今天可能恰好没有作业:切到「最近一个有作业的日期」保证看板一定有卡片(断言才有意义)。
// 按天查看支持 ?date=YYYY-MM-DD 深链,切天不需要去操作日期选择器。 // 按天查看支持 ?date=YYYY-MM-DD 深链,切天不需要去操作日期选择器。
if (!document.querySelector('.board-host')) { // 注意判据是「看板里没有卡片」而不是「没有 board-host 容器」——空看板照样渲染容器,
// 拿容器当判据会导致切日期的兜底永远不触发(今天的日期没作业时看板必然为空)。
if (!document.querySelector('.board-card')) {
const [{ homeworkApi }, { useAuthStore }] = await Promise.all([ const [{ homeworkApi }, { useAuthStore }] = await Promise.all([
import('../api/index.js'), import('../api/index.js'),
import('../stores/auth.js'), import('../stores/auth.js'),
@@ -704,6 +806,117 @@ export async function homeworkBoardSelfTest(): Promise<SmokeCheckResult> {
} }
} }
/**
* 冒烟自检(不需要后端):**本机录入的作业不再上灵动岛**(用户要求)。
*
* 场景:教室机器上录完作业,服务端照样广播 `homework:new`,但"自己通知自己"没有意义。
* 判定按**内容指纹 + id**(发起请求前就登记,避免"广播晚于响应"漏判),因此这里两条都要验:
* 1) 登记过的这条:投递后灵动岛状态不变;
* 2) 没登记过的同形作业(别班/别的标题):照常上岛。
*/
export async function islandHomeworkSuppressionCheck(): Promise<SmokeCheckResult> {
const [{ markHomeworkCreatedLocally, isLocalHomework, pushHomeworkToIsland }, { useAuthStore }] =
await Promise.all([import('../island/bridge.js'), import('../stores/auth.js')]);
try {
const classId = useAuthStore().classId ?? 'smoke-class';
const assignDate = '2030-01-01';
const draft = {
id: 'smoke-homework-suppressed',
classId,
title: '本机录入的作业',
content: '这条不应该弹上岛',
assignDate,
};
markHomeworkCreatedLocally(draft);
const recognized = isLocalHomework(draft);
// 同 id、同内容 → 必须认出来;换个标题 → 不算本机录入
const recognizedByFingerprint = isLocalHomework({ ...draft, id: '' });
const foreign = isLocalHomework({ ...draft, id: 'other', title: '别的作业' });
const before = await window.desktop?.islandGetState?.();
pushHomeworkToIsland({
...draft,
courseId: null,
attachmentUrl: null,
createdBy: '',
createdAt: new Date().toISOString(),
} as never);
await new Promise((resolve) => setTimeout(resolve, 400));
const after = await window.desktop?.islandGetState?.();
const untouched =
(before?.active?.id ?? null) === (after?.active?.id ?? null) &&
(before?.queued.length ?? 0) === (after?.queued.length ?? 0);
return {
ok: recognized && recognizedByFingerprint && !foreign && untouched,
detail:
`按 id 认出=${recognized} 按内容指纹认出=${recognizedByFingerprint} 别的作业误判=${foreign} ` +
`投递后灵动岛未变=${untouched}`,
};
} catch (error) {
return {
ok: false,
detail: `本机作业不上岛自检异常:${error instanceof Error ? error.message : String(error)}`,
};
}
}
/**
* 冒烟自检(不需要后端):**初次启动引导**。
*
* 冒烟每次都用全新配置目录(等于"首次启动"),因此引导必须自动弹出;
* 这里真实点击把它一步步走完,断言:遮罩关闭 + `onboardingDone` 已写入配置。
* 关闭判据用「元素从 DOM 消失」——引导是 v-if 自绘遮罩(特意不用 el-dialog,
* 避免"关闭后 DOM 残留在文档里"的误报,见 AGENTS §7 第 22 条)。
*/
export async function onboardingSelfTest(): Promise<SmokeCheckResult> {
try {
// 引导在启动后延迟 ~400ms 弹出,这里轮询等它出现
const appearDeadline = Date.now() + 5000;
while (Date.now() < appearDeadline && !document.querySelector('.onboarding-welcome')) {
await new Promise((resolve) => setTimeout(resolve, 100));
}
if (!document.querySelector('.onboarding-welcome')) {
const config = await window.desktop?.getConfig?.();
return {
ok: false,
detail: `初次启动引导未自动出现(onboardingDone=${config?.onboardingDone ?? '-'})`,
};
}
// 逐页「下一步」到最后一页再点「开始使用」(按钮由 data-action 标识,不依赖文案)
const clicks: string[] = [];
for (let attempt = 0; attempt < 12; attempt += 1) {
const action = document.querySelector('.onboarding-welcome [data-action="finish"]') ? 'finish' : 'next';
const button = document.querySelector<HTMLElement>(`.onboarding-welcome [data-action="${action}"]`);
if (!button) break;
clicks.push(action);
button.click();
if (action === 'finish') break;
await new Promise((resolve) => setTimeout(resolve, 150));
}
let closed = !document.querySelector('.onboarding-welcome');
const closeDeadline = Date.now() + 2000;
while (Date.now() < closeDeadline && !closed) {
await new Promise((resolve) => setTimeout(resolve, 100));
closed = !document.querySelector('.onboarding-welcome');
}
const config = await window.desktop?.getConfig?.();
const done = config?.onboardingDone === true;
return {
ok: closed && done,
detail: `步骤点击=[${clicks.join(',')}] 已关闭=${closed} onboardingDone=${config?.onboardingDone ?? '-'}`,
};
} catch (error) {
return {
ok: false,
detail: `引导自检异常:${error instanceof Error ? error.message : String(error)}`,
};
}
}
/** 冒烟收尾:删除自检临时数据 → 断开实时通道 → 退出登录,保证下次冒烟从登录页开始 */ /** 冒烟收尾:删除自检临时数据 → 断开实时通道 → 退出登录,保证下次冒烟从登录页开始 */
export async function sessionCleanup(): Promise<SmokeCheckResult> { export async function sessionCleanup(): Promise<SmokeCheckResult> {
const [{ useAuthStore }, { useRealtimeStore }] = await Promise.all([ const [{ useAuthStore }, { useRealtimeStore }] = await Promise.all([
@@ -720,6 +933,224 @@ export async function sessionCleanup(): Promise<SmokeCheckResult> {
} }
} }
/**
* 冒烟自检(不需要后端):主界面外观件 —— 主题切换与侧边栏折叠。
* 走**真实 DOM 点击**(顶栏日月按钮 / 汉堡按钮),验证:
* 1) html.dark 类与 store 同步翻转,且写入主进程配置;
* 2) 侧边栏折叠后 el-menu 进入 collapse 态、宽度收窄,配置同步;
* 结束时把主题还原为初始值(后续截图/几何用例依赖固定主题)。
*/
export async function layoutChromeSelfTest(): Promise<SmokeCheckResult> {
try {
const { router } = await import('../router/index.js');
await router.push('/schedule');
if (!(await waitUntil(() => Boolean(document.querySelector('[data-test="theme-toggle"]')), 6000))) {
return { ok: false, detail: '主布局未渲染(找不到主题切换按钮)' };
}
const clickToggle = (selector: string): boolean => {
const node = document.querySelector<HTMLElement>(selector);
if (!node) return false;
node.click();
return true;
};
// 1) 主题:真实点击日月按钮 → html.dark 翻转 → 配置落盘
const initialDark = document.documentElement.classList.contains('dark');
if (!clickToggle('[data-test="theme-toggle"]')) return { ok: false, detail: '主题按钮点击失败' };
const flipped = await waitUntil(
() => document.documentElement.classList.contains('dark') !== initialDark,
2500,
);
const flippedDark = document.documentElement.classList.contains('dark');
const configAfterFlip = await window.desktop?.getConfig?.();
const themePersisted = configAfterFlip?.theme === (flippedDark ? 'dark' : 'light');
// 1.5) 顶栏右侧必须水平对齐(用户反馈"深色模式没对齐",两种主题其实都偏)。
// Element Plus 给按钮的是 `vertical-align:middle`、给下拉容器的是 `vertical-align:top`,
// 容器不是 flex 的话两个 inline-level 子元素会各按各的规则落位,错开几像素。
const centerYOf = (element: Element | null | undefined): number | null => {
if (!element) return null;
const rect = element.getBoundingClientRect();
return rect.height > 0 ? rect.top + rect.height / 2 : null;
};
const themeToggleY = centerYOf(document.querySelector('[data-test="theme-toggle"]'));
const userChipY = centerYOf(document.querySelector('.user-chip'));
const headerCenterDelta =
themeToggleY !== null && userChipY !== null ? Math.abs(themeToggleY - userChipY) : null;
const headerAligned = headerCenterDelta !== null && headerCenterDelta <= 1.5;
// 2) 侧边栏:点汉堡折叠 → 图标导轨态 + 宽度收窄(是动画,要等它走完)→ 配置落盘 → 再展开还原
const asideBefore = document.querySelector<HTMLElement>('.aside.ch-nav');
const widthBefore = asideBefore?.offsetWidth ?? 0;
// 2.0) 折叠必须是**动画**而不是瞬切(用户要求"重写菜单的动画")。
// 不去抓中间帧(时序敏感),直接断言侧栏上挂着 width 的过渡 —— 确定性的。
const asideComputed = asideBefore ? getComputedStyle(asideBefore) : null;
const asideTransitionProperty = asideComputed?.transitionProperty ?? '';
const asideTransitionSeconds = asideComputed ? Number.parseFloat(asideComputed.transitionDuration) : 0;
const widthAnimated =
asideTransitionProperty.includes('width') &&
Number.isFinite(asideTransitionSeconds) &&
asideTransitionSeconds > 0.05;
if (!clickToggle('[data-test="sidebar-toggle"]')) return { ok: false, detail: '汉堡按钮点击失败' };
const collapsed = await waitUntil(() => {
const aside = document.querySelector<HTMLElement>('.aside.ch-nav');
return Boolean(aside?.classList.contains('is-collapsed')) && (aside?.offsetWidth ?? 999) <= 80;
}, 4000);
const asideAfter = document.querySelector<HTMLElement>('.aside.ch-nav');
const widthAfter = asideAfter?.offsetWidth ?? 0;
const configAfterCollapse = await window.desktop?.getConfig?.();
const collapsePersisted = configAfterCollapse?.sidebarCollapsed === true;
// 2.1) 折叠态的两条观感硬要求(用户反馈回归):
// a) 菜单里不允许残留任何**可见**的文字。折叠实现是"文字宽度被 flex 压到 0 + overflow:hidden
// 裁掉 + opacity 归零"(`display:none` 无法过渡,用不了),所以判据是"看得见"
// —— 有宽度且未透明 —— 而不是"根本没参与布局";
// b) 折叠后的图标必须与顶部汉堡按钮在同一竖列(中心 x 相差 ≤ 2px)。
// 分组标题里还有个绝对定位的折叠箭头,它同样带 el-icon 类但已淡出,量它没有意义,排除。
const centerXOf = (element: Element | null | undefined): number | null => {
if (!element) return null;
const rect = element.getBoundingClientRect();
return rect.width > 0 ? rect.left + rect.width / 2 : null;
};
const leftoverText: string[] = [];
for (const node of Array.from(
document.querySelectorAll('.aside .el-menu-item > span, .aside .el-sub-menu__title > span'),
)) {
const element = node as HTMLElement;
if (element.classList.contains('menu-icon-slot')) continue;
const text = (element.textContent ?? '').trim();
if (!text || element.getClientRects().length === 0) continue;
const rect = element.getBoundingClientRect();
const opacity = Number(getComputedStyle(element).opacity || '1');
if (rect.width >= 1 && opacity > 0.05) leftoverText.push(`可见:${text.slice(0, 6)}`);
}
const toggleCenter = centerXOf(document.querySelector('[data-test="sidebar-toggle"]'));
const iconCenters = Array.from(
document.querySelectorAll(
'.aside.is-collapsed .menu-icon-slot .el-icon, ' +
'.aside.is-collapsed .el-sub-menu__title > .el-icon:not([class*="icon-arrow"])',
),
).map((node) => centerXOf(node));
const iconDeltas = iconCenters
.filter((value): value is number => value !== null && toggleCenter !== null)
.map((value) => Math.abs(value - (toggleCenter as number)));
const iconsAligned = iconDeltas.length > 0 && Math.max(...iconDeltas) <= 2;
// 2.2) 导轨必须"一眼看全":先把设置组展开(11 行图标 = 最坏情况),再断言菜单区没有纵向溢出。
// 折叠态页脚必须把**高度**也收成 0 —— 只淡出不留高度的话,那 ~70px 会把最后两个图标
// 顶出可视区,用户就得上下滑动(反馈原话:"菜单图标无法完全显示需要上下滑动")。
const settingsItem = Array.from(
document.querySelectorAll<HTMLElement>('.aside .el-sub-menu .el-menu-item'),
).find((element) =>
Array.from(element.querySelectorAll('span')).some((span) => (span.textContent ?? '').trim() === '通用'),
);
const submenuOpen = (): boolean => Boolean(settingsItem && settingsItem.offsetParent !== null);
if (!submenuOpen()) {
// el-sub-menu__title 的点击是 **toggle**:先判"子项是否可见"再点,
// 盲点一次会把已展开的组收起来(AGENTS §5 第 49 条)
document.querySelector<HTMLElement>('.aside .el-sub-menu__title')?.click();
await waitUntil(() => submenuOpen(), 2000);
}
const railMenu = document.querySelector<HTMLElement>('.aside .menu');
const railOverflowPx = railMenu ? railMenu.scrollHeight - railMenu.clientHeight : Number.NaN;
const railFits = Number.isFinite(railOverflowPx) && railOverflowPx <= 1;
clickToggle('[data-test="sidebar-toggle"]');
// 展开同样是动画:等宽度回到 200 再继续,否则下面量页脚时侧栏还停在中间宽度
const expandedBack = await waitUntil(() => {
const aside = document.querySelector<HTMLElement>('.aside.ch-nav');
return !aside?.classList.contains('is-collapsed') && (aside?.offsetWidth ?? 0) >= 190;
}, 4000);
// 3) 侧栏不溢出:菜单区自己滚动(.menu 有 min-height:0 + overflow-y:auto),
// 底部「第 N 周 / 最近同步」始终留在窗口内 —— 窗口默认高 582px,
// 在加这条结构性保证之前,两个分组全展开会把 footer 挤出屏幕(用户反馈)。
const footer = document.querySelector<HTMLElement>('.aside-footer');
const footerRect = footer?.getBoundingClientRect();
const footerVisible =
Boolean(footer && footer.offsetParent !== null) &&
Boolean(footerRect && footerRect.bottom <= window.innerHeight + 1);
// 3) 还原主题,避免影响后续用例
clickToggle('[data-test="theme-toggle"]');
await waitUntil(() => document.documentElement.classList.contains('dark') === initialDark, 2500);
const ok =
flipped &&
themePersisted &&
headerAligned &&
widthAnimated &&
collapsed &&
collapsePersisted &&
widthAfter < widthBefore &&
widthAfter <= 80 &&
expandedBack &&
leftoverText.length === 0 &&
iconsAligned &&
railFits &&
footerVisible;
return {
ok,
detail:
`主题翻转=${flipped} 落盘=${themePersisted}(${configAfterFlip?.theme ?? '-'}) ` +
`顶栏对齐=${headerAligned}(中线差=${headerCenterDelta === null ? '-' : headerCenterDelta.toFixed(1)}px,要求 ≤1.5px) ` +
`宽度过渡=${widthAnimated}(${asideTransitionProperty} ${asideTransitionSeconds}s) ` +
`折叠=${collapsed} 宽度=${widthBefore}→${widthAfter} 展开还原=${expandedBack} 落盘=${collapsePersisted} ` +
`文字残影=${leftoverText.length === 0 ? '无' : leftoverText.join(',')} ` +
`图标与汉堡同列=${iconsAligned}(中心差=${iconDeltas.map((d) => d.toFixed(1)).join('/') || '-'},要求 ≤2px) ` +
`导轨无溢出=${railFits}(溢出=${Number.isFinite(railOverflowPx) ? `${railOverflowPx}px` : '-'}) ` +
`侧栏底部可见=${footerVisible}`,
};
} catch (error) {
return {
ok: false,
detail: `外观件自检异常:${error instanceof Error ? error.message : String(error)}`,
};
}
}
/**
* 冒烟自检(不需要后端):关于页(/settings/about)。
* 断言页面渲染出标题与「鸣谢 / 诊断信息」区块,且 getAppInfo 返回了新增的 configPath
* (诊断信息依赖它)。
*/
export async function aboutPageSelfTest(): Promise<SmokeCheckResult> {
try {
const { router } = await import('../router/index.js');
await router.push('/settings/about');
const rendered = await waitUntil(
() => (document.querySelector('.page-title')?.textContent ?? '').includes('关于'),
6000,
);
if (!rendered) return { ok: false, detail: '关于页未挂载' };
const text = document.body.innerText.replace(/\s+/g, ' ');
const hasThanks = text.includes('鸣谢');
const hasDiagnostics = text.includes('诊断信息');
const info = await window.desktop?.getAppInfo?.();
const hasConfigPath = Boolean(info?.configPath);
// 检查更新入口(新功能回归):关于页要有这一块,且按钮可点。
// 这里只断言"入口存在"——是否真有新版本取决于 GitHub,不该绑进冒烟(见 main/update.ts)
const updateBlock = document.querySelector('[data-test="update-check"]');
const updateButton = document.querySelector('[data-test="update-check-button"]');
await router.push('/schedule');
return {
ok: hasThanks && hasDiagnostics && hasConfigPath && Boolean(updateBlock) && Boolean(updateButton),
detail:
`鸣谢=${hasThanks} 诊断=${hasDiagnostics} configPath=${hasConfigPath ? '有' : '无'} ` +
`检查更新块=${updateBlock ? '有' : '无'} 按钮=${updateButton ? '有' : '无'}`,
};
} catch (error) {
return {
ok: false,
detail: `关于页自检异常:${error instanceof Error ? error.message : String(error)}`,
};
}
}
/** 注册到 window,供主进程冒烟脚本调用 */ /** 注册到 window,供主进程冒烟脚本调用 */
export function registerSmokeHooks(): void { export function registerSmokeHooks(): void {
window.__classhelperSmoke__ = { window.__classhelperSmoke__ = {
@@ -730,6 +1161,10 @@ export function registerSmokeHooks(): void {
islandRealtimeScenario, islandRealtimeScenario,
islandRealtimeCleanup, islandRealtimeCleanup,
islandReadState, islandReadState,
islandHomeworkSuppressionCheck,
onboardingSelfTest,
layoutChromeSelfTest,
aboutPageSelfTest,
scheduleTimelineSelfTest, scheduleTimelineSelfTest,
homeworkBoardSelfTest, homeworkBoardSelfTest,
sessionCleanup, sessionCleanup,
@@ -0,0 +1,311 @@
<script setup lang="ts">
import { computed, onUnmounted, ref, watch } from 'vue';
import { useOnboardingStore } from '../stores/onboarding.js';
/**
* 初次启动引导(六步向导)。
*
* - 首次启动自动弹出(App.vue 按 `onboardingDone` 判定);完成 / 跳过(右上角按钮 / Esc)
* 都算看过,由这里写入主进程配置,之后不再自动弹出。
* - 登录页与设置页的「使用引导」入口可随时重看(重看关闭时再写一次也无副作用)。
* - **用 v-if 自绘遮罩而不是 el-dialog**:关闭即从 DOM 卸载。冒烟断言"引导已关闭"时
* 不会踩 el-dialog「DOM 残留在文档里」的坑(AGENTS §7 第 22 条)。
* - 操作按钮用 `data-action` 标识(prev/next/finish/skip),冒烟点击不依赖按钮文案。
*/
const onboarding = useOnboardingStore();
const steps = [
{
icon: 'School',
title: '欢迎使用班级小助手',
lines: [
'这台电脑将以「班级」的身份使用班级小助手:实时接收课表、作业、通知与成绩。',
'第一次使用,先花半分钟看看怎么开始。',
],
},
{
icon: 'Link',
title: '第一步 · 连接服务器',
lines: [
'在登录页填写老师或管理员提供的服务器地址(通常形如 http://192.168.x.x:4000)。',
'点「测试连接」确认可达;以后也能在「设置」里随时修改。',
],
},
{
icon: 'Key',
title: '第二步 · 登录班级',
lines: [
'使用班级码 + 班级密码登录(向老师或管理员索取)。',
'登录后这台设备就代表全班:作业完成、通知已读都会按全班记录,不需要每个学生单独登录。',
],
},
{
icon: 'Calendar',
title: '登录之后',
lines: [
'左侧菜单切换「课表 / 作业 / 通知 / 成绩」四个页面,作业支持看板全屏展示。',
'断网时自动显示最近同步的缓存数据,联网后自动更新。',
],
},
{
icon: 'Bell',
title: '灵动岛提醒',
lines: [
'屏幕上方会有一条「灵动岛」浮窗:新通知、叫人、作业都会在那里弹出。',
'上课时段自动隐藏、下课自动弹出;外观与位置可在「设置 → 灵动岛」调整。',
],
},
{
icon: 'CircleCheckFilled',
title: '准备好了',
lines: [
'按上面的步骤登录就可以开始使用了。',
'侧边栏「设置」分组里有通用、外观(深色模式)、灵动岛等页面;这份引导可以在登录页或「设置 → 通用 → 使用引导」随时重看。',
],
},
];
const index = ref(0);
const current = computed(() => steps[index.value] ?? steps[0]);
const isFirst = computed(() => index.value === 0);
const isLast = computed(() => index.value === steps.length - 1);
/** 每次打开都从第一步开始(重看入口也走完整流程) */
watch(
() => onboarding.visible,
(visible) => {
if (visible) index.value = 0;
},
);
function goNext(): void {
if (isLast.value) finish();
else index.value += 1;
}
function goPrev(): void {
if (!isFirst.value) index.value -= 1;
}
/** 完成 / 跳过统一走这里:记「已看过」并关闭(重看时重复写一次无副作用) */
function finish(): void {
const bridge = window.desktop;
// 桥接不可用(浏览器调试)也要能正常关掉引导
if (!bridge) {
onboarding.close();
return;
}
void bridge
.saveConfig({ onboardingDone: true })
.then(() => onboarding.close())
.catch(() => onboarding.close());
}
function onKeydown(event: KeyboardEvent): void {
if (event.key === 'Escape') finish();
}
if (typeof window !== 'undefined') {
window.addEventListener('keydown', onKeydown);
}
onUnmounted(() => {
window.removeEventListener('keydown', onKeydown);
});
</script>
<template>
<Transition name="onboarding-fade">
<div
v-if="onboarding.visible"
class="onboarding-mask"
role="dialog"
aria-modal="true"
aria-label="初次启动引导"
>
<div class="onboarding-card onboarding-welcome">
<div class="onboarding-head">
<span class="onboarding-logo">
<el-icon :size="18"><School /></el-icon>
</span>
<div class="onboarding-heading">
<h2 class="onboarding-title">班级小助手</h2>
<p class="onboarding-sub">初次启动引导 · 第 {{ index + 1 }} / {{ steps.length }} 步</p>
</div>
<el-button link class="onboarding-skip" data-action="skip" @click="finish">跳过引导</el-button>
</div>
<div class="onboarding-body">
<span class="onboarding-icon">
<el-icon :size="30"><component :is="current.icon" /></el-icon>
</span>
<h3 class="onboarding-step-title">{{ current.title }}</h3>
<p v-for="(line, lineIndex) in current.lines" :key="lineIndex" class="onboarding-line">
{{ line }}
</p>
</div>
<div class="onboarding-foot">
<div class="onboarding-dots">
<span
v-for="(step, dotIndex) in steps"
:key="dotIndex"
class="dot"
:class="{ active: dotIndex === index }"
/>
</div>
<div class="onboarding-actions">
<el-button v-if="!isFirst" data-action="prev" @click="goPrev">上一步</el-button>
<el-button v-if="!isLast" type="primary" data-action="next" @click="goNext">
下一步
</el-button>
<el-button v-else type="primary" data-action="finish" @click="finish">开始使用</el-button>
</div>
</div>
</div>
</div>
</Transition>
</template>
<style scoped>
.onboarding-mask {
position: fixed;
inset: 0;
z-index: 3000;
display: flex;
align-items: center;
justify-content: center;
padding: 24px;
background: rgba(15, 30, 50, 0.55);
}
.onboarding-card {
width: 520px;
max-width: 92vw;
max-height: 86vh;
overflow-y: auto;
background: var(--ch-layer-solid);
border-radius: 16px;
padding: 22px 24px 18px;
box-shadow: 0 24px 64px rgba(15, 30, 50, 0.35);
}
.onboarding-head {
display: flex;
align-items: center;
gap: 10px;
}
.onboarding-logo {
display: inline-flex;
align-items: center;
justify-content: center;
width: 34px;
height: 34px;
border-radius: 9px;
color: #fff;
background: linear-gradient(135deg, var(--ch-accent) 0%, #4d94d1 100%);
}
.onboarding-heading {
flex: 1;
min-width: 0;
}
.onboarding-title {
margin: 0;
font-size: 15px;
line-height: 1.3;
}
.onboarding-sub {
margin: 2px 0 0;
font-size: 12px;
color: var(--ch-text-tertiary);
}
.onboarding-body {
display: flex;
flex-direction: column;
align-items: flex-start;
padding: 18px 4px 6px;
}
.onboarding-icon {
display: inline-flex;
align-items: center;
justify-content: center;
width: 58px;
height: 58px;
border-radius: 16px;
margin-bottom: 14px;
color: var(--ch-accent);
background: var(--ch-accent-soft);
}
.onboarding-step-title {
margin: 0 0 10px;
font-size: 18px;
}
.onboarding-line {
margin: 0 0 8px;
font-size: 13px;
line-height: 1.8;
color: var(--ch-text-regular, #606266);
}
.onboarding-foot {
display: flex;
align-items: center;
justify-content: space-between;
gap: 12px;
margin-top: 14px;
padding-top: 14px;
border-top: 1px solid var(--ch-divider);
}
.onboarding-dots {
display: flex;
align-items: center;
gap: 6px;
}
.dot {
width: 7px;
height: 7px;
border-radius: 999px;
background: var(--ch-border-strong);
transition: all 0.2s ease;
}
.dot.active {
width: 20px;
background: var(--ch-accent);
}
.onboarding-actions {
display: flex;
align-items: center;
gap: 8px;
}
/* 进出场:淡入 + 轻微上浮,跟随系统"动画"开关无强依赖 */
.onboarding-fade-enter-active,
.onboarding-fade-leave-active {
transition: opacity 0.22s ease;
}
.onboarding-fade-enter-active .onboarding-card,
.onboarding-fade-leave-active .onboarding-card {
transition: transform 0.22s ease;
}
.onboarding-fade-enter-from,
.onboarding-fade-leave-to {
opacity: 0;
}
.onboarding-fade-enter-from .onboarding-card,
.onboarding-fade-leave-to .onboarding-card {
transform: translateY(10px) scale(0.98);
}
</style>
@@ -0,0 +1,193 @@
<script setup lang="ts">
import { computed } from 'vue';
/**
* 轻量柱状图(纯 HTML/CSS,不依赖任何图表库)。
*
* 为什么不用 echarts:成绩页只需要「分组柱 + 数值标签 + 坐标轴」这点东西,
* 而 `import * as echarts from 'echarts'` 会给渲染产物加 1.1MB(客户端里最大的一块),
* 按需引入 echarts/core 也仍有约 500KB。
*
* 实现要点(决定了这里为什么不需要 resize 监听):
* - 柱高用**百分比**:`.bar-track` 是行方向 flex 里 `flex:1` 的子项,高度确定,
* 柱子的 `height: X%` 直接按它解析;
* - 刻度与网格线用**零高度 flex 行 + `justify-content: space-between`**:
* 零高度元素的中心正好落在 i/(N-1) 处,与柱状区上下边界精确对齐;
* - 纵轴刻度列与绘图区共用同一套上下留白(数值行 18px / 标签行 30px),因此永远对齐。
*/
interface BarItem {
label: string;
value: number;
}
const props = withDefaults(
defineProps<{
/** 每根柱:分类名 + 数值(0 ~ max) */
items: BarItem[];
/** 柱色 */
color?: string;
/** 纵轴上限 */
max?: number;
/** 数值单位(显示在刻度与柱顶数值后面) */
unit?: string;
/** 图表高度(px) */
height?: number;
}>(),
{ color: '#409eff', max: 100, unit: '%', height: 300 },
);
/** 纵轴刻度(自上而下):100 / 75 / 50 / 25 / 0(按 max 换算) */
const ticks = computed(() => [1, 0.75, 0.5, 0.25, 0].map((ratio) => Math.round(props.max * ratio)));
function barHeight(value: number): string {
const ratio = props.max > 0 ? value / props.max : 0;
return `${Math.min(1, Math.max(0, ratio)) * 100}%`;
}
function formatValue(value: number): string {
return `${Number.isInteger(value) ? value : value.toFixed(1)}${props.unit}`;
}
</script>
<template>
<div class="bar-chart" :style="{ height: `${height}px` }">
<div v-if="items.length === 0" class="bar-chart-empty">暂无数据</div>
<template v-else>
<div class="axis-y" aria-hidden="true">
<span v-for="tick in ticks" :key="tick" class="tick">{{ tick }}{{ unit }}</span>
</div>
<div class="plot">
<div class="gridlines" aria-hidden="true">
<span v-for="tick in ticks" :key="tick" class="gridline"></span>
</div>
<div class="bars">
<div v-for="item in items" :key="item.label" class="bar-col">
<div class="bar-value">{{ formatValue(item.value) }}</div>
<div class="bar-track">
<div
class="bar"
:style="{ height: barHeight(item.value), background: color }"
:title="`${item.label}:${formatValue(item.value)}`"
></div>
</div>
<div class="bar-label" :title="item.label">{{ item.label }}</div>
</div>
</div>
</div>
</template>
</div>
</template>
<style scoped>
.bar-chart {
display: grid;
grid-template-columns: 46px 1fr;
width: 100%;
}
.bar-chart-empty {
grid-column: 1 / -1;
display: flex;
align-items: center;
justify-content: center;
height: 100%;
font-size: 13px;
color: var(--ch-text-tertiary);
}
/* 纵轴刻度:上下留白与 .bars 里的数值行 / 标签行一一对应 */
.axis-y {
display: flex;
flex-direction: column;
justify-content: space-between;
padding: 18px 0 30px;
}
.tick {
height: 0;
display: flex;
align-items: center;
justify-content: flex-end;
padding-right: 8px;
font-size: 11px;
line-height: 1;
white-space: nowrap;
color: var(--ch-text-tertiary);
}
.plot {
position: relative;
min-width: 0;
}
.gridlines {
position: absolute;
inset: 18px 0 30px;
display: flex;
flex-direction: column;
justify-content: space-between;
pointer-events: none;
}
.gridline {
height: 0;
border-top: 1px solid var(--ch-border);
}
.bars {
display: flex;
align-items: stretch;
gap: 10px;
height: 100%;
padding: 0 6px;
}
.bar-col {
flex: 1 1 0;
min-width: 0;
display: flex;
flex-direction: column;
height: 100%;
}
.bar-value {
flex: none;
height: 18px;
font-size: 11px;
line-height: 1;
text-align: center;
white-space: nowrap;
overflow: hidden;
color: var(--ch-text-secondary);
}
.bar-track {
flex: 1 1 auto;
min-height: 0;
display: flex;
align-items: flex-end;
justify-content: center;
}
.bar {
width: 100%;
max-width: 46px;
border-radius: 4px 4px 0 0;
transition: height 0.2s ease;
}
.bar-label {
flex: none;
height: 30px;
padding-top: 6px;
font-size: 11px;
line-height: 1.3;
text-align: center;
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis;
color: var(--ch-text-secondary);
}
</style>
@@ -0,0 +1,94 @@
import type { App } from 'vue';
import {
AlarmClock,
ArrowDown,
ArrowLeft,
ArrowRight,
Bell,
Brush,
Calendar,
CircleCheckFilled,
Connection,
Expand,
Fold,
FullScreen,
Guide,
InfoFilled,
Key,
Link,
Loading,
Lock,
MagicStick,
Moon,
Notebook,
Plus,
Pointer,
Refresh,
School,
Setting,
Sunny,
SwitchButton,
Tools,
Trophy,
UserFilled,
Warning,
} from '@element-plus/icons-vue';
/**
* Element Plus 图标注册表(桌面客户端渲染进程)。
*
* **为什么不 `import * as ElementPlusIconsVue` 全量注册**:
* 图标库有 293 个组件(实测全量打包 minified 203KB,实际用到的只有 33 个),
* 全量注册既把死代码打进主 chunk,又要在启动时执行 293 次 `app.component()`。
*
* **为什么不改成模板里逐个 import**:本项目的图标是按**字符串名**引用的
* (`ClientLayout.vue` 的菜单配置 `icon: 'Setting'`、`OnboardingWelcome.vue` 的引导步骤、
* 按钮上的 `:icon="'FullScreen'"`、`<component :is="item.icon">`),Element Plus 会用
* `<component :is="'Setting'">` 去解析**全局组件名**,因此图标必须以全局组件存在。
*
* 新增视图时若用了新图标,`scripts/check-icons.mjs` 会在构建前报错,
* 不会静默渲染成空白。
*/
const APP_ICONS = {
AlarmClock,
ArrowDown,
ArrowLeft,
ArrowRight,
Bell,
Brush,
Calendar,
CircleCheckFilled,
Connection,
Expand,
Fold,
FullScreen,
Guide,
InfoFilled,
Key,
Link,
Loading,
Lock,
MagicStick,
Moon,
Notebook,
Plus,
Pointer,
Refresh,
School,
Setting,
Sunny,
SwitchButton,
Tools,
Trophy,
UserFilled,
Warning,
} as const;
/** 供 `scripts/check-icons.mjs` 读取的名单(构建期静态校验用) */
export const APP_ICON_NAMES: readonly string[] = Object.keys(APP_ICONS).sort();
export function registerAppIcons(app: App): void {
for (const [name, component] of Object.entries(APP_ICONS)) {
app.component(name, component);
}
}
@@ -92,6 +92,11 @@ export function pushNotificationToIsland(notification: NotificationDto): void {
/** 新作业上岛(homework:new):胶囊提示"新作业",点击展开看作业要求 */ /** 新作业上岛(homework:new):胶囊提示"新作业",点击展开看作业要求 */
export function pushHomeworkToIsland(homework: HomeworkDto): void { export function pushHomeworkToIsland(homework: HomeworkDto): void {
// 本机刚录入的作业不再上岛:教室机器上录作业的人就是眼前这台设备的主人,
// 再弹一张"新作业"卡片纯属自己通知自己(用户反馈)。
if (isLocalHomework(homework)) {
return;
}
window.desktop?.islandPush({ window.desktop?.islandPush({
notification: { notification: {
id: `homework-${homework.id}`, id: `homework-${homework.id}`,
@@ -107,6 +112,62 @@ export function pushHomeworkToIsland(homework: HomeworkDto): void {
}); });
} }
/* ------------------------------------------------------------ 本机录入的作业 */
/**
* 本机刚录入的作业指纹。
*
* 为什么按指纹而不只按 id:`homework:new` 是服务端**先广播、后回响应**的,
* 录入接口返回的 id 很可能比实时事件到得还晚 —— 只记 id 会漏掉"事件先到"的那一半,
* 于是本机录的作业照样弹上岛。因此在发请求**之前**就按内容记一份指纹,
* 回来后补记 id(覆盖事件晚到的情况)。指纹带 TTL,避免长期占用内存。
*/
const localHomeworkKeys = new Set<string>();
let localHomeworkKeysAt = 0;
const LOCAL_HOMEWORK_TTL_MS = 60_000;
/** 作业内容指纹:同一班、同一天、同标题同正文 = 就是本机刚录的那条 */
function homeworkFingerprint(homework: {
classId?: string | null;
title?: string | null;
content?: string | null;
assignDate?: string | null;
}): string {
return [
homework.classId ?? '',
homework.assignDate ?? '',
(homework.title ?? '').trim(),
(homework.content ?? '').trim(),
].join('|');
}
/** 录入前/后登记"这条作业是本机录的"(id 可后补) */
export function markHomeworkCreatedLocally(homework: {
id?: string | null;
classId?: string | null;
title?: string | null;
content?: string | null;
assignDate?: string | null;
}): void {
const now = Date.now();
if (now - localHomeworkKeysAt > LOCAL_HOMEWORK_TTL_MS) localHomeworkKeys.clear();
localHomeworkKeysAt = now;
localHomeworkKeys.add(homeworkFingerprint(homework));
if (homework.id) localHomeworkKeys.add(homework.id);
}
/** 这条作业是不是本机刚录的(供投递前判定与冒烟验证) */
export function isLocalHomework(homework: {
id?: string | null;
classId?: string | null;
title?: string | null;
content?: string | null;
assignDate?: string | null;
}): boolean {
if (homework.id && localHomeworkKeys.has(homework.id)) return true;
return localHomeworkKeys.has(homeworkFingerprint(homework));
}
/** /**
* "叫人"上岛:紧急叫人(priority=URGENT)无视上课时段立即展开; * "叫人"上岛:紧急叫人(priority=URGENT)无视上课时段立即展开;
* 普通叫人按普通通知处理(课间先显示胶囊、点击展开,上课时段只排队)。 * 普通叫人按普通通知处理(课间先显示胶囊、点击展开,上课时段只排队)。
@@ -148,15 +209,40 @@ export function subscribeIslandMarkRead(): void {
}); });
} }
/**
* 灵动岛点了"标为已读"(多条通知的整批)→ 把这一批都在通知中心里标记已读。
* 与单条版本同一套兜底:离线时先在本地记为已读。
*/
export function subscribeIslandMarkAllRead(): void {
window.desktop?.onIslandMarkAllRead?.((ids) => {
void (async () => {
const store = useNotificationStore();
await Promise.all(
(ids ?? []).map(async (id) => {
try {
await store.markRead(id);
} catch {
const target = store.items.find((item) => item.id === id);
if (target) target.read = true;
}
}),
);
})();
});
}
/** 具名的课表变更处理器:匿名函数在停止时无法 off 掉,会随"登出→登录"越挂越多 */
function onScheduleUpdated(): void {
void refreshIslandSchedules().catch(() => undefined);
}
export function startIslandBridge(): void { export function startIslandBridge(): void {
if (tickTimer) return; if (tickTimer) return;
void refreshIslandSchedules().catch(() => undefined); void refreshIslandSchedules().catch(() => undefined);
// 课表变更(教师改课)立即复算,避免"下课后不弹出"或"上课没隐藏" // 课表变更(教师改课)立即复算,避免"下课后不弹出"或"上课没隐藏"
useRealtimeStore().on(SOCKET_EVENTS.scheduleUpdated, () => { useRealtimeStore().on(SOCKET_EVENTS.scheduleUpdated, onScheduleUpdated);
void refreshIslandSchedules().catch(() => undefined);
});
tickTimer = setInterval(() => recomputeClassState(), TICK_INTERVAL_MS); tickTimer = setInterval(() => recomputeClassState(), TICK_INTERVAL_MS);
refreshTimer = setInterval(() => { refreshTimer = setInterval(() => {
@@ -164,9 +250,31 @@ export function startIslandBridge(): void {
}, REFRESH_INTERVAL_MS); }, REFRESH_INTERVAL_MS);
} }
/**
* 停止桥接:退出登录 / 切换账号时必须调用。
*
* 只清定时器是不够的:
* - 订阅要 off,否则每次"登出 → 登录"都会多挂一份监听;
* - 本地课表缓存要清空,否则登出后仍会按**上一个班**的课表继续给主进程下发"上课/下课"
* (灵动岛按陈旧课表隐藏或弹出),换班登录时第一轮刷新回来之前用的也是旧课表。
*/
export function stopIslandBridge(): void { export function stopIslandBridge(): void {
if (tickTimer) clearInterval(tickTimer); if (tickTimer) clearInterval(tickTimer);
if (refreshTimer) clearInterval(refreshTimer); if (refreshTimer) clearInterval(refreshTimer);
tickTimer = null; tickTimer = null;
refreshTimer = null; refreshTimer = null;
useRealtimeStore().off(SOCKET_EVENTS.scheduleUpdated, onScheduleUpdated);
schedules = [];
currentPeriod = null;
inClass = false;
// 把"不在上课"同步给主进程:否则主进程还记着上一个会话的"上课中",
// 重新登录后若第一轮课表刷新失败(离线且无缓存),灵动岛会继续按上课态把通知压着不弹,
// 直到下一次刷新成功为止。这里主动对齐一次,代价是登出瞬间可能补弹一条此前被暂存的通知。
window.desktop?.islandSetClassState({
inClass: false,
currentPeriodEnd: null,
week: useAppStore().currentWeek,
});
} }
@@ -1,12 +1,14 @@
<script setup lang="ts"> <script setup lang="ts">
import { computed, onMounted, onUnmounted } from 'vue'; import { computed, nextTick, onMounted, onUnmounted, ref, watch } from 'vue';
import { useRoute, useRouter } from 'vue-router'; import { useRoute, useRouter } from 'vue-router';
import { ElMessage, ElMessageBox } from 'element-plus'; import { ElMessage, ElMessageBox, type MenuInstance } from 'element-plus';
import { SOCKET_EVENTS, type NotificationDto } from '@classhelper/shared'; import { SOCKET_EVENTS, type NotificationDto } from '@classhelper/shared';
import { startIslandBridge, stopIslandBridge } from '../island/bridge.js';
import { useAppStore } from '../stores/app.js'; import { useAppStore } from '../stores/app.js';
import { useAuthStore } from '../stores/auth.js'; import { useAuthStore } from '../stores/auth.js';
import { useNotificationStore } from '../stores/notifications.js'; import { useNotificationStore } from '../stores/notifications.js';
import { useRealtimeStore } from '../stores/realtime.js'; import { useRealtimeStore } from '../stores/realtime.js';
import { useUiStore } from '../stores/ui.js';
const route = useRoute(); const route = useRoute();
const router = useRouter(); const router = useRouter();
@@ -14,18 +16,77 @@ const appStore = useAppStore();
const auth = useAuthStore(); const auth = useAuthStore();
const realtime = useRealtimeStore(); const realtime = useRealtimeStore();
const notifications = useNotificationStore(); const notifications = useNotificationStore();
const ui = useUiStore();
const menuItems = [ /**
* 主侧边栏。
*
* - **一级项**:课表 / 作业 / 通知 / 成绩 —— 直接铺在侧栏上,**不再套「学习」分组**。
* 分组标题白占一行、还得多点一次展开,折叠成图标导轨时尤其明显(用户要求拆掉)。
* - **分组**:只剩「设置」(通用 / 外观 / 灵动岛 / 提醒 / 账号 / 关于,各自是独立路由)。
* 6 个子项平铺太长,保留分组与"默认只展开当前路由所在分组"。折叠后是图标导轨,
* 分组子项与一级项一样以图标列出(见 styles/index.css 的折叠态规则)。
*
* 顶栏左侧汉堡按钮把整栏收成图标导轨(状态持久化在主进程配置里)。
*/
const primaryItems = [
{ path: '/schedule', title: '课表', icon: 'Calendar' }, { path: '/schedule', title: '课表', icon: 'Calendar' },
{ path: '/homeworks', title: '作业', icon: 'Notebook' }, { path: '/homeworks', title: '作业', icon: 'Notebook' },
{ path: '/notifications', title: '通知', icon: 'Bell' }, { path: '/notifications', title: '通知', icon: 'Bell' },
{ path: '/grades', title: '成绩', icon: 'Trophy' }, { path: '/grades', title: '成绩', icon: 'Trophy' },
{ path: '/settings', title: '设置', icon: 'Setting' },
]; ];
const menuGroups = [
{
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' },
],
},
];
/** 未读红点挂在「通知」项的图标右上角 */
function showBadge(path: string): boolean {
return path === '/notifications' && notifications.unreadCount > 0;
}
/** 高亮当前菜单:直接比较路由路径,避免依赖路由名 */ /** 高亮当前菜单:直接比较路由路径,避免依赖路由名 */
const activeMenu = computed(() => route.path); const activeMenu = computed(() => route.path);
/** 当前路由所属的分组标题(用于"只默认展开所在分组",与 ClassIsland 一致) */
const activeGroupTitle = computed(() => {
const group = menuGroups.find((item) => item.items.some((entry) => route.path === entry.path));
// 落在**一级项**(课表/作业/通知/成绩)上没有所属分组 —— 返回 null,别拿某个组的名字顶上去
return group?.title ?? null;
});
/**
* 分组展开控制:默认只展开**当前路由所在的分组**(一级项不属于任何分组,此时一个都不展开)。
*
* 窗口默认高度与 ClassIsland 对齐(582px),设置组 6 个子项展开后会超出可视高度、
* 把底部的「账号 / 关于」挤出屏幕;只展开当前组既符合 ClassIsland 的观感(它也只展开当前组),
* 又让小窗口下的侧栏始终完整可见。用户手动展开其它分组不受限制(可多个同时展开)。
*/
const menuRef = ref<MenuInstance>();
const openedGroups = ref<string[]>(activeGroupTitle.value ? [activeGroupTitle.value] : []);
watch(
() => route.path,
async (path) => {
const group = menuGroups.find((item) => item.items.some((entry) => path === entry.path));
if (!group) return;
// 展开当前组(不主动关闭用户已展开的其它组)
await nextTick();
menuRef.value?.open(group.title);
},
);
/** /**
* 菜单点击回调。 * 菜单点击回调。
* 注意:el-menu 的 @select 抛出的是 index(这里即路由路径), * 注意:el-menu 的 @select 抛出的是 index(这里即路由路径),
@@ -43,9 +104,11 @@ function go(name: string): void {
/** 开发期自检:菜单路径必须存在于路由表中 */ /** 开发期自检:菜单路径必须存在于路由表中 */
if (import.meta.env.DEV) { if (import.meta.env.DEV) {
const knownPaths = new Set(router.getRoutes().map((item) => item.path)); const knownPaths = new Set(router.getRoutes().map((item) => item.path));
for (const item of menuItems) { for (const group of menuGroups) {
if (!knownPaths.has(item.path)) { for (const item of group.items) {
console.error(`[ClientLayout] 菜单项未注册对应路由:${item.path}`); if (!knownPaths.has(item.path)) {
console.error(`[ClientLayout] 菜单项未注册对应路由:${item.path}`);
}
} }
} }
} }
@@ -70,10 +133,14 @@ async function handleLogout(): Promise<void> {
void router.push({ name: 'login' }); void router.push({ name: 'login' });
} }
/** 通知实时推送:更新列表 + 红点 + 缓存 */ /**
* 通知实时推送:更新通知中心列表与红点。
*
* 这里**不再**额外弹一条"收到新通知"的 toast —— `stores/realtime.ts` 收到
* notification:new 时已经弹过带优先级与标题的那条,两条堆在屏幕上纯属噪音。
*/
function onNotification(payload: unknown): void { function onNotification(payload: unknown): void {
void notifications.pushRealtime(payload as NotificationDto); void notifications.pushRealtime(payload as NotificationDto);
ElMessage({ message: '收到新通知,点击「通知」查看', type: 'info', duration: 3000 });
} }
/** 服务器从不可达恢复为可达:自动同步一次(联网后自动同步) */ /** 服务器从不可达恢复为可达:自动同步一次(联网后自动同步) */
@@ -87,30 +154,58 @@ onMounted(async () => {
await notifications.refreshUnreadCount(); await notifications.refreshUnreadCount();
realtime.on(SOCKET_EVENTS.notificationNew, onNotification); realtime.on(SOCKET_EVENTS.notificationNew, onNotification);
appStore.onServerRecovered(onRecovered); appStore.onServerRecovered(onRecovered);
// 灵动岛桥接跟着"已登录布局"的生命周期走:这样退出登录会随布局卸载而停止,
// 重新登录(或换班登录)时又会重新启动,不会拿旧课表算上课状态。
if (auth.token) startIslandBridge();
}); });
onUnmounted(() => { onUnmounted(() => {
realtime.off(SOCKET_EVENTS.notificationNew, onNotification); realtime.off(SOCKET_EVENTS.notificationNew, onNotification);
appStore.offServerRecovered(onRecovered); appStore.offServerRecovered(onRecovered);
stopIslandBridge();
}); });
</script> </script>
<template> <template>
<el-container class="layout"> <el-container class="layout">
<el-aside width="200px" class="aside ch-nav"> <el-aside
:width="ui.sidebarCollapsed ? '64px' : '200px'"
class="aside ch-nav"
:class="{ 'is-collapsed': ui.sidebarCollapsed }"
>
<div class="brand"> <div class="brand">
<button
type="button"
class="nav-toggle"
aria-label="折叠或展开侧边栏"
:aria-expanded="ui.sidebarCollapsed ? 'false' : 'true'"
data-test="sidebar-toggle"
@click="ui.toggleSidebar()"
>
<el-icon :size="16"><Expand v-if="ui.sidebarCollapsed" /><Fold v-else /></el-icon>
</button>
<!-- 品牌区在折叠时**不是 v-if 删掉**,而是靠 CSS 收宽度 + 淡出:
v-if 会在动画中途把节点直接摘掉,看上去是"啪"地一跳;收放要连续就得让它们一直在。 -->
<span class="brand-logo"> <span class="brand-logo">
<el-icon :size="16"><School /></el-icon> <el-icon :size="16"><School /></el-icon>
</span> </span>
<span class="brand-text">班级小助手</span> <span class="brand-text">班级小助手</span>
</div> </div>
<el-menu :default-active="activeMenu" class="menu" @select="handleMenuSelect"> <el-menu
<el-menu-item v-for="item in menuItems" :key="item.path" :index="item.path"> ref="menuRef"
<!-- 未读红点挂在图标右上角(之前挂在文字后面,位置不对) --> :default-active="activeMenu"
:default-openeds="openedGroups"
class="menu"
@select="handleMenuSelect"
>
<!-- 一级项:直接铺在侧栏上(不再套「学习」分组)。
下面 el-sub-menu 里的菜单项与本段是同一套标记(图标槽 + 未读红点 + 标题),
改动时两处要一起改。 -->
<el-menu-item v-for="item in primaryItems" :key="item.path" :index="item.path">
<span class="menu-icon-slot"> <span class="menu-icon-slot">
<el-icon><component :is="item.icon" /></el-icon> <el-icon><component :is="item.icon" /></el-icon>
<el-badge <el-badge
v-if="item.path === '/notifications' && notifications.unreadCount > 0" v-if="showBadge(item.path)"
:value="notifications.unreadCount" :value="notifications.unreadCount"
:max="99" :max="99"
class="menu-badge" class="menu-badge"
@@ -118,7 +213,27 @@ onUnmounted(() => {
</span> </span>
<span>{{ item.title }}</span> <span>{{ item.title }}</span>
</el-menu-item> </el-menu-item>
<el-sub-menu v-for="group in menuGroups" :key="group.title" :index="group.title">
<template #title>
<el-icon><component :is="group.icon" /></el-icon>
<span>{{ group.title }}</span>
</template>
<el-menu-item v-for="item in group.items" :key="item.path" :index="item.path">
<!-- 未读红点挂在图标右上角(之前挂在文字后面,位置不对) -->
<span class="menu-icon-slot">
<el-icon><component :is="item.icon" /></el-icon>
<el-badge
v-if="showBadge(item.path)"
:value="notifications.unreadCount"
:max="99"
class="menu-badge"
/>
</span>
<span>{{ item.title }}</span>
</el-menu-item>
</el-sub-menu>
</el-menu> </el-menu>
<!-- 同上:折叠时不删节点,只淡出并收掉内边距 -->
<div class="aside-footer"> <div class="aside-footer">
<div class="aside-meta">第 {{ appStore.currentWeek }} 周</div> <div class="aside-meta">第 {{ appStore.currentWeek }} 周</div>
<div class="aside-meta">最近同步:{{ appStore.lastSyncText }}</div> <div class="aside-meta">最近同步:{{ appStore.lastSyncText }}</div>
@@ -133,6 +248,19 @@ onUnmounted(() => {
<span class="server-url">{{ appStore.serverUrl }}</span> <span class="server-url">{{ appStore.serverUrl }}</span>
</div> </div>
<div class="header-right"> <div class="header-right">
<!-- 黑夜/白天快捷切换:外观页里也有同样的设置,两处写同一份配置 -->
<el-tooltip :content="ui.theme === 'dark' ? '切换到浅色模式' : '切换到深色模式'" placement="bottom">
<el-button
class="theme-toggle"
text
circle
data-test="theme-toggle"
:aria-label="ui.theme === 'dark' ? '切换到浅色模式' : '切换到深色模式'"
@click="ui.toggleTheme()"
>
<el-icon><Sunny v-if="ui.theme === 'dark'" /><Moon v-else /></el-icon>
</el-button>
</el-tooltip>
<el-dropdown trigger="click"> <el-dropdown trigger="click">
<span class="user-chip"> <span class="user-chip">
<el-icon><UserFilled /></el-icon> <el-icon><UserFilled /></el-icon>
@@ -141,7 +269,7 @@ onUnmounted(() => {
</span> </span>
<template #dropdown> <template #dropdown>
<el-dropdown-menu> <el-dropdown-menu>
<el-dropdown-item @click="go('settings')"> <el-dropdown-item @click="go('settings-general')">
<el-icon><Setting /></el-icon> <el-icon><Setting /></el-icon>
设置 设置
</el-dropdown-item> </el-dropdown-item>
@@ -182,6 +310,11 @@ onUnmounted(() => {
.aside { .aside {
display: flex; display: flex;
flex-direction: column; flex-direction: column;
/* 展开/收回动画:宽度来自 el-aside 的内联 --el-aside-width,这里只负责过渡。
overflow:hidden 是必需的 —— 收窄过程中文字要被栏边裁掉,不能溢出到主区域;
菜单自己的滚动由内部的 .menu(flex:1 + min-height:0 + overflow-y:auto)负责。 */
overflow: hidden;
transition: width var(--nav-dur) var(--nav-ease);
} }
.brand { .brand {
@@ -189,10 +322,43 @@ onUnmounted(() => {
align-items: center; align-items: center;
gap: 10px; gap: 10px;
height: 52px; height: 52px;
padding: 0 16px; padding: 0 10px 0 12px;
font-weight: 600; font-weight: 600;
font-size: 14px; font-size: 14px;
color: var(--ch-text); color: var(--ch-text);
transition:
padding-left var(--nav-dur) var(--nav-ease),
gap var(--nav-dur) var(--nav-ease);
}
/* 汉堡按钮:折叠/展开整个侧边栏(状态持久化) */
.nav-toggle {
display: inline-flex;
align-items: center;
justify-content: center;
width: 28px;
height: 28px;
flex: 0 0 auto;
border: none;
border-radius: var(--ch-radius-control);
background: transparent;
color: var(--ch-text-secondary);
cursor: pointer;
transition: background 0.15s ease;
}
.nav-toggle:hover {
background: var(--ch-hover-soft);
}
/* 折叠态:侧栏只剩 64px,汉堡按钮水平居中。
用**位移 padding-left** 而不是 `justify-content: center` —— 后者不可过渡,会在动画中途"跳"一下。
汉堡宽 28px,padding-left 18px ⇒ 中心 = 18 + 14 = 32px,正好是 64/2,与折叠后的图标导轨同列
(冒烟断言中心差 ≤ 2px)。
这里刻意用**自己的类名**(`.is-collapsed`)而不是 `:has(.el-menu--collapse)`:
`:has()` 的失效会让 Chromium 标记整棵文档树重新计算样式。 */
.aside.ch-nav.is-collapsed .brand {
padding-left: 18px;
} }
/* Fluent 品牌标:强调色圆角方块 + 白色图标 */ /* Fluent 品牌标:强调色圆角方块 + 白色图标 */
@@ -202,21 +368,68 @@ onUnmounted(() => {
justify-content: center; justify-content: center;
width: 26px; width: 26px;
height: 26px; height: 26px;
flex: 0 0 auto;
border-radius: 6px; border-radius: 6px;
color: #fff; color: #fff;
background: linear-gradient(135deg, var(--ch-accent) 0%, #4d94d1 100%); background: linear-gradient(135deg, var(--ch-accent) 0%, #4d94d1 100%);
overflow: hidden;
transition:
width var(--nav-dur) var(--nav-ease),
opacity calc(var(--nav-dur) * 0.6) var(--nav-ease);
} }
/*
* 品牌文字 / 菜单文字在折叠时**不靠 max-width 归零**(那要么写死一个魔法数字,要么
* `none → 0` 根本不可过渡),而是:
* - `min-width: 0` 让这个 flex 子项能被压缩(默认的 `min-width: auto` 会撑住内容宽度);
* - 宽度自然跟着栏宽收缩,多出来的字被 `overflow: hidden` 裁掉;
* - 再叠一层 opacity 淡出,避免在中间帧里留下"半截字"。
* 于是文字宽度是**跟着侧栏宽度连续变化**的,不需要给它单独设动画终点。
*/
.brand-text { .brand-text {
min-width: 0;
overflow: hidden;
white-space: nowrap;
letter-spacing: 0.2px; letter-spacing: 0.2px;
transition: opacity calc(var(--nav-dur) * 0.6) var(--nav-ease);
}
/* 折叠:品牌区收成 0 宽并淡出(不是删节点,理由见模板上的注释) */
.aside.ch-nav.is-collapsed .brand {
gap: 0;
}
/*
* 图标导轨里**不显示滚动条**:所有图标应当一眼看全(用户要求"不要用滚轮、删掉滚动条")。
* 导轨之所以放得下,靠的是页脚在折叠态把高度也收成 0(见 .is-collapsed .aside-footer)——
* 不再有那 ~70px 的留白,11 行图标(462px)在 540px 的最小窗口里也够。
* 这里只隐藏滚动条本身,`overflow-y: auto` 保留:窗口被拉到极矮时还能滚,不至于把图标直接裁掉。
* 展开态**不隐藏** —— 那一栏确实会超(设置组展开时约 606px > 582px),
* 滚动条是"下面还有内容"的唯一提示,不能拿掉。
*/
.aside.ch-nav.is-collapsed .menu {
scrollbar-width: none;
}
.aside.ch-nav.is-collapsed .brand-logo {
width: 0;
opacity: 0;
}
.aside.ch-nav.is-collapsed .brand-text {
opacity: 0;
} }
.menu { .menu {
flex: 1; flex: 1;
/* min-height:0 是 flex 子项能滚动的关键:否则内容撑高、底部 footer 被挤出窗口 */
min-height: 0;
overflow-y: auto;
overflow-x: hidden;
border-right: none; border-right: none;
background: transparent; background: transparent;
--el-menu-bg-color: transparent; --el-menu-bg-color: transparent;
--el-menu-hover-bg-color: rgba(0, 0, 0, 0.04); --el-menu-hover-bg-color: var(--ch-hover-soft);
--el-menu-text-color: var(--ch-text); --el-menu-text-color: var(--ch-text);
--el-menu-active-color: var(--ch-text); --el-menu-active-color: var(--ch-text);
} }
@@ -260,6 +473,30 @@ onUnmounted(() => {
.aside-footer { .aside-footer {
padding: 10px 16px 14px; padding: 10px 16px 14px;
border-top: 1px solid var(--ch-divider); border-top: 1px solid var(--ch-divider);
overflow: hidden;
/* max-height 是给折叠动画用的终点:`* { box-sizing: border-box }`,展开态给一个略高于
内容(约 70px)的值,折叠时归零 —— 导轨里**一个像素都不给页脚留**。
不这么做的话,文字淡出后仍占着 ~70px,10 个图标在 540px 的最小窗口里就放不下、被迫滚动
(用户反馈:"图标无法完全显示、需要上下滑动、滚动条碍眼")。 */
max-height: 96px;
transition:
opacity calc(var(--nav-dur) * 0.7) var(--nav-ease),
padding var(--nav-dur) var(--nav-ease),
max-height var(--nav-dur) var(--nav-ease),
border-top-color var(--nav-dur) var(--nav-ease);
}
/* 折叠:页脚淡出、内边距与高度一起收到 0,分隔线也透明掉。
`min-height: 0` 是必需的:flex 子项默认 `min-height: auto`(= 内容高度),
而 CSS 里 min-height 优先于 max-height —— 不显式归零的话 max-height:0 根本压不下去。 */
.aside.ch-nav.is-collapsed .aside-footer {
opacity: 0;
padding-top: 0;
padding-bottom: 0;
max-height: 0;
min-height: 0;
border-top-color: transparent;
pointer-events: none;
} }
.aside-meta { .aside-meta {
@@ -270,7 +507,7 @@ onUnmounted(() => {
.header { .header {
height: 52px; height: 52px;
background: rgba(255, 255, 255, 0.6); background: var(--ch-header-bg);
backdrop-filter: blur(20px); backdrop-filter: blur(20px);
border-bottom: 1px solid var(--ch-border); border-bottom: 1px solid var(--ch-border);
display: flex; display: flex;
@@ -292,6 +529,17 @@ onUnmounted(() => {
color: var(--ch-text-tertiary); color: var(--ch-text-tertiary);
} }
.header-right {
/* 必须是 flex:Element Plus 的按钮是 `vertical-align: middle`、下拉容器是 `vertical-align: top`,
放在普通 block 容器里两个 inline-level 子元素会按各自的垂直对齐规则落位,主题切换按钮与
用户名牌就会错开几像素(用户反馈的"深色模式没对齐",其实两种主题下都偏,只是深色下更显眼)。
与 Web 管理端 AdminLayout 的同名容器保持同一套写法。 */
display: flex;
align-items: center;
gap: 8px;
flex: 0 0 auto;
}
.user-chip { .user-chip {
display: flex; display: flex;
align-items: center; align-items: center;
@@ -304,7 +552,12 @@ onUnmounted(() => {
} }
.user-chip:hover { .user-chip:hover {
background: rgba(0, 0, 0, 0.04); background: var(--ch-hover-soft);
}
.theme-toggle {
/* 与用户名牌的间距由 .header-right 的 gap 负责,这里不再自带 margin */
color: var(--ch-text-secondary);
} }
.main { .main {
+18 -6
View File
@@ -2,26 +2,38 @@ import { createApp } from 'vue';
import { createPinia } from 'pinia'; import { createPinia } from 'pinia';
import ElementPlus from 'element-plus'; import ElementPlus from 'element-plus';
import zhCn from 'element-plus/es/locale/lang/zh-cn'; import zhCn from 'element-plus/es/locale/lang/zh-cn';
import * as ElementPlusIconsVue from '@element-plus/icons-vue';
import 'element-plus/dist/index.css'; import 'element-plus/dist/index.css';
// 深色主题:html.dark 下的 --el-* 变量(品牌覆盖在 styles/index.css 的 html.dark 块)
import 'element-plus/theme-chalk/dark/css-vars.css';
import App from './App.vue'; import App from './App.vue';
import router from './router/index.js'; import router from './router/index.js';
import { registerSmokeHooks } from './cache/self-test.js'; import { registerAppIcons } from './icons.js';
import './styles/index.css'; import './styles/index.css';
const app = createApp(App); const app = createApp(App);
for (const [name, component] of Object.entries(ElementPlusIconsVue)) { // 按需注册图标(见 icons.ts:只注册用到的那些,而不是全量 293 个)
app.component(name, component); registerAppIcons(app);
}
app.use(createPinia()); app.use(createPinia());
app.use(router); app.use(router);
app.use(ElementPlus, { locale: zhCn }); app.use(ElementPlus, { locale: zhCn });
// 冒烟验证模式:把缓存自检钩子暴露给主进程调用(正常运行时不存在) // 冒烟验证模式:把缓存自检钩子暴露给主进程调用(正常运行时不存在)。
//
// **动态 import 是刻意的**:`cache/self-test.ts` 有 1000 多行自检代码,
// 静态 import 会把它打进渲染进程入口 chunk,每次启动都要解析一遍。改成动态 import 后
// Vite/Rollup 会把它切成独立 chunk,只在冒烟模式下才加载(`verify:desktop` /
// `verify:packaged` 的那条路径)。
//
// 教师凭据由 preload 从环境变量透传(**不写在代码里**:渲染产物会进 app.asar 发给学生机)。
if (window.desktop?.smokeTest) { if (window.desktop?.smokeTest) {
const { registerSmokeHooks, setSmokeTeacherCredentials } = await import('./cache/self-test.js');
setSmokeTeacherCredentials({
username: window.desktop.smokeCredentials?.username ?? '',
password: window.desktop.smokeCredentials?.password ?? '',
});
registerSmokeHooks(); registerSmokeHooks();
} }
@@ -41,11 +41,46 @@ const routes: RouteRecordRaw[] = [
component: () => import('../views/GradeView.vue'), component: () => import('../views/GradeView.vue'),
meta: { title: '成绩' }, meta: { title: '成绩' },
}, },
/* 设置:主侧边栏「设置」分组下的六个子页(ClassIsland 式 主菜单+子菜单) */
{ {
path: 'settings', path: 'settings',
name: 'settings', redirect: '/settings/general',
component: () => import('../views/SettingsView.vue'), },
meta: { title: '设置' }, {
path: 'settings/general',
name: 'settings-general',
component: () => import('../views/settings/GeneralSettingsView.vue'),
meta: { title: '通用设置' },
},
{
path: 'settings/appearance',
name: 'settings-appearance',
component: () => import('../views/settings/AppearanceView.vue'),
meta: { title: '外观' },
},
{
path: 'settings/island',
name: 'settings-island',
component: () => import('../views/settings/IslandSettingsView.vue'),
meta: { title: '灵动岛' },
},
{
path: 'settings/reminder',
name: 'settings-reminder',
component: () => import('../views/settings/ReminderSettingsView.vue'),
meta: { title: '提醒' },
},
{
path: 'settings/account',
name: 'settings-account',
component: () => import('../views/settings/AccountSettingsView.vue'),
meta: { title: '账号' },
},
{
path: 'settings/about',
name: 'settings-about',
component: () => import('../views/settings/AboutView.vue'),
meta: { title: '关于' },
}, },
], ],
}, },
@@ -0,0 +1,24 @@
import { ref } from 'vue';
import { defineStore } from 'pinia';
/**
* 初次启动引导的显示状态。
*
* 首次启动由 App.vue 按「配置里是否记过 onboardingDone」自动弹出;
* 登录页与设置页的「使用引导」入口调用 open() 随时重看。
* 单独一个 store 而不是组件内部 ref:触发入口(登录页 / 设置页)与
* 渲染点(App.vue 顶层)分处两棵互不相干的子树。
*/
export const useOnboardingStore = defineStore('onboarding', () => {
const visible = ref(false);
function open(): void {
visible.value = true;
}
function close(): void {
visible.value = false;
}
return { visible, open, close };
});
@@ -0,0 +1,73 @@
import { ref } from 'vue';
import { defineStore } from 'pinia';
import type { DesktopStoredConfig } from '../../types/desktop.js';
/**
* 界面偏好(主题 / 侧边栏折叠)。
*
* 持久化在主进程配置(DesktopStoredConfig.theme / sidebarCollapsed)里,
* 与灵动岛外观等设置同一套落盘机制;浏览器调试(无 window.desktop)回落 localStorage。
* 深色主题 = 在 <html> 上挂 .dark 类(Element Plus dark css-vars + styles/index.css 的
* html.dark 品牌变量),应用主题的全部入口都必须走 setTheme,保证类名与配置同步。
*/
const THEME_KEY = 'classhelper.theme';
const SIDEBAR_KEY = 'classhelper.sidebarCollapsed';
function applyThemeClass(theme: 'light' | 'dark'): void {
document.documentElement.classList.toggle('dark', theme === 'dark');
}
export const useUiStore = defineStore('ui', () => {
const theme = ref<'light' | 'dark'>('light');
const sidebarCollapsed = ref(false);
/** 启动时从主进程配置恢复(App.vue 的 boot 流程里调用,早于首屏渲染) */
async function init(): Promise<void> {
if (window.desktop) {
const config = await window.desktop.getConfig().catch(() => null);
if (config) {
theme.value = config.theme === 'dark' ? 'dark' : 'light';
sidebarCollapsed.value = config.sidebarCollapsed === true;
}
} else {
theme.value = localStorage.getItem(THEME_KEY) === 'dark' ? 'dark' : 'light';
sidebarCollapsed.value = localStorage.getItem(SIDEBAR_KEY) === '1';
}
applyThemeClass(theme.value);
}
/** 切换主题(外观页单选 / 顶栏快捷切换共用),写回配置 */
async function setTheme(next: 'light' | 'dark'): Promise<void> {
theme.value = next;
applyThemeClass(next);
if (window.desktop) {
await window.desktop.saveConfig({ theme: next }).catch(() => undefined);
} else {
localStorage.setItem(THEME_KEY, next);
}
}
function toggleTheme(): void {
void setTheme(theme.value === 'dark' ? 'light' : 'dark');
}
/** 主侧边栏折叠/展开(汉堡按钮),写回配置 */
async function setSidebarCollapsed(collapsed: boolean): Promise<void> {
sidebarCollapsed.value = collapsed;
if (window.desktop) {
await window.desktop.saveConfig({ sidebarCollapsed: collapsed }).catch(() => undefined);
} else {
localStorage.setItem(SIDEBAR_KEY, collapsed ? '1' : '0');
}
}
function toggleSidebar(): void {
void setSidebarCollapsed(!sidebarCollapsed.value);
}
return { theme, sidebarCollapsed, init, setTheme, toggleTheme, setSidebarCollapsed, toggleSidebar };
});
/** 供类型检查使用(仅引用类型) */
export type UiConfig = Pick<DesktopStoredConfig, 'theme' | 'sidebarCollapsed'>;
@@ -1,12 +1,19 @@
/* ============================================================================ /* ============================================================================
* 班级小助手客户端主题 —— ClassIsland 同款 Fluent 风格 * 班级小助手客户端主题 —— ClassIsland 同款 Fluent 风格(浅色 / 深色双主题)
* *
* 参考 ClassIsland(Windows 课件表应用)的观感: * 参考 ClassIsland(Windows 课件表应用)的观感:
* - WinUI / Fluent 设计语言:浅色 Mica 底 + 半透明"亚克力"卡片 + 1px 细腻描边 * - WinUI / Fluent 设计语言:Mica 底 + 半透明"亚克力"卡片 + 1px 细腻描边
* - 强调色 #0F6CBD(悬停 #115EA3),选中项用强调色淡底 + 左侧强调条 * - 强调色 #0F6CBD(悬停 #115EA3),选中项用强调色淡底 + 左侧强调条
* - 圆角:卡片 8px、控件 4~6px、胶囊 999px * - 圆角:卡片 8px、控件 4~6px、胶囊 999px
* - 字体:Segoe UI Variable / 微软雅黑 UI,字号偏小、行距偏松 * - 字体:Segoe UI Variable / 微软雅黑 UI,字号偏小、行距偏松
* - 阴影极轻(0 2px 4px rgba(0,0,0,.04)),层次主要靠描边与底色区分 * - 阴影极轻(0 2px 4px rgba(0,0,0,.04)),层次主要靠描边与底色区分
*
* 主题机制:
* - 全部颜色走 --ch-* / --el-* 变量,:root 是浅色值;
* - 深色主题 = html 根元素挂 .dark 类(由 stores/ui.ts 按配置切换),
* Element Plus 的 dark/css-vars.css(main.ts 引入)提供 --el-* 深色默认,
* 下面的 html.dark 块覆盖品牌变量(特异性高于 :root,必定生效);
* - 组件里**不要写死颜色**,一律用变量——深色回归靠这条纪律守着。
* ========================================================================== */ * ========================================================================== */
:root { :root {
@@ -33,12 +40,29 @@
--ch-text-secondary: #5c5c5c; --ch-text-secondary: #5c5c5c;
--ch-text-tertiary: #8a8a8a; --ch-text-tertiary: #8a8a8a;
/* 交互态(悬停底色 / 侧栏与顶栏的亚克力底 / 滚动条) */
--ch-hover-soft: rgba(0, 0, 0, 0.04);
--ch-nav-bg: rgba(255, 255, 255, 0.65);
--ch-header-bg: rgba(255, 255, 255, 0.6);
--ch-scrollbar: rgba(0, 0, 0, 0.18);
--ch-scrollbar-hover: rgba(0, 0, 0, 0.3);
/* 圆角与阴影 */ /* 圆角与阴影 */
--ch-radius-card: 8px; --ch-radius-card: 8px;
--ch-radius-control: 4px; --ch-radius-control: 4px;
--ch-shadow-flyout: 0 8px 16px rgba(0, 0, 0, 0.08); --ch-shadow-flyout: 0 8px 16px rgba(0, 0, 0, 0.08);
--ch-shadow-card: 0 2px 4px rgba(0, 0, 0, 0.04); --ch-shadow-card: 0 2px 4px rgba(0, 0, 0, 0.04);
/*
* 侧栏收放动画。组件(ClientLayout 的 .aside/.brand/.brand-logo/.aside-footer)
* 与全局的菜单导轨规则(下面的 .ch-nav.is-collapsed …)共用这一份参数,
* 改时长/缓动只改这里,两边不会漂。
*/
--nav-dur: 260ms;
--nav-ease: cubic-bezier(0.4, 0, 0.2, 1);
/* 图标与文字的间距(折叠时收到 0) */
--nav-gap: 8px;
/* 兼容旧变量名 */ /* 兼容旧变量名 */
--ch-sidebar: #ffffff; --ch-sidebar: #ffffff;
@@ -62,6 +86,55 @@
--el-font-size-base: 13px; --el-font-size-base: 13px;
} }
/* ---------------------------------------------------------------- 深色主题 */
html.dark {
--ch-accent: #5aabec;
--ch-accent-hover: #7cc0f4;
--ch-accent-soft: rgba(90, 171, 236, 0.16);
--ch-accent-soft-strong: rgba(90, 171, 236, 0.26);
--ch-bg: #161719;
--ch-layer: rgba(32, 33, 36, 0.72);
--ch-layer-solid: #1e1f23;
--ch-layer-alt: rgba(28, 29, 32, 0.5);
--ch-card-subtle: rgba(255, 255, 255, 0.04);
--ch-border: rgba(255, 255, 255, 0.08);
--ch-border-strong: rgba(255, 255, 255, 0.14);
--ch-divider: rgba(255, 255, 255, 0.06);
--ch-text: #e8e8ea;
--ch-text-secondary: #b0b1b5;
--ch-text-tertiary: #7e7f85;
--ch-hover-soft: rgba(255, 255, 255, 0.07);
--ch-nav-bg: rgba(28, 29, 32, 0.65);
--ch-header-bg: rgba(30, 31, 34, 0.6);
--ch-scrollbar: rgba(255, 255, 255, 0.22);
--ch-scrollbar-hover: rgba(255, 255, 255, 0.36);
--ch-shadow-flyout: 0 8px 16px rgba(0, 0, 0, 0.45);
--ch-shadow-card: 0 2px 4px rgba(0, 0, 0, 0.3);
--ch-sidebar: #1e1f23;
/* Element Plus 深色下的品牌色对齐(dark/css-vars.css 的默认蓝偏亮,这里对齐品牌) */
--el-color-primary: #4a9eff;
--el-color-primary-light-3: #337fd6;
--el-color-primary-light-5: #2563ab;
--el-color-primary-light-7: #1b4a82;
--el-color-primary-light-8: #163c6b;
--el-color-primary-light-9: #122f55;
--el-color-primary-dark-2: #6cb4ff;
--el-text-color-primary: #e8e8ea;
--el-text-color-regular: #c9cacd;
--el-text-color-secondary: #9a9b9f;
--el-border-color: rgba(255, 255, 255, 0.12);
--el-border-color-light: rgba(255, 255, 255, 0.08);
--el-border-color-lighter: rgba(255, 255, 255, 0.06);
}
* { * {
box-sizing: border-box; box-sizing: border-box;
} }
@@ -179,12 +252,12 @@ textarea {
} }
.el-button--default { .el-button--default {
background: rgba(255, 255, 255, 0.7) !important; background: var(--ch-layer) !important;
border-color: var(--ch-border-strong) !important; border-color: var(--ch-border-strong) !important;
} }
.el-button--default:hover { .el-button--default:hover {
background: rgba(0, 0, 0, 0.04) !important; background: var(--ch-hover-soft) !important;
} }
.el-button--primary { .el-button--primary {
@@ -195,7 +268,7 @@ textarea {
.el-textarea__inner, .el-textarea__inner,
.el-select__wrapper { .el-select__wrapper {
border-radius: var(--ch-radius-control) !important; border-radius: var(--ch-radius-control) !important;
background: rgba(255, 255, 255, 0.7) !important; background: var(--ch-layer) !important;
box-shadow: 0 0 0 1px var(--ch-border-strong) inset !important; box-shadow: 0 0 0 1px var(--ch-border-strong) inset !important;
} }
@@ -224,12 +297,38 @@ textarea {
box-shadow: var(--ch-shadow-flyout) !important; box-shadow: var(--ch-shadow-flyout) !important;
} }
/* 关于页的折叠卡片:与 el-card 同一套观感(分割线代替卡片描边) */
.el-collapse {
--el-collapse-border-color: var(--ch-divider);
border: none !important;
}
.el-collapse-item__header {
background: var(--ch-layer) !important;
border: 1px solid var(--ch-border) !important;
border-radius: var(--ch-radius-card) !important;
padding: 0 16px;
margin-top: 8px;
font-weight: 600;
font-size: 13.5px;
}
.el-collapse-item__wrap {
background: transparent !important;
border-bottom: none !important;
}
.el-collapse-item__content {
padding: 12px 6px 4px !important;
color: var(--ch-text);
}
/* ---------------------------------------------------------------- 表格 */ /* ---------------------------------------------------------------- 表格 */
.el-table { .el-table {
--el-table-border-color: var(--ch-divider); --el-table-border-color: var(--ch-divider);
--el-table-header-bg-color: transparent; --el-table-header-bg-color: transparent;
--el-table-row-hover-bg-color: rgba(0, 0, 0, 0.03); --el-table-row-hover-bg-color: var(--ch-hover-soft);
background: transparent !important; background: transparent !important;
} }
@@ -251,12 +350,13 @@ textarea {
/* ---------------------------------------------------------------- 侧边导航(Fluent NavigationView 观感) */ /* ---------------------------------------------------------------- 侧边导航(Fluent NavigationView 观感) */
.ch-nav { .ch-nav {
background: rgba(255, 255, 255, 0.65); background: var(--ch-nav-bg);
backdrop-filter: blur(24px) saturate(1.2); backdrop-filter: blur(24px) saturate(1.2);
border-right: 1px solid var(--ch-border); border-right: 1px solid var(--ch-border);
} }
.ch-nav .el-menu-item { .ch-nav .el-menu-item,
.ch-nav .el-sub-menu__title {
height: 40px; height: 40px;
line-height: 40px; line-height: 40px;
margin: 2px 8px; margin: 2px 8px;
@@ -266,8 +366,19 @@ textarea {
position: relative; position: relative;
} }
.ch-nav .el-menu-item:hover { .ch-nav .el-menu-item:hover,
background: rgba(0, 0, 0, 0.04); .ch-nav .el-sub-menu__title:hover {
background: var(--ch-hover-soft);
}
/* 分组标题:比普通菜单项轻一档(分组是"容器",不是目的地) */
.ch-nav .el-sub-menu__title {
font-weight: 600;
color: var(--ch-text-secondary);
}
.ch-nav .el-sub-menu .el-menu {
background: transparent;
} }
/* 选中项:强调色淡底 + 左侧强调条(WinUI 经典样式) */ /* 选中项:强调色淡底 + 左侧强调条(WinUI 经典样式) */
@@ -288,6 +399,93 @@ textarea {
background: var(--ch-accent); background: var(--ch-accent);
} }
/* ---------------------------------------------------------------- 折叠态:图标导轨
*
* 折叠**不再用** el-menu 的 `:collapse`:那会把每个分组的子项卸载进浮层(一次结构切换),
* 并让整条菜单重排一遍 —— 既做不出连续动画,也是"点汉堡卡一下"的渲染侧来源。
* 现在改成纯粹的 CSS 收拢:栏宽、文字宽度、图标位置全是可过渡属性,全程没有结构变化,
* 折叠后就是一条图标导轨(分组标题与子项都以图标列出)。
*
* 几何(64px 栏、菜单项左右各 8px margin):
* 展开 一级项 padding-left 20px、二级项 40px(Element Plus 自带)→ 图标中心 40 / 60px
* 折叠 所有项 padding-left / padding-right 都是 12px → 图标中心 8 + 12 + 12 = 32px,
* 正好与顶部汉堡按钮的居中位置同列(冒烟断言中心差 ≤ 2px)。
* 图标槽(.menu-icon-slot)与分组标题里的裸图标都是 Element Plus 给的 24px 宽。
*/
/* 图标与文字的间距改由文字的 margin-left 负责:Element Plus 给图标挂了 margin-right:5px,
那会让图标在 24px 的槽里偏左 2.5px(折叠时肉眼可见地不居中)。 */
.ch-nav .el-menu-item [class^='el-icon'],
.ch-nav .el-sub-menu__title > [class^='el-icon'] {
margin-right: 0;
}
.ch-nav .el-menu-item,
.ch-nav .el-sub-menu__title {
transition:
padding-left var(--nav-dur) var(--nav-ease),
padding-right var(--nav-dur) var(--nav-ease),
border-color var(--el-transition-duration),
background-color var(--el-transition-duration),
color var(--el-transition-duration);
}
/*
* 文字:**不给它单独设动画终点**,宽度靠 flex 被压缩 —— `min-width:0` 让这个 flex 子项
* 能被压到 0(默认的 `min-width:auto` 会撑住内容宽度),多出来的字由 `overflow:hidden` 裁掉。
* 于是文字宽度天然跟着栏宽连续变化,不需要写什么魔法 max-width;再叠一层 opacity 淡出,
* 避免中间帧留下"半截字"(`display:none` 没法过渡,用不了)。
*/
.ch-nav .el-menu-item > span:not(.menu-icon-slot),
.ch-nav .el-sub-menu__title > span:not(.menu-icon-slot) {
min-width: 0;
margin-left: var(--nav-gap);
overflow: hidden;
white-space: nowrap;
transition:
margin-left var(--nav-dur) var(--nav-ease),
opacity calc(var(--nav-dur) * 0.6) var(--nav-ease);
}
/* 分组标题右侧的折叠箭头:导轨里没有它的位置 */
.ch-nav .el-sub-menu__icon-arrow {
transition: opacity calc(var(--nav-dur) * 0.5) var(--nav-ease);
}
.ch-nav.is-collapsed .el-menu-item > span:not(.menu-icon-slot),
.ch-nav.is-collapsed .el-sub-menu__title > span:not(.menu-icon-slot) {
margin-left: 0;
opacity: 0;
pointer-events: none;
}
.ch-nav.is-collapsed .el-sub-menu__icon-arrow {
opacity: 0;
}
/*
* 折叠后的内边距。
*
* 这三条选择器形状都是**照抄 Element Plus 的**,不是冗余 —— 它按层级用三个不同的选择器算缩进
* (一级项 20px、分组标题 20px、分组内子项 40px),特异度分别是 0-4-0 / 0-4-0 / 0-5-0:
* `.el-menu--vertical:not(.el-menu--collapse):not(.el-menu--popup-container) .el-menu-item`
* `.el-menu--vertical:not(.el-menu--collapse):not(.el-menu--popup-container) .el-sub-menu__title`
* `.el-menu--vertical:not(.el-menu--collapse):not(.el-menu--popup-container) .el-sub-menu .el-menu-item`
* 写成 `.ch-nav.is-collapsed .el-sub-menu__title` 这种(0-3-0)压不住任何一条 —— 实测踩过两次:
* 第一版漏了分组标题(偏 8.0px),把「学习」拆成一级项后又漏了一级项(同样偏 8.0px)。
* 下面两条(0-5-0 / 0-6-0)把它们全覆盖,且不用 !important。
*/
.ch-nav.is-collapsed .el-menu--vertical:not(.el-menu--collapse) .el-menu-item,
.ch-nav.is-collapsed .el-menu--vertical:not(.el-menu--collapse) .el-sub-menu__title {
padding-left: 12px;
padding-right: 12px;
}
.ch-nav.is-collapsed .el-menu--vertical:not(.el-menu--collapse) .el-sub-menu .el-menu-item {
padding-left: 12px;
padding-right: 12px;
}
/* ---------------------------------------------------------------- 课表时间轴 */ /* ---------------------------------------------------------------- 课表时间轴 */
.timetable-cell { .timetable-cell {
@@ -320,14 +518,14 @@ textarea {
} }
::-webkit-scrollbar-thumb { ::-webkit-scrollbar-thumb {
background: rgba(0, 0, 0, 0.18); background: var(--ch-scrollbar);
border: 3px solid transparent; border: 3px solid transparent;
background-clip: content-box; background-clip: content-box;
border-radius: 8px; border-radius: 8px;
} }
::-webkit-scrollbar-thumb:hover { ::-webkit-scrollbar-thumb:hover {
background: rgba(0, 0, 0, 0.3); background: var(--ch-scrollbar-hover);
background-clip: content-box; background-clip: content-box;
} }
@@ -1,6 +1,5 @@
<script setup lang="ts"> <script setup lang="ts">
import { computed, onMounted, onUnmounted, ref } from 'vue'; import { computed, onMounted, onUnmounted, ref } from 'vue';
import * as echarts from 'echarts';
import { import {
SOCKET_EVENTS, SOCKET_EVENTS,
averageOf, averageOf,
@@ -11,6 +10,7 @@ import {
} from '@classhelper/shared'; } from '@classhelper/shared';
import { gradeApi } from '../api/index.js'; import { gradeApi } from '../api/index.js';
import { fetchWithCache } from '../cache/index.js'; import { fetchWithCache } from '../cache/index.js';
import ScoreBarChart from '../components/ScoreBarChart.vue';
import { useAppStore } from '../stores/app.js'; import { useAppStore } from '../stores/app.js';
import { useAuthStore } from '../stores/auth.js'; import { useAuthStore } from '../stores/auth.js';
import { useRealtimeStore } from '../stores/realtime.js'; import { useRealtimeStore } from '../stores/realtime.js';
@@ -24,8 +24,6 @@ const loading = ref(false);
const grades = ref<GradeDto[]>([]); const grades = ref<GradeDto[]>([]);
const fromCache = ref(false); const fromCache = ref(false);
const updatedAt = ref<number | null>(null); const updatedAt = ref<number | null>(null);
const chartRef = ref<HTMLDivElement>();
let chart: ReturnType<typeof echarts.init> | null = null;
const averagePercent = computed(() => const averagePercent = computed(() =>
grades.value.length === 0 grades.value.length === 0
@@ -53,6 +51,21 @@ const levelCounts = computed(() => {
return levels; return levels;
}); });
/**
* 按考试聚合平均得分率(最近 8 次考试),交给 ScoreBarChart 渲染。
* 这里原先调的是 `echarts.setOption(...)`;改用纯 CSS 柱状图是为了去掉
* echarts(渲染产物里最大的一块,1.1MB)。聚合口径与之前完全一致。
*/
const examAverages = computed(() => {
const byExam = new Map<string, number[]>();
for (const item of grades.value) {
const bucket = byExam.get(item.examName) ?? [];
bucket.push(gradePercent(item.score, item.totalScore));
byExam.set(item.examName, bucket);
}
return [...byExam.entries()].slice(-8).map(([label, percents]) => ({ label, value: averageOf(percents) }));
});
async function loadGrades(): Promise<void> { async function loadGrades(): Promise<void> {
loading.value = true; loading.value = true;
try { try {
@@ -61,50 +74,11 @@ async function loadGrades(): Promise<void> {
fromCache.value = result.fromCache; fromCache.value = result.fromCache;
updatedAt.value = result.updatedAt; updatedAt.value = result.updatedAt;
if (!result.fromCache) appStore.markSynced(); if (!result.fromCache) appStore.markSynced();
renderChart();
} finally { } finally {
loading.value = false; loading.value = false;
} }
} }
function renderChart(): void {
if (!chartRef.value) return;
chart ??= echarts.init(chartRef.value);
// 按考试聚合平均得分率(最近 8 次考试)
const byExam = new Map<string, number[]>();
for (const item of grades.value) {
const bucket = byExam.get(item.examName) ?? [];
bucket.push(gradePercent(item.score, item.totalScore));
byExam.set(item.examName, bucket);
}
const exams = [...byExam.entries()].slice(-8);
chart.setOption({
tooltip: { trigger: 'axis' },
grid: { left: 44, right: 18, top: 30, bottom: 34 },
xAxis: {
type: 'category',
data: exams.map(([name]) => name),
axisLabel: { interval: 0, rotate: exams.length > 4 ? 20 : 0, fontSize: 11 },
},
yAxis: { type: 'value', max: 100, name: '得分率%' },
series: [
{
type: 'bar',
barMaxWidth: 46,
itemStyle: { color: '#409eff', borderRadius: [4, 4, 0, 0] },
label: { show: true, position: 'top', formatter: '{c}%', fontSize: 11 },
data: exams.map(([, percents]) => averageOf(percents)),
},
],
});
}
function handleResize(): void {
chart?.resize();
}
function onGradeEvent(): void { function onGradeEvent(): void {
void loadGrades(); void loadGrades();
} }
@@ -115,15 +89,11 @@ function onRecovered(): void {
onMounted(async () => { onMounted(async () => {
await loadGrades(); await loadGrades();
window.addEventListener('resize', handleResize);
realtime.on(SOCKET_EVENTS.gradeUpdated, onGradeEvent); realtime.on(SOCKET_EVENTS.gradeUpdated, onGradeEvent);
appStore.onServerRecovered(onRecovered); appStore.onServerRecovered(onRecovered);
}); });
onUnmounted(() => { onUnmounted(() => {
window.removeEventListener('resize', handleResize);
chart?.dispose();
chart = null;
realtime.off(SOCKET_EVENTS.gradeUpdated, onGradeEvent); realtime.off(SOCKET_EVENTS.gradeUpdated, onGradeEvent);
appStore.offServerRecovered(onRecovered); appStore.offServerRecovered(onRecovered);
}); });
@@ -172,7 +142,7 @@ onUnmounted(() => {
<el-col :xs="24" :md="16"> <el-col :xs="24" :md="16">
<el-card v-loading="loading" shadow="never"> <el-card v-loading="loading" shadow="never">
<template #header><span>各次考试平均得分率</span></template> <template #header><span>各次考试平均得分率</span></template>
<div ref="chartRef" class="chart"></div> <ScoreBarChart :items="examAverages" />
</el-card> </el-card>
</el-col> </el-col>
</el-row> </el-row>
@@ -226,7 +196,7 @@ onUnmounted(() => {
<style scoped> <style scoped>
.stat-card { .stat-card {
background: #fff; background: var(--ch-layer-solid);
border: 1px solid var(--ch-border); border: 1px solid var(--ch-border);
border-radius: 10px; border-radius: 10px;
padding: 16px; padding: 16px;
@@ -234,7 +204,7 @@ onUnmounted(() => {
.stat-label { .stat-label {
font-size: 13px; font-size: 13px;
color: #909399; color: var(--ch-text-secondary);
} }
.stat-value { .stat-value {
@@ -246,7 +216,7 @@ onUnmounted(() => {
.stat-hint { .stat-hint {
margin-top: 4px; margin-top: 4px;
font-size: 12px; font-size: 12px;
color: #c0c4cc; color: var(--ch-text-tertiary);
} }
.level-list { .level-list {
@@ -255,9 +225,4 @@ onUnmounted(() => {
gap: 6px; gap: 6px;
margin-top: 8px; margin-top: 8px;
} }
.chart {
width: 100%;
height: 300px;
}
</style> </style>
@@ -1,5 +1,5 @@
<script setup lang="ts"> <script setup lang="ts">
import { computed, nextTick, onMounted, onUnmounted, ref } from 'vue'; import { computed, nextTick, onMounted, onUnmounted, ref, watch } from 'vue';
import { useRoute, useRouter } from 'vue-router'; import { useRoute, useRouter } from 'vue-router';
import { ElMessage } from 'element-plus'; import { ElMessage } from 'element-plus';
import { import {
@@ -15,6 +15,7 @@ import {
} from '@classhelper/shared'; } from '@classhelper/shared';
import { courseApi, homeworkApi } from '../api/index.js'; import { courseApi, homeworkApi } from '../api/index.js';
import { fetchWithCache } from '../cache/index.js'; import { fetchWithCache } from '../cache/index.js';
import { markHomeworkCreatedLocally } from '../island/bridge.js';
import { useAppStore } from '../stores/app.js'; import { useAppStore } from '../stores/app.js';
import { useAuthStore } from '../stores/auth.js'; import { useAuthStore } from '../stores/auth.js';
import { useRealtimeStore } from '../stores/realtime.js'; import { useRealtimeStore } from '../stores/realtime.js';
@@ -80,6 +81,17 @@ async function selectDate(value: string | null): Promise<void> {
await loadHomework(); await loadHomework();
} }
// 深链 ?date= 不止在首次挂载生效:已在作业页时(看板/列表之间切换、冒烟直接推 query),
// 路由 query 变了也要跟着切换日期 —— 组件被复用,没有这条监听就停在原日期。
watch(
() => route.query.date,
(value) => {
if (typeof value !== 'string' || !isDayKey(value) || value === selectedDate.value) return;
selectedDate.value = value;
void loadHomework();
},
);
/** 前后一天(教室电脑上不用打开日历也能翻) */ /** 前后一天(教室电脑上不用打开日历也能翻) */
async function shiftDate(delta: number): Promise<void> { async function shiftDate(delta: number): Promise<void> {
await selectDate(shiftDayKey(selectedDate.value, delta)); await selectDate(shiftDayKey(selectedDate.value, delta));
@@ -412,13 +424,19 @@ async function submitCreate(): Promise<void> {
createSaving.value = true; createSaving.value = true;
try { try {
await homeworkApi.create({ // 先按内容登记"This 是本机录的":服务端是**先广播 homework:new、后回响应**的,
// 等响应拿到 id 再登记就晚了 —— 实时事件可能已经到了,岛已经弹出来了。
const draft = { classId, title, content, assignDate: selectedDate.value };
markHomeworkCreatedLocally(draft);
const created = await homeworkApi.create({
classId, classId,
courseId: createForm.value.courseId || null, courseId: createForm.value.courseId || null,
title, title,
content, content,
assignDate: selectedDate.value, assignDate: selectedDate.value,
}); });
// 回执里带上 id 再记一次(覆盖"广播晚于响应"的另一半)
if (created?.id) markHomeworkCreatedLocally({ ...draft, id: created.id });
ElMessage.success(`已录入到 ${selectedDate.value}`); ElMessage.success(`已录入到 ${selectedDate.value}`);
createVisible.value = false; createVisible.value = false;
await loadHomework(); await loadHomework();
@@ -898,7 +916,7 @@ onUnmounted(() => {
.content-block { .content-block {
white-space: pre-wrap; white-space: pre-wrap;
line-height: 1.75; line-height: 1.75;
background: #fafafa; background: var(--ch-layer-alt);
border-radius: 12px; border-radius: 12px;
padding: 12px; padding: 12px;
margin: 0; margin: 0;
@@ -1130,7 +1148,7 @@ onUnmounted(() => {
transform: translateX(-50%); transform: translateX(-50%);
font-size: 14px; font-size: 14px;
font-weight: 500; font-weight: 500;
color: #6b7280; color: var(--ch-text-tertiary);
white-space: nowrap; white-space: nowrap;
} }
@@ -1158,7 +1176,7 @@ onUnmounted(() => {
.submission-list { .submission-list {
max-height: 46vh; max-height: 46vh;
overflow-y: auto; overflow-y: auto;
border: 1px solid #ebeef5; border: 1px solid var(--ch-divider);
border-radius: 12px; border-radius: 12px;
padding: 12px; padding: 12px;
} }
@@ -5,12 +5,14 @@ import { ElMessage, type FormInstance, type FormRules } from 'element-plus';
import { pingHealth, setApiBaseUrl } from '../api/http.js'; import { pingHealth, setApiBaseUrl } from '../api/http.js';
import { useAppStore } from '../stores/app.js'; import { useAppStore } from '../stores/app.js';
import { useAuthStore } from '../stores/auth.js'; import { useAuthStore } from '../stores/auth.js';
import { useOnboardingStore } from '../stores/onboarding.js';
import { useRealtimeStore } from '../stores/realtime.js'; import { useRealtimeStore } from '../stores/realtime.js';
import { DEFAULT_SERVER, normalizeServerUrl } from '../config.js'; import { DEFAULT_SERVER, normalizeServerUrl } from '../config.js';
const router = useRouter(); const router = useRouter();
const appStore = useAppStore(); const appStore = useAppStore();
const auth = useAuthStore(); const auth = useAuthStore();
const onboarding = useOnboardingStore();
const realtime = useRealtimeStore(); const realtime = useRealtimeStore();
const formRef = ref<FormInstance>(); const formRef = ref<FormInstance>();
@@ -134,6 +136,14 @@ async function enterOffline(): Promise<void> {
<el-button type="primary" :loading="auth.loading" @click="submit">登录</el-button> <el-button type="primary" :loading="auth.loading" @click="submit">登录</el-button>
</div> </div>
<!-- 重看初次启动引导:首次启动会自动弹出过一次,这里供随时回看 -->
<div class="login-guide">
<el-button link type="primary" @click="onboarding.open()">
<el-icon><Guide /></el-icon>
查看使用引导
</el-button>
</div>
<el-alert <el-alert
v-if="testResult === 'ok'" v-if="testResult === 'ok'"
class="mt-12" class="mt-12"
@@ -177,7 +187,7 @@ async function enterOffline(): Promise<void> {
.login-card { .login-card {
width: 420px; width: 420px;
background: #fff; background: var(--ch-layer-solid);
border-radius: 14px; border-radius: 14px;
padding: 28px 26px 20px; padding: 28px 26px 20px;
box-shadow: 0 18px 40px rgba(15, 30, 50, 0.28); box-shadow: 0 18px 40px rgba(15, 30, 50, 0.28);
@@ -198,7 +208,7 @@ async function enterOffline(): Promise<void> {
.login-sub { .login-sub {
margin: 4px 0 0; margin: 4px 0 0;
font-size: 12px; font-size: 12px;
color: #909399; color: var(--ch-text-secondary);
} }
.login-actions { .login-actions {
@@ -210,6 +220,12 @@ async function enterOffline(): Promise<void> {
flex: 1; flex: 1;
} }
.login-guide {
display: flex;
justify-content: center;
margin-top: 10px;
}
.offline-button { .offline-button {
width: 100%; width: 100%;
} }
@@ -218,6 +234,6 @@ async function enterOffline(): Promise<void> {
margin: 16px 0 0; margin: 16px 0 0;
font-size: 12px; font-size: 12px;
line-height: 1.7; line-height: 1.7;
color: #c0c4cc; color: var(--ch-text-tertiary);
} }
</style> </style>
@@ -165,11 +165,11 @@ onUnmounted(() => {
} }
.notice-item:hover { .notice-item:hover {
background: #f7f9fc; background: var(--ch-hover-soft);
} }
.notice-item.unread { .notice-item.unread {
background: #f0f7ff; background: var(--ch-accent-soft);
} }
.notice-item:last-child { .notice-item:last-child {
@@ -194,7 +194,7 @@ onUnmounted(() => {
.notice-content { .notice-content {
margin-top: 6px; margin-top: 6px;
font-size: 13px; font-size: 13px;
color: #606266; color: var(--ch-text-secondary);
display: -webkit-box; display: -webkit-box;
-webkit-line-clamp: 2; -webkit-line-clamp: 2;
-webkit-box-orient: vertical; -webkit-box-orient: vertical;
@@ -220,7 +220,7 @@ onUnmounted(() => {
.content-block { .content-block {
white-space: pre-wrap; white-space: pre-wrap;
line-height: 1.8; line-height: 1.8;
background: #fafafa; background: var(--ch-layer-alt);
border-radius: 8px; border-radius: 8px;
padding: 14px; padding: 14px;
margin: 0 0 16px; margin: 0 0 16px;
@@ -460,7 +460,7 @@ onUnmounted(() => {
} }
.hero-status.status-idle { .hero-status.status-idle {
background: rgba(0, 0, 0, 0.03); background: var(--ch-hover-soft);
} }
.status-title { .status-title {
@@ -553,7 +553,7 @@ onUnmounted(() => {
width: 10px; width: 10px;
height: 10px; height: 10px;
border-radius: 50%; border-radius: 50%;
background: #fff; background: var(--ch-layer-solid);
border: 2px solid var(--ch-border-strong); border: 2px solid var(--ch-border-strong);
} }
@@ -574,7 +574,8 @@ onUnmounted(() => {
padding: 10px 14px; padding: 10px 14px;
border: 1px solid var(--ch-border); border: 1px solid var(--ch-border);
border-radius: var(--ch-radius-card); border-radius: var(--ch-radius-card);
background: rgba(255, 255, 255, 0.6); /* 走主题变量:浅色是白玻璃、深色是深玻璃(写死白色会在深色主题下变成"浅灰卡 + 浅字"看不清) */
background: var(--ch-layer);
transition: transition:
border-color 0.15s ease, border-color 0.15s ease,
background 0.15s ease, background 0.15s ease,
@@ -595,7 +596,7 @@ onUnmounted(() => {
} }
.timeline-item.is-past .timeline-card-inner { .timeline-item.is-past .timeline-card-inner {
background: rgba(255, 255, 255, 0.35); background: var(--ch-layer-alt);
color: var(--ch-text-tertiary); color: var(--ch-text-tertiary);
} }
@@ -1,702 +0,0 @@
<script setup lang="ts">
import { computed, onMounted, ref } from 'vue';
import { useRouter } from 'vue-router';
import { ElMessage, ElMessageBox } from 'element-plus';
import {
CLASSISLAND_NOTIFICATION_CHANNEL_HINTS,
CLASSISLAND_NOTIFICATION_CHANNEL_LABELS,
CLASSISLAND_NOTIFICATION_CHANNELS,
HOMEWORK_PHRASE_DEFAULTS,
HOMEWORK_PHRASE_MAX_COUNT,
HOMEWORK_PHRASE_MAX_LENGTH,
DEFAULT_ISLAND_APPEARANCE,
ISLAND_APPEARANCE_RANGES as RANGES,
ISLAND_POSITION_LABELS,
ISLAND_STYLE_LABELS,
ISLAND_STYLES,
ISLAND_POSITIONS,
formatDate,
type ClassIslandNotificationChannel,
type IslandAppearance,
type IslandPosition,
type IslandStyle,
} from '@classhelper/shared';
import type { DesktopAppInfo } from '../../types/desktop.js';
import { classIslandStatusApi } from '../api/index.js';
import { pingHealth, setApiBaseUrl } from '../api/http.js';
import { normalizeServerUrl } from '../config.js';
import { useAppStore } from '../stores/app.js';
import { useAuthStore } from '../stores/auth.js';
import { useNotificationStore } from '../stores/notifications.js';
import { useRealtimeStore } from '../stores/realtime.js';
const router = useRouter();
const appStore = useAppStore();
const auth = useAuthStore();
const realtime = useRealtimeStore();
const notifications = useNotificationStore();
const serverInput = ref(appStore.serverUrl);
const testing = ref(false);
const saving = ref(false);
const appInfo = ref<DesktopAppInfo | null>(null);
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 loadAppInfo(): Promise<void> {
if (!window.desktop) return;
appInfo.value = await window.desktop.getAppInfo();
}
async function saveServer(): Promise<void> {
const normalized = normalizeServerUrl(serverInput.value);
if (!normalized) {
ElMessage.error('服务器地址格式不正确,例如 http://127.0.0.1:4000');
return;
}
saving.value = true;
try {
await appStore.applyServerUrl(normalized);
serverInput.value = normalized;
ElMessage.success('服务器地址已保存');
await testConnection();
if (auth.token) realtime.connect(normalized, auth.token);
} finally {
saving.value = false;
}
}
async function testConnection(): Promise<void> {
testing.value = true;
try {
const result = await pingHealth();
if (result.ok) ElMessage.success('服务器连接正常');
else ElMessage.error('无法连接服务器,请检查地址与网络');
} finally {
testing.value = false;
}
}
async function manualSync(): Promise<void> {
setApiBaseUrl(appStore.serverUrl);
await appStore.ping();
if (appStore.offline) {
ElMessage.warning('当前无法连接服务器,已保留缓存数据');
return;
}
await notifications.load();
appStore.markSynced();
ElMessage.success('已同步最新数据');
}
async function clearCache(): Promise<void> {
await ElMessageBox.confirm('清空后离线时将无法查看历史数据,确认继续?', '清空离线缓存', {
type: 'warning',
});
await appStore.clearCache();
ElMessage.success('离线缓存已清空');
}
async function logout(): Promise<void> {
await ElMessageBox.confirm('确认退出当前账号?', '退出登录', { type: 'warning' });
realtime.disconnect();
await auth.logout();
ElMessage.success('已退出登录');
await router.replace('/login');
}
/* ------------------------------------------------------------ 通知显示位置 */
/**
* 通知显示位置:这台教室机器把提醒弹在哪个端。
*
* - both:ClassHelper 客户端(弹窗 + 灵动岛)与 ClassIsland 都弹(默认)
* - client:只弹 ClassHelper 客户端
* - classisland:只弹 ClassIsland(客户端只进通知中心,不弹窗、不上岛)
*
* 值会落本地配置(本机立刻生效)并写回班级记录(服务端据此决定要不要推 ClassIsland)。
*/
const channelSaving = ref(false);
/**
* 本班有没有接入 ClassIsland 设备。
*
* 只用来禁用「只在 ClassIsland 上弹」——没有设备时选它等于把提醒静默丢掉;
* 注意**不能**顺手把「两端都弹」也禁掉:那样教室一旦选过"只在客户端",没设备时就再也切不回来了。
*/
const classIslandConnected = ref(false);
/** 本班 ClassIsland 设备的展示信息(设备名 / 最后上报),来自 /classes/:id/classisland-status */
const classIslandStatus = ref<{
connected: boolean;
deviceName: string | null;
deviceCount: number;
lastSeenAt: string | null;
pluginVersion: string | null;
classIslandVersion: string | null;
} | null>(null);
const classIslandStatusText = computed(() => {
const status = classIslandStatus.value;
if (!status || !status.connected) return '未接入';
const seen = status.lastSeenAt ? `最后上报 ${formatDate(status.lastSeenAt, true)}` : '尚未上报过';
return `已接入 · ${status.deviceName ?? 'ClassIsland 设备'} · ${seen}`;
});
const channelOptions = computed(() =>
CLASSISLAND_NOTIFICATION_CHANNELS.map((value) => ({
value,
label: CLASSISLAND_NOTIFICATION_CHANNEL_LABELS[value],
disabled: value === 'classisland' && !classIslandConnected.value,
})),
);
async function loadClassChannel(): Promise<void> {
const classId = auth.classId;
if (!classId) return;
await appStore.loadNotificationChannel(classId);
}
async function applyChannel(value: ClassIslandNotificationChannel): Promise<void> {
channelSaving.value = true;
try {
const saved = await appStore.setNotificationChannel(auth.classId, value);
if (saved) ElMessage.success('提醒显示位置已更新');
else ElMessage.warning('已保存在本机,但同步到服务器失败(离线或权限不足),联网后请再点一次');
} finally {
channelSaving.value = false;
}
}
/* ------------------------------------------------------------ 作业录入快捷短语 */
/**
* 作业快捷短语:录作业时点一下就把词追加到标题/内容里(P、大本、背诵…)。
*
* 存在客户端本地配置(这台教室机器自己的习惯),不占用服务端字段;
* 空数组是合法值 —— 老师把短语全删了就是"不想用快捷短语"。
*/
const phrases = ref<string[]>([...HOMEWORK_PHRASE_DEFAULTS]);
const phraseInput = ref('');
const savingPhrases = ref(false);
async function loadPhrases(): Promise<void> {
const config = await window.desktop?.getConfig?.();
if (config?.homeworkPhrases) phrases.value = [...config.homeworkPhrases];
}
async function savePhrases(): Promise<void> {
if (!window.desktop?.saveConfig) return;
savingPhrases.value = true;
try {
const saved = await window.desktop.saveConfig({ homeworkPhrases: [...phrases.value] });
phrases.value = [...saved.homeworkPhrases];
} finally {
savingPhrases.value = false;
}
}
async function addPhrase(): Promise<void> {
const value = phraseInput.value.trim().slice(0, HOMEWORK_PHRASE_MAX_LENGTH);
if (!value) return;
if (phrases.value.includes(value)) {
ElMessage.warning('这条短语已经有了');
return;
}
if (phrases.value.length >= HOMEWORK_PHRASE_MAX_COUNT) {
ElMessage.warning(`最多 ${HOMEWORK_PHRASE_MAX_COUNT} 条快捷短语`);
return;
}
phrases.value = [...phrases.value, value];
phraseInput.value = '';
await savePhrases();
ElMessage.success('已添加');
}
async function removePhrase(value: string): Promise<void> {
phrases.value = phrases.value.filter((item) => item !== value);
await savePhrases();
}
async function resetPhrases(): Promise<void> {
await ElMessageBox.confirm('恢复为默认快捷短语?', '恢复默认', { type: 'warning' });
phrases.value = [...HOMEWORK_PHRASE_DEFAULTS];
await savePhrases();
ElMessage.success('已恢复默认');
}
/* ------------------------------------------------------------ 灵动岛个性化 */
const island = ref<IslandAppearance>({ ...DEFAULT_ISLAND_APPEARANCE });
/**
* 左右边距是否有效:只在停靠左 / 右时生效。
*
* 岛是"居中停靠"时(默认就是顶部居中),水平方向的锚点就是屏幕中线 ——
* 这时调左右边距不会有任何变化。之前没把这点说清楚,用户会以为"调了不生效"。
*/
const marginXApplies = computed(() => !island.value.position.endsWith('center'));
const savingIsland = ref(false);
const positionOptions = ISLAND_POSITIONS.map((value) => ({
value,
label: ISLAND_POSITION_LABELS[value],
}));
const styleOptions = ISLAND_STYLES.map((value) => ({
value,
label: ISLAND_STYLE_LABELS[value],
}));
/** 读取当前生效的外观(主进程为单一事实来源) */
async function loadIslandAppearance(): Promise<void> {
if (!window.desktop?.islandGetAppearance) return;
island.value = await window.desktop.islandGetAppearance();
}
/**
* 改动即生效:属性变化时先应用(实时预览),点"保存"再落盘。
* 高度/宽度只影响窗口与卡片尺寸变量,内容用 flex + 溢出滚动承载,不会溢出或错乱。
*
* 注意:必须传**展开后的纯对象**。`island` 是 `ref`,它的 `.value` 在 Vue 里是响应式
* Proxy,Proxy 过不了 IPC 的结构化克隆(`An object could not be cloned.`)——
* 那正是"拖了滑块、数字在变、灵动岛却没反应"的原因。
*/
function applyIslandAppearance(patch: Partial<IslandAppearance> = {}): void {
island.value = { ...island.value, ...patch };
window.desktop?.islandSetAppearance({ ...island.value });
}
async function saveIslandAppearance(): Promise<void> {
if (!window.desktop?.saveConfig) return;
savingIsland.value = true;
try {
await window.desktop.saveConfig({ island: { ...island.value } });
ElMessage.success('个性化设置已保存');
} finally {
savingIsland.value = false;
}
}
async function resetIslandAppearance(): Promise<void> {
await ElMessageBox.confirm('恢复灵动岛的默认外观?', '恢复默认', { type: 'warning' });
applyIslandAppearance({ ...DEFAULT_ISLAND_APPEARANCE });
await saveIslandAppearance();
}
/** 本地推一条测试通知,立刻确认外观效果(预览模式:直接展开、失焦不收起、30 秒后自动消失) */
function testIsland(): void {
window.desktop?.islandPush?.({
notification: {
id: `appearance-test-${Date.now()}`,
title: '灵动岛外观预览',
content: '拖动滑块即可实时预览:高度、宽度、圆角、透明度、字号、主题色、位置与动画。',
priority: 'NORMAL',
createdAt: new Date().toISOString(),
courseName: null,
teacherName: '本地预览',
},
context: { inClass: false, currentPeriodEnd: null, preview: true },
});
}
onMounted(async () => {
await loadAppInfo();
await appStore.refreshCacheStats();
await loadIslandAppearance();
await loadClassChannel();
await loadPhrases();
// 本班 ClassIsland 联动状态:没接设备就别让选「只在 ClassIsland 上弹」
if (auth.classId) {
const status = await classIslandStatusApi.get(auth.classId).catch(() => null);
classIslandStatus.value = status;
classIslandConnected.value = status?.connected === true;
}
});
</script>
<template>
<div class="page">
<div class="page-header">
<div>
<h2 class="page-title">设置</h2>
<p class="page-subtitle">服务器连接、账号信息与离线缓存管理</p>
</div>
</div>
<el-row :gutter="12">
<el-col :xs="24" :md="12">
<el-card shadow="never">
<template #header><span>服务器连接</span></template>
<el-form label-position="top">
<el-form-item label="服务器地址">
<el-input v-model="serverInput" placeholder="http://127.0.0.1:4000">
<template #prefix>
<el-icon><Link /></el-icon>
</template>
</el-input>
</el-form-item>
</el-form>
<div class="toolbar">
<el-button type="primary" :loading="saving" @click="saveServer">保存并测试</el-button>
<el-button :loading="testing" @click="testConnection">测试连接</el-button>
<el-button @click="manualSync">立即同步</el-button>
</div>
<el-descriptions class="mt-16" :column="1" border size="small">
<el-descriptions-item label="当前状态">
<el-tag :type="appStore.serverReachable ? 'success' : 'danger'" size="small">
{{ appStore.serverReachable ? '服务器可达' : '离线(显示缓存数据)' }}
</el-tag>
<el-tag class="ml-8" :type="realtime.connected ? 'success' : 'info'" size="small">
{{ realtime.statusText }}
</el-tag>
</el-descriptions-item>
<el-descriptions-item label="最近同步">{{ appStore.lastSyncText }}</el-descriptions-item>
<el-descriptions-item label="实时事件数">{{ realtime.eventCount }} 条</el-descriptions-item>
</el-descriptions>
</el-card>
<el-card shadow="never" class="mt-12">
<template #header>
<span>灵动岛 · 个性化</span>
</template>
<el-form label-width="96px" label-position="left">
<el-form-item :label="`高度 ${island.height}px`">
<el-slider
:model-value="island.height"
:min="RANGES.height.min"
:max="RANGES.height.max"
:step="1"
@input="(value: number) => applyIslandAppearance({ height: value })"
/>
</el-form-item>
<el-form-item :label="`宽度 ${island.width}px`">
<el-slider
:model-value="island.width"
:min="RANGES.width.min"
:max="RANGES.width.max"
:step="2"
@input="(value: number) => applyIslandAppearance({ width: value })"
/>
</el-form-item>
<el-form-item :label="`圆角 ${island.radius}px`">
<el-slider
:model-value="island.radius"
:min="RANGES.radius.min"
:max="RANGES.radius.max"
:step="1"
@input="(value: number) => applyIslandAppearance({ radius: value })"
/>
</el-form-item>
<el-form-item :label="`不透明度 ${Math.round(island.opacity * 100)}%`">
<el-slider
:model-value="island.opacity"
:min="RANGES.opacity.min"
:max="RANGES.opacity.max"
:step="0.05"
@input="(value: number) => applyIslandAppearance({ opacity: value })"
/>
</el-form-item>
<el-form-item :label="`字号 ${island.fontSize}px`">
<el-slider
:model-value="island.fontSize"
:min="RANGES.fontSize.min"
:max="RANGES.fontSize.max"
:step="1"
@input="(value: number) => applyIslandAppearance({ fontSize: value })"
/>
</el-form-item>
<el-form-item :label="`动画速度 ${island.speed.toFixed(1)}x`">
<el-slider
:model-value="island.speed"
:min="RANGES.speed.min"
:max="RANGES.speed.max"
:step="0.1"
@input="(value: number) => applyIslandAppearance({ speed: value })"
/>
</el-form-item>
<el-form-item label="主题色">
<el-color-picker
:model-value="island.accent"
@change="(value: string | null) => applyIslandAppearance({ accent: value ?? '#0a84ff' })"
/>
<span class="text-muted ml-8">用于高亮、按钮与进度条</span>
</el-form-item>
<el-form-item label="视觉风格">
<el-select
:model-value="island.style"
style="width: 180px"
@change="(value: IslandStyle) => applyIslandAppearance({ style: value })"
>
<el-option
v-for="item in styleOptions"
:key="item.value"
:label="item.label"
:value="item.value"
/>
</el-select>
<span class="text-muted ml-8">纯黑 / 毛玻璃(半透明)/ 主题色渐变</span>
</el-form-item>
<el-form-item label="显示位置">
<el-select
:model-value="island.position"
style="width: 180px"
@change="(value: IslandPosition) => applyIslandAppearance({ position: value })"
>
<el-option
v-for="item in positionOptions"
:key="item.value"
:label="item.label"
:value="item.value"
/>
</el-select>
</el-form-item>
<el-form-item :label="`左右边距 ${island.marginX}px`">
<el-slider
:model-value="island.marginX"
:min="RANGES.marginX.min"
:max="RANGES.marginX.max"
:step="2"
:disabled="!marginXApplies"
@input="(value: number) => applyIslandAppearance({ marginX: value })"
/>
<span v-if="marginXApplies" class="text-muted ml-8">停靠左/右时距屏幕边缘的距离</span>
<span v-else class="text-muted ml-8">
当前是「居中」停靠,左右边距不生效 —— 把上面的「显示位置」改成左 / 右停靠即可看到效果
</span>
</el-form-item>
<el-form-item :label="`上下边距 ${island.marginY}px`">
<el-slider
:model-value="island.marginY"
:min="RANGES.marginY.min"
:max="RANGES.marginY.max"
:step="2"
@input="(value: number) => applyIslandAppearance({ marginY: value })"
/>
<span class="text-muted ml-8">停靠顶/底时距屏幕边缘的距离(任务栏在侧面时调大)</span>
</el-form-item>
<el-form-item label="跟随鼠标屏幕">
<el-switch
:model-value="island.followCursorDisplay"
@change="
(value: boolean | string | number) =>
applyIslandAppearance({ followCursorDisplay: Boolean(value) })
"
/>
<span class="text-muted ml-8">多显示器教室电脑:岛出现在鼠标所在的那块屏幕</span>
</el-form-item>
<el-form-item label="动画">
<el-switch
:model-value="island.animations"
@change="
(value: boolean | string | number) => applyIslandAppearance({ animations: Boolean(value) })
"
/>
<span class="text-muted ml-8">关闭后展开/收起为瞬时生效</span>
</el-form-item>
<el-form-item label="始终置顶">
<el-switch
:model-value="island.alwaysOnTop"
@change="
(value: boolean | string | number) => applyIslandAppearance({ alwaysOnTop: Boolean(value) })
"
/>
</el-form-item>
<el-form-item label="空闲细缝">
<el-switch
:model-value="island.idleSliver"
@change="
(value: boolean | string | number) => applyIslandAppearance({ idleSliver: Boolean(value) })
"
/>
<span class="text-muted ml-8">参考 WinIsland:没有消息时保留一条细缝(关闭则完全隐藏)</span>
</el-form-item>
</el-form>
<div class="toolbar">
<el-button type="primary" :loading="savingIsland" @click="saveIslandAppearance">
保存设置
</el-button>
<el-button @click="testIsland">预览效果</el-button>
<el-button @click="resetIslandAppearance">恢复默认</el-button>
</div>
<el-alert
class="mt-12"
type="info"
:closable="false"
title="拖动滑块即为实时预览;保存后写入本地配置,重启客户端仍然生效"
/>
</el-card>
<el-card shadow="never" class="mt-12">
<template #header><span>ClassIsland 联动</span></template>
<el-descriptions :column="1" border size="small" class="mb-12">
<el-descriptions-item label="联动状态">{{ classIslandStatusText }}</el-descriptions-item>
<el-descriptions-item label="插件 / ClassIsland">
{{ classIslandStatus?.pluginVersion ?? '—' }} /
{{ classIslandStatus?.classIslandVersion ?? '—' }}
</el-descriptions-item>
</el-descriptions>
<p class="text-muted">
<strong>通知模式</strong>
:老师在班级小助手上发布通知 / 叫人时,提醒弹在灵动岛还是 ClassIsland,
由这台教室机器决定。选择会同步到班级,服务端据此决定是否推送到教室的 ClassIsland。
</p>
<el-radio-group
:model-value="appStore.notificationChannel"
:disabled="channelSaving"
class="channel-group"
@change="
(value: string | number | boolean | undefined) =>
applyChannel(value as ClassIslandNotificationChannel)
"
>
<el-radio
v-for="item in channelOptions"
:key="item.value"
:value="item.value"
:disabled="item.disabled"
>
{{ item.label }}
</el-radio>
</el-radio-group>
<p class="text-muted channel-hint">
{{ CLASSISLAND_NOTIFICATION_CHANNEL_HINTS[appStore.notificationChannel] }}
<template v-if="!classIslandConnected">
<br />
提示:本班还没有接入 ClassIsland 设备(在 Web 端「ClassIsland 联动」里接入后才能选"只在
ClassIsland 上弹")。
</template>
</p>
</el-card>
<el-card shadow="never" class="mt-12">
<template #header><span>作业录入</span></template>
<p class="text-muted">
在教室电脑上录作业时,点一下短语就会追加到标题 / 内容里(例如 P、大本、背诵)。 最多
{{ HOMEWORK_PHRASE_MAX_COUNT }} 条、每条
{{ HOMEWORK_PHRASE_MAX_LENGTH }} 字;全部删掉即不在录入页显示。
</p>
<div class="phrase-row">
<el-tag
v-for="item in phrases"
:key="item"
closable
type="info"
effect="plain"
@close="removePhrase(item)"
>
{{ item }}
</el-tag>
<span v-if="phrases.length === 0" class="text-muted">(已清空)</span>
</div>
<div class="toolbar mt-12">
<el-input
v-model="phraseInput"
placeholder="新增短语,如 大本"
style="width: 200px"
:maxlength="HOMEWORK_PHRASE_MAX_LENGTH"
@keyup.enter="addPhrase"
/>
<el-button type="primary" :loading="savingPhrases" @click="addPhrase">添加</el-button>
<el-button @click="resetPhrases">恢复默认</el-button>
</div>
</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="姓名">{{ auth.user?.name ?? '-' }}</el-descriptions-item>
<el-descriptions-item :label="auth.isClassSession ? '班级码' : '用户名'">
{{ auth.user?.username ?? '-' }}
</el-descriptions-item>
<el-descriptions-item label="登录方式">
{{ auth.isClassSession ? '班级账号(本机代表全班)' : '个人学生账号' }}
</el-descriptions-item>
<el-descriptions-item label="班级">{{ auth.user?.className ?? '未分班' }}</el-descriptions-item>
<el-descriptions-item label="年级">{{ auth.user?.grade ?? '-' }}</el-descriptions-item>
</el-descriptions>
<el-button class="mt-16" type="danger" plain @click="logout">退出登录</el-button>
</el-card>
</el-col>
<el-col :xs="24" :md="12">
<el-card shadow="never">
<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 :icon="'Refresh'" @click="appStore.refreshCacheStats()">刷新统计</el-button>
<el-button type="danger" plain @click="clearCache">清空缓存</el-button>
</div>
<el-alert
class="mt-12"
type="info"
:closable="false"
show-icon
title="离线可用"
description="断网后课表、作业、通知、成绩都会从本地缓存读取;恢复网络后自动向服务器同步最新数据。"
/>
</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="应用版本">{{ appInfo?.appVersion ?? '-' }}</el-descriptions-item>
<el-descriptions-item label="Electron">{{ appInfo?.electron ?? '-' }}</el-descriptions-item>
<el-descriptions-item label="Chromium">{{ appInfo?.chrome ?? '-' }}</el-descriptions-item>
<el-descriptions-item label="Node.js">{{ appInfo?.node ?? '-' }}</el-descriptions-item>
<el-descriptions-item label="平台">{{ appInfo?.platform ?? '-' }}</el-descriptions-item>
<el-descriptions-item label="数据目录">{{ appInfo?.userDataPath ?? '-' }}</el-descriptions-item>
</el-descriptions>
</el-card>
</el-col>
</el-row>
</div>
</template>
<style scoped>
.channel-group {
display: flex;
flex-direction: column;
align-items: flex-start;
gap: 6px;
margin-top: 10px;
}
.channel-hint {
margin-top: 10px;
}
.phrase-row {
display: flex;
flex-wrap: wrap;
align-items: center;
gap: 8px;
margin-top: 12px;
}
.ml-8 {
margin-left: 8px;
}
</style>
@@ -0,0 +1,301 @@
<script setup lang="ts">
import { onMounted, ref } from 'vue';
import { ElMessage } from 'element-plus';
import type { UpdateInfo } from '@classhelper/shared';
import type { DesktopAppInfo } from '../../../types/desktop.js';
import { useAppStore } from '../../stores/app.js';
/**
* 关于(ClassIsland 同款折叠卡片式):
* 应用信息(版本/运行时/常用链接/检查更新)→ 诊断信息(排查问题用)→ 鸣谢。
* 所有外链走主进程 openExternal(只放行 http/https,见 main/ipc.ts 的白名单)。
*/
const appStore = useAppStore();
const appInfo = ref<DesktopAppInfo | null>(null);
/** 折叠面板默认展开第一项(应用信息),诊断信息默认收起 */
const expandedNames = ref(['app']);
/** 检查更新:结果由主进程直连 GitHub 得到(见 main/update.ts) */
const checking = ref(false);
const updateInfo = ref<UpdateInfo | null>(null);
const PROJECT_URL = 'https://github.com/LoveChengke/ClassHelper';
const ISSUES_URL = 'https://github.com/LoveChengke/ClassHelper/issues';
const collapseItems = [
{ name: 'app', title: '应用信息', icon: 'School' },
{ name: 'diagnostics', title: '查看诊断信息', icon: 'Warning' },
{ name: 'thanks', title: '鸣谢', icon: 'Pointer' },
];
async function openExternal(url: string): Promise<void> {
if (window.desktop?.openExternal) {
const handled = await window.desktop.openExternal(url);
if (handled) return;
}
window.open(url, '_blank');
}
/**
* 检查更新。
*
* @param force true = 用户主动点击(绕过主进程缓存);false = 进页面时带出启动自动检查的结果
*/
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 ignoreVersion(): Promise<void> {
const version = updateInfo.value?.latestVersion;
if (!version) return;
await window.desktop?.ignoreUpdateVersion(version);
ElMessage.success(`已忽略 v${version} 的更新提示`);
}
onMounted(async () => {
if (!window.desktop) return;
appInfo.value = await window.desktop.getAppInfo().catch(() => null);
// 带出启动自动检查的结果(命中主进程缓存,不会再发一次请求)
void checkUpdate(false);
});
</script>
<template>
<div class="page">
<div class="page-header">
<div>
<h2 class="page-title">关于</h2>
<p class="page-subtitle">版本、诊断信息与鸣谢</p>
</div>
</div>
<el-collapse v-model="expandedNames" class="about-collapse">
<!-- 应用信息 -->
<el-collapse-item name="app">
<template #title>
<span class="about-title">
<el-icon><School /></el-icon>
{{ collapseItems[0].title }}
</span>
<span class="about-extra">班级小助手 v{{ appInfo?.appVersion ?? '-' }}</span>
</template>
<div class="about-section">
<p class="about-copy">
Copyright © 2025-2026 班级小助手
<br />
面向班级的课表 · 作业 · 通知 · 成绩信息工具(Web 管理端 + 桌面客户端 + 灵动岛)
</p>
<div class="about-links">
<span class="about-links-label">常用链接</span>
<el-button link type="primary" @click="openExternal(PROJECT_URL)">项目主页</el-button>
<el-button link type="primary" @click="openExternal(ISSUES_URL)">问题反馈</el-button>
</div>
<el-descriptions :column="1" border size="small" class="mt-12">
<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>
<!-- 检查更新:直连 GitHub 看最新的 Release 是不是比本机新 -->
<div class="about-update" data-test="update-check">
<div class="about-update-head">
<span class="about-update-label">检查更新</span>
<el-button
size="small"
:loading="checking"
data-test="update-check-button"
@click="checkUpdate(true)"
>
检查更新
</el-button>
</div>
<div class="about-update-body">
<template v-if="checking">正在检查…</template>
<template v-else-if="!updateInfo">尚未检查</template>
<template v-else-if="!updateInfo.ok">
<!-- 教室机器没有外网是常态,这里只是"查不到",不是错误 -->
<span class="about-update-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="about-update-muted">当前 v{{ updateInfo.currentVersion }}</span>
<el-button
link
type="primary"
size="small"
data-test="update-download"
@click="openExternal(updateInfo.releaseUrl)"
>
前往下载
</el-button>
<el-button link size="small" @click="ignoreVersion">忽略此版本</el-button>
</template>
<template v-else>
<el-tag size="small" type="info" effect="plain">已是最新版本</el-tag>
<span class="about-update-muted">
v{{ updateInfo.currentVersion }} · {{ updateInfo.latestVersion }}
</span>
</template>
</div>
</div>
</div>
</el-collapse-item>
<!-- 诊断信息 -->
<el-collapse-item name="diagnostics">
<template #title>
<span class="about-title">
<el-icon><Warning /></el-icon>
{{ collapseItems[1].title }}
</span>
<span class="about-extra">报障时请附带本页信息</span>
</template>
<div class="about-section">
<el-descriptions :column="1" border size="small">
<el-descriptions-item label="服务器地址">{{ appStore.serverUrl }}</el-descriptions-item>
<el-descriptions-item label="连接状态">
<el-tag size="small" :type="appStore.serverReachable ? 'success' : 'danger'">
{{ appStore.serverReachable ? '服务器可达' : '离线(显示缓存数据)' }}
</el-tag>
</el-descriptions-item>
<el-descriptions-item label="最近同步">{{ appStore.lastSyncText }}</el-descriptions-item>
<el-descriptions-item label="缓存条目">{{ appStore.cacheItemCount }} 条</el-descriptions-item>
<el-descriptions-item label="数据目录">{{ appInfo?.userDataPath ?? '-' }}</el-descriptions-item>
<el-descriptions-item label="配置文件">{{ appInfo?.configPath ?? '-' }}</el-descriptions-item>
</el-descriptions>
</div>
</el-collapse-item>
<!-- 鸣谢 -->
<el-collapse-item name="thanks">
<template #title>
<span class="about-title">
<el-icon><Pointer /></el-icon>
{{ collapseItems[2].title }}
</span>
</template>
<div class="about-section">
<ul class="about-thanks">
<li>
<strong>ClassIsland</strong>
—— 界面风格、设置页与「今天」时间轴的交互参考
</li>
<li>
<strong>WinIsland</strong>
—— 灵动岛的窗口形态与弹簧动画参考
</li>
<li>
<strong>Vue / Element Plus / Prisma / Express / Socket.IO</strong>
—— 本项目赖以构建的开源基石
</li>
</ul>
</div>
</el-collapse-item>
</el-collapse>
<p class="about-quote">谨以此应用,献给朝夕相伴的班级与同窗;愿时光流转,情谊常在。</p>
</div>
</template>
<style scoped>
.about-title {
display: inline-flex;
align-items: center;
gap: 8px;
}
.about-extra {
margin-left: auto;
margin-right: 12px;
font-size: 12px;
font-weight: 400;
color: var(--ch-text-tertiary);
}
.about-section {
padding: 0 4px;
}
.about-copy {
margin: 0 0 10px;
line-height: 1.8;
color: var(--ch-text-secondary);
font-size: 12.5px;
}
.about-links {
display: flex;
align-items: center;
gap: 4px;
}
.about-links-label {
font-size: 12.5px;
color: var(--ch-text-secondary);
margin-right: 4px;
}
/* 检查更新:颜色一律走 --ch-* 变量(深色主题下不能写死浅色底/深色字) */
.about-update {
margin-top: 12px;
padding: 10px 12px;
border: 1px solid var(--ch-border);
border-radius: var(--ch-radius-card);
background: var(--ch-layer-alt);
}
.about-update-head {
display: flex;
align-items: center;
justify-content: space-between;
gap: 8px;
}
.about-update-label {
font-size: 12.5px;
font-weight: 600;
color: var(--ch-text-secondary);
}
.about-update-body {
display: flex;
align-items: center;
flex-wrap: wrap;
gap: 8px;
margin-top: 8px;
font-size: 12.5px;
color: var(--ch-text);
}
.about-update-muted {
color: var(--ch-text-tertiary);
}
.about-thanks {
margin: 0;
padding-left: 18px;
line-height: 2;
font-size: 12.5px;
color: var(--ch-text-secondary);
}
.about-quote {
margin: 18px 0 4px;
text-align: center;
font-size: 12px;
color: var(--ch-text-tertiary);
}
</style>
@@ -0,0 +1,55 @@
<script setup lang="ts">
import { useRouter } from 'vue-router';
import { ElMessage, ElMessageBox } from 'element-plus';
import { useAuthStore } from '../../stores/auth.js';
import { useRealtimeStore } from '../../stores/realtime.js';
/**
* 账号设置:本机登录的班级账号信息 + 退出登录。
* 班级密码由管理员在 Web 管理端维护(本机按用户要求不提供改密入口)。
*/
const router = useRouter();
const auth = useAuthStore();
const realtime = useRealtimeStore();
async function logout(): Promise<void> {
await ElMessageBox.confirm('确认退出当前账号?', '退出登录', { type: 'warning' });
realtime.disconnect();
await auth.logout();
ElMessage.success('已退出登录');
await router.replace('/login');
}
</script>
<template>
<div class="page">
<div class="page-header">
<div>
<h2 class="page-title">账号</h2>
<p class="page-subtitle">本机登录的班级账号</p>
</div>
</div>
<el-card shadow="never">
<template #header><span>账号信息</span></template>
<el-descriptions :column="1" border size="small">
<el-descriptions-item label="姓名">{{ auth.user?.name ?? '-' }}</el-descriptions-item>
<el-descriptions-item :label="auth.isClassSession ? '班级码' : '用户名'">
{{ auth.user?.username ?? '-' }}
</el-descriptions-item>
<el-descriptions-item label="登录方式">
{{ auth.isClassSession ? '班级账号(本机代表全班)' : '班级账号' }}
</el-descriptions-item>
<el-descriptions-item label="班级">{{ auth.user?.className ?? '未分班' }}</el-descriptions-item>
<el-descriptions-item label="年级">{{ auth.user?.grade ?? '-' }}</el-descriptions-item>
</el-descriptions>
<div class="toolbar mt-16">
<el-button type="danger" plain @click="logout">退出登录</el-button>
</div>
<div class="text-muted mt-12">
班级密码由管理员在 Web 管理端「班级管理 → 修改班级账号」中设置;本机退出后用班级码 +
班级密码重新登录。
</div>
</el-card>
</div>
</template>
@@ -0,0 +1,162 @@
<script setup lang="ts">
import { ElMessage } from 'element-plus';
import { useUiStore } from '../../stores/ui.js';
/**
* 外观:黑夜 / 白天模式。
* 状态与持久化都在 stores/ui.ts(主进程配置 theme 字段),顶栏右上角的
* 日月按钮与本页写同一份配置,切换立即生效(html.dark + Element Plus dark css-vars)。
*/
const ui = useUiStore();
const options = [
{ value: 'light', label: '浅色', desc: '明亮界面,适合白天与投影环境' },
{ value: 'dark', label: '深色', desc: '黑夜模式,适合晚自习与暗教室' },
] as const;
async function selectTheme(value: 'light' | 'dark'): Promise<void> {
if (value === ui.theme) return;
await ui.setTheme(value);
ElMessage.success(value === 'dark' ? '已切换到深色模式' : '已切换到浅色模式');
}
</script>
<template>
<div class="page">
<div class="page-header">
<div>
<h2 class="page-title">外观</h2>
<p class="page-subtitle">黑夜与白天模式,切换立即生效并自动保存</p>
</div>
</div>
<el-card shadow="never">
<template #header><span>界面主题</span></template>
<div class="theme-options">
<button
v-for="option in options"
:key="option.value"
type="button"
class="theme-option"
:class="[`theme-${option.value}`, { active: ui.theme === option.value }]"
:data-theme-option="option.value"
@click="selectTheme(option.value)"
>
<span class="theme-preview">
<span class="preview-side" />
<span class="preview-body">
<span class="preview-line" />
<span class="preview-line short" />
</span>
</span>
<span class="theme-name">
<el-icon><Sunny v-if="option.value === 'light'" /><Moon v-else /></el-icon>
{{ option.label }}
</span>
<span class="theme-desc">{{ option.desc }}</span>
</button>
</div>
<el-alert
class="mt-12"
type="info"
:closable="false"
title="顶栏右上角也有主题快捷切换按钮"
description="灵动岛始终为深色浮窗,不随主题变化;登录页与全屏作业看板为固定配色,亦不受影响。"
/>
</el-card>
</div>
</template>
<style scoped>
.theme-options {
display: flex;
gap: 12px;
flex-wrap: wrap;
}
.theme-option {
width: 200px;
display: flex;
flex-direction: column;
align-items: flex-start;
gap: 6px;
padding: 12px;
border: 1px solid var(--ch-border-strong);
border-radius: var(--ch-radius-card);
background: var(--ch-layer);
cursor: pointer;
color: var(--ch-text);
text-align: left;
transition:
border-color 0.15s ease,
box-shadow 0.15s ease;
}
.theme-option:hover {
border-color: var(--ch-accent);
}
.theme-option.active {
border-color: var(--ch-accent);
box-shadow: 0 0 0 1px var(--ch-accent) inset;
}
/* 主题缩略预览:两块小色板直接表现各自配色 */
.theme-preview {
display: flex;
width: 100%;
height: 64px;
border-radius: 6px;
overflow: hidden;
border: 1px solid var(--ch-border-strong);
}
.theme-light .theme-preview {
background: #f3f3f3;
}
.theme-dark .theme-preview {
background: #161719;
}
.preview-side {
width: 28px;
background: rgba(255, 255, 255, 0.65);
}
.theme-dark .preview-side {
background: rgba(32, 33, 36, 0.9);
}
.preview-body {
flex: 1;
padding: 8px;
display: flex;
flex-direction: column;
gap: 6px;
}
.preview-line {
height: 8px;
border-radius: 4px;
width: 80%;
background: rgba(15, 108, 189, 0.55);
}
.preview-line.short {
width: 50%;
background: rgba(128, 128, 128, 0.35);
}
.theme-name {
display: inline-flex;
align-items: center;
gap: 6px;
font-weight: 600;
}
.theme-desc {
font-size: 12px;
color: var(--ch-text-tertiary);
}
</style>
@@ -0,0 +1,285 @@
<script setup lang="ts">
import { computed, onMounted, ref } from 'vue';
import { ElMessage, ElMessageBox } from 'element-plus';
import {
HOMEWORK_PHRASE_DEFAULTS,
HOMEWORK_PHRASE_MAX_COUNT,
HOMEWORK_PHRASE_MAX_LENGTH,
formatDate,
} from '@classhelper/shared';
import { pingHealth, setApiBaseUrl } from '../../api/http.js';
import { normalizeServerUrl } from '../../config.js';
import { useAppStore } from '../../stores/app.js';
import { useAuthStore } from '../../stores/auth.js';
import { useNotificationStore } from '../../stores/notifications.js';
import { useOnboardingStore } from '../../stores/onboarding.js';
import { useRealtimeStore } from '../../stores/realtime.js';
/**
* 通用设置:服务器连接、离线缓存与作业录入短语。
* (外观 / 灵动岛 / 提醒 / 账号 / 关于 各自是独立子页,见侧边栏「设置」分组。)
*/
const appStore = useAppStore();
const auth = useAuthStore();
const onboarding = useOnboardingStore();
const realtime = useRealtimeStore();
const notifications = useNotificationStore();
const serverInput = ref(appStore.serverUrl);
const testing = ref(false);
const saving = ref(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 saveServer(): Promise<void> {
const normalized = normalizeServerUrl(serverInput.value);
if (!normalized) {
ElMessage.error('服务器地址格式不正确,例如 http://127.0.0.1:4000');
return;
}
saving.value = true;
try {
await appStore.applyServerUrl(normalized);
serverInput.value = normalized;
ElMessage.success('服务器地址已保存');
await testConnection();
if (auth.token) realtime.connect(normalized, auth.token);
} finally {
saving.value = false;
}
}
async function testConnection(): Promise<void> {
testing.value = true;
try {
const result = await pingHealth();
if (result.ok) ElMessage.success('服务器连接正常');
else ElMessage.error('无法连接服务器,请检查地址与网络');
} finally {
testing.value = false;
}
}
async function manualSync(): Promise<void> {
setApiBaseUrl(appStore.serverUrl);
await appStore.ping();
if (appStore.offline) {
ElMessage.warning('当前无法连接服务器,已保留缓存数据');
return;
}
await notifications.load();
appStore.markSynced();
ElMessage.success('已同步最新数据');
}
async function clearCache(): Promise<void> {
await ElMessageBox.confirm('清空后离线时将无法查看历史数据,确认继续?', '清空离线缓存', {
type: 'warning',
});
await appStore.clearCache();
ElMessage.success('离线缓存已清空');
}
/* ------------------------------------------------------------ 作业录入快捷短语 */
/**
* 作业快捷短语:录作业时点一下就把词追加到标题/内容里(P、大本、背诵…)。
*
* 存在客户端本地配置(这台教室机器自己的习惯),不占用服务端字段;
* 空数组是合法值 —— 老师把短语全删了就是"不想用快捷短语"。
*/
const phrases = ref<string[]>([...HOMEWORK_PHRASE_DEFAULTS]);
const phraseInput = ref('');
const savingPhrases = ref(false);
async function loadPhrases(): Promise<void> {
const config = await window.desktop?.getConfig?.();
if (config?.homeworkPhrases) phrases.value = [...config.homeworkPhrases];
}
async function savePhrases(): Promise<void> {
if (!window.desktop?.saveConfig) return;
savingPhrases.value = true;
try {
const saved = await window.desktop.saveConfig({ homeworkPhrases: [...phrases.value] });
phrases.value = [...saved.homeworkPhrases];
} finally {
savingPhrases.value = false;
}
}
async function addPhrase(): Promise<void> {
const value = phraseInput.value.trim().slice(0, HOMEWORK_PHRASE_MAX_LENGTH);
if (!value) return;
if (phrases.value.includes(value)) {
ElMessage.warning('这条短语已经有了');
return;
}
if (phrases.value.length >= HOMEWORK_PHRASE_MAX_COUNT) {
ElMessage.warning(`最多 ${HOMEWORK_PHRASE_MAX_COUNT} 条快捷短语`);
return;
}
phrases.value = [...phrases.value, value];
phraseInput.value = '';
await savePhrases();
ElMessage.success('已添加');
}
async function removePhrase(value: string): Promise<void> {
phrases.value = phrases.value.filter((item) => item !== value);
await savePhrases();
}
async function resetPhrases(): Promise<void> {
await ElMessageBox.confirm('恢复为默认快捷短语?', '恢复默认', { type: 'warning' });
phrases.value = [...HOMEWORK_PHRASE_DEFAULTS];
await savePhrases();
ElMessage.success('已恢复默认');
}
onMounted(async () => {
await appStore.refreshCacheStats();
await loadPhrases();
});
</script>
<template>
<div class="page">
<div class="page-header">
<div>
<h2 class="page-title">通用</h2>
<p class="page-subtitle">服务器连接、离线缓存与作业录入</p>
</div>
<!-- 重看初次启动引导(首启时由 App.vue 自动弹出过一次) -->
<el-button @click="onboarding.open()">
<el-icon><Guide /></el-icon>
使用引导
</el-button>
</div>
<el-row :gutter="12">
<el-col :xs="24" :md="12">
<el-card shadow="never">
<template #header><span>服务器连接</span></template>
<el-form label-position="top">
<el-form-item label="服务器地址">
<el-input v-model="serverInput" placeholder="http://127.0.0.1:4000">
<template #prefix>
<el-icon><Link /></el-icon>
</template>
</el-input>
</el-form-item>
</el-form>
<div class="toolbar">
<el-button type="primary" :loading="saving" @click="saveServer">保存并测试</el-button>
<el-button :loading="testing" @click="testConnection">测试连接</el-button>
<el-button @click="manualSync">立即同步</el-button>
</div>
<el-descriptions class="mt-16" :column="1" border size="small">
<el-descriptions-item label="当前状态">
<el-tag :type="appStore.serverReachable ? 'success' : 'danger'" size="small">
{{ appStore.serverReachable ? '服务器可达' : '离线(显示缓存数据)' }}
</el-tag>
<el-tag class="ml-8" :type="realtime.connected ? 'success' : 'info'" size="small">
{{ realtime.statusText }}
</el-tag>
</el-descriptions-item>
<el-descriptions-item label="最近同步">{{ appStore.lastSyncText }}</el-descriptions-item>
<el-descriptions-item label="实时事件数">{{ realtime.eventCount }} 条</el-descriptions-item>
</el-descriptions>
</el-card>
<el-card shadow="never" class="mt-12">
<template #header><span>作业录入</span></template>
<p class="text-muted">
在教室电脑上录作业时,点一下短语就会追加到标题 / 内容里(例如 P、大本、背诵)。 最多
{{ HOMEWORK_PHRASE_MAX_COUNT }} 条、每条
{{ HOMEWORK_PHRASE_MAX_LENGTH }} 字;全部删掉即不在录入页显示。
</p>
<div class="phrase-row">
<el-tag
v-for="item in phrases"
:key="item"
closable
type="info"
effect="plain"
@close="removePhrase(item)"
>
{{ item }}
</el-tag>
<span v-if="phrases.length === 0" class="text-muted">(已清空)</span>
</div>
<div class="toolbar mt-12">
<el-input
v-model="phraseInput"
placeholder="新增短语,如 大本"
style="width: 200px"
:maxlength="HOMEWORK_PHRASE_MAX_LENGTH"
@keyup.enter="addPhrase"
/>
<el-button type="primary" :loading="savingPhrases" @click="addPhrase">添加</el-button>
<el-button @click="resetPhrases">恢复默认</el-button>
</div>
</el-card>
</el-col>
<el-col :xs="24" :md="12">
<el-card shadow="never">
<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 :icon="'Refresh'" @click="appStore.refreshCacheStats()">刷新统计</el-button>
<el-button type="danger" plain @click="clearCache">清空缓存</el-button>
</div>
<el-alert
class="mt-12"
type="info"
:closable="false"
show-icon
title="离线可用"
description="断网后课表、作业、通知、成绩都会从本地缓存读取;恢复网络后自动向服务器同步最新数据。"
/>
</el-card>
</el-col>
</el-row>
</div>
</template>
<style scoped>
.phrase-row {
display: flex;
flex-wrap: wrap;
align-items: center;
gap: 8px;
margin-top: 12px;
}
.ml-8 {
margin-left: 8px;
}
</style>
@@ -0,0 +1,276 @@
<script setup lang="ts">
import { computed, onMounted, ref } from 'vue';
import { ElMessage, ElMessageBox } from 'element-plus';
import {
DEFAULT_ISLAND_APPEARANCE,
ISLAND_APPEARANCE_RANGES as RANGES,
ISLAND_POSITION_LABELS,
ISLAND_POSITIONS,
ISLAND_STYLE_LABELS,
ISLAND_STYLES,
type IslandAppearance,
type IslandPosition,
type IslandStyle,
} from '@classhelper/shared';
/**
* 灵动岛个性化(原设置页「灵动岛 · 个性化」卡整块迁移)。
*
* 注意:必须传**展开后的纯对象**。`island` 是 `ref`,它的 `.value` 在 Vue 里是响应式
* Proxy,Proxy 过不了 IPC 的结构化克隆(`An object could not be cloned.`)——
* 那正是"拖了滑块、数字在变、灵动岛却没反应"的原因。
*/
const island = ref<IslandAppearance>({ ...DEFAULT_ISLAND_APPEARANCE });
const savingIsland = ref(false);
/**
* 左右边距是否有效:只在停靠左 / 右时生效。
*
* 岛是"居中停靠"时(默认就是顶部居中),水平方向的锚点就是屏幕中线 ——
* 这时调左右边距不会有任何变化。之前没把这点说清楚,用户会以为"调了不生效"。
*/
const marginXApplies = computed(() => !island.value.position.endsWith('center'));
const positionOptions = ISLAND_POSITIONS.map((value) => ({
value,
label: ISLAND_POSITION_LABELS[value],
}));
const styleOptions = ISLAND_STYLES.map((value) => ({
value,
label: ISLAND_STYLE_LABELS[value],
}));
/** 读取当前生效的外观(主进程为单一事实来源) */
async function loadIslandAppearance(): Promise<void> {
if (!window.desktop?.islandGetAppearance) return;
island.value = await window.desktop.islandGetAppearance();
}
/** 改动即生效:属性变化时先应用(实时预览),点"保存"再落盘 */
function applyIslandAppearance(patch: Partial<IslandAppearance> = {}): void {
island.value = { ...island.value, ...patch };
window.desktop?.islandSetAppearance({ ...island.value });
}
async function saveIslandAppearance(): Promise<void> {
if (!window.desktop?.saveConfig) return;
savingIsland.value = true;
try {
await window.desktop.saveConfig({ island: { ...island.value } });
ElMessage.success('个性化设置已保存');
} finally {
savingIsland.value = false;
}
}
async function resetIslandAppearance(): Promise<void> {
await ElMessageBox.confirm('恢复灵动岛的默认外观?', '恢复默认', { type: 'warning' });
applyIslandAppearance({ ...DEFAULT_ISLAND_APPEARANCE });
await saveIslandAppearance();
}
/** 本地推一条测试通知,立刻确认外观效果(预览模式:直接展开、失焦不收起、30 秒后自动消失) */
function testIsland(): void {
window.desktop?.islandPush?.({
notification: {
id: `appearance-test-${Date.now()}`,
title: '灵动岛外观预览',
content: '拖动滑块即可实时预览:高度、宽度、圆角、透明度、字号、主题色、位置与动画。',
priority: 'NORMAL',
createdAt: new Date().toISOString(),
courseName: null,
teacherName: '本地预览',
},
context: { inClass: false, currentPeriodEnd: null, preview: true },
});
}
onMounted(async () => {
await loadIslandAppearance();
});
</script>
<template>
<div class="page">
<div class="page-header">
<div>
<h2 class="page-title">灵动岛</h2>
<p class="page-subtitle">屏幕上方的消息浮窗:外观、停靠位置与动画</p>
</div>
</div>
<el-card shadow="never">
<template #header><span>灵动岛 · 个性化</span></template>
<el-form label-width="96px" label-position="left">
<el-form-item :label="`高度 ${island.height}px`">
<el-slider
:model-value="island.height"
:min="RANGES.height.min"
:max="RANGES.height.max"
:step="1"
@input="(value: number) => applyIslandAppearance({ height: value })"
/>
</el-form-item>
<el-form-item :label="`宽度 ${island.width}px`">
<el-slider
:model-value="island.width"
:min="RANGES.width.min"
:max="RANGES.width.max"
:step="2"
@input="(value: number) => applyIslandAppearance({ width: value })"
/>
</el-form-item>
<el-form-item :label="`圆角 ${island.radius}px`">
<el-slider
:model-value="island.radius"
:min="RANGES.radius.min"
:max="RANGES.radius.max"
:step="1"
@input="(value: number) => applyIslandAppearance({ radius: value })"
/>
</el-form-item>
<el-form-item :label="`不透明度 ${Math.round(island.opacity * 100)}%`">
<el-slider
:model-value="island.opacity"
:min="RANGES.opacity.min"
:max="RANGES.opacity.max"
:step="0.05"
@input="(value: number) => applyIslandAppearance({ opacity: value })"
/>
</el-form-item>
<el-form-item :label="`字号 ${island.fontSize}px`">
<el-slider
:model-value="island.fontSize"
:min="RANGES.fontSize.min"
:max="RANGES.fontSize.max"
:step="1"
@input="(value: number) => applyIslandAppearance({ fontSize: value })"
/>
</el-form-item>
<el-form-item :label="`动画速度 ${island.speed.toFixed(1)}x`">
<el-slider
:model-value="island.speed"
:min="RANGES.speed.min"
:max="RANGES.speed.max"
:step="0.1"
@input="(value: number) => applyIslandAppearance({ speed: value })"
/>
</el-form-item>
<el-form-item label="主题色">
<el-color-picker
:model-value="island.accent"
@change="(value: string | null) => applyIslandAppearance({ accent: value ?? '#0a84ff' })"
/>
<span class="text-muted ml-8">用于高亮、按钮与进度条</span>
</el-form-item>
<el-form-item label="视觉风格">
<el-select
:model-value="island.style"
style="width: 180px"
@change="(value: IslandStyle) => applyIslandAppearance({ style: value })"
>
<el-option
v-for="item in styleOptions"
:key="item.value"
:label="item.label"
:value="item.value"
/>
</el-select>
<span class="text-muted ml-8">纯黑 / 毛玻璃(半透明)/ 主题色渐变</span>
</el-form-item>
<el-form-item label="显示位置">
<el-select
:model-value="island.position"
style="width: 180px"
@change="(value: IslandPosition) => applyIslandAppearance({ position: value })"
>
<el-option
v-for="item in positionOptions"
:key="item.value"
:label="item.label"
:value="item.value"
/>
</el-select>
</el-form-item>
<el-form-item :label="`左右边距 ${island.marginX}px`">
<el-slider
:model-value="island.marginX"
:min="RANGES.marginX.min"
:max="RANGES.marginX.max"
:step="2"
:disabled="!marginXApplies"
@input="(value: number) => applyIslandAppearance({ marginX: value })"
/>
<span v-if="marginXApplies" class="text-muted ml-8">停靠左/右时距屏幕边缘的距离</span>
<span v-else class="text-muted ml-8">
当前是「居中」停靠,左右边距不生效 —— 把上面的「显示位置」改成左 / 右停靠即可看到效果
</span>
</el-form-item>
<el-form-item :label="`上下边距 ${island.marginY}px`">
<el-slider
:model-value="island.marginY"
:min="RANGES.marginY.min"
:max="RANGES.marginY.max"
:step="2"
@input="(value: number) => applyIslandAppearance({ marginY: value })"
/>
<span class="text-muted ml-8">停靠顶/底时距屏幕边缘的距离(任务栏在侧面时调大)</span>
</el-form-item>
<el-form-item label="跟随鼠标屏幕">
<el-switch
:model-value="island.followCursorDisplay"
@change="
(value: boolean | string | number) =>
applyIslandAppearance({ followCursorDisplay: Boolean(value) })
"
/>
<span class="text-muted ml-8">多显示器教室电脑:岛出现在鼠标所在的那块屏幕</span>
</el-form-item>
<el-form-item label="动画">
<el-switch
:model-value="island.animations"
@change="
(value: boolean | string | number) => applyIslandAppearance({ animations: Boolean(value) })
"
/>
<span class="text-muted ml-8">关闭后展开/收起为瞬时生效</span>
</el-form-item>
<el-form-item label="始终置顶">
<el-switch
:model-value="island.alwaysOnTop"
@change="
(value: boolean | string | number) => applyIslandAppearance({ alwaysOnTop: Boolean(value) })
"
/>
</el-form-item>
<el-form-item label="空闲细缝">
<el-switch
:model-value="island.idleSliver"
@change="
(value: boolean | string | number) => applyIslandAppearance({ idleSliver: Boolean(value) })
"
/>
<span class="text-muted ml-8">参考 WinIsland:没有消息时保留一条细缝(关闭则完全隐藏)</span>
</el-form-item>
</el-form>
<div class="toolbar">
<el-button type="primary" :loading="savingIsland" @click="saveIslandAppearance">保存设置</el-button>
<el-button @click="testIsland">预览效果</el-button>
<el-button @click="resetIslandAppearance">恢复默认</el-button>
</div>
<el-alert
class="mt-12"
type="info"
:closable="false"
title="拖动滑块即为实时预览;保存后写入本地配置,重启客户端仍然生效"
/>
</el-card>
</div>
</template>
<style scoped>
.ml-8 {
margin-left: 8px;
}
</style>
@@ -0,0 +1,141 @@
<script setup lang="ts">
import { computed, onMounted, ref } from 'vue';
import { ElMessage } from 'element-plus';
import {
CLASSISLAND_NOTIFICATION_CHANNEL_HINTS,
CLASSISLAND_NOTIFICATION_CHANNEL_LABELS,
CLASSISLAND_NOTIFICATION_CHANNELS,
formatDate,
type ClassIslandNotificationChannel,
} from '@classhelper/shared';
import { classIslandStatusApi } from '../../api/index.js';
import { useAppStore } from '../../stores/app.js';
import { useAuthStore } from '../../stores/auth.js';
/**
* 提醒设置:这台教室机器把提醒弹在哪个端(客户端 / ClassIsland / 两端都弹)。
* 值同时落本地配置与班级记录(服务端据此决定是否推送 ClassIsland)。
*/
const appStore = useAppStore();
const auth = useAuthStore();
const channelSaving = ref(false);
/**
* 本班有没有接入 ClassIsland 设备。
*
* 只用来禁用「只在 ClassIsland 上弹」——没有设备时选它等于把提醒静默丢掉;
* 注意**不能**顺手把「两端都弹」也禁掉:那样教室一旦选过"只在客户端",没设备时就再也切不回来了。
*/
const classIslandConnected = ref(false);
/** 本班 ClassIsland 设备的展示信息(设备名 / 最后上报),来自 /classes/:id/classisland-status */
const classIslandStatus = ref<{
connected: boolean;
deviceName: string | null;
deviceCount: number;
lastSeenAt: string | null;
pluginVersion: string | null;
classIslandVersion: string | null;
} | null>(null);
const classIslandStatusText = computed(() => {
const status = classIslandStatus.value;
if (!status || !status.connected) return '未接入';
const seen = status.lastSeenAt ? `最后上报 ${formatDate(status.lastSeenAt, true)}` : '尚未上报过';
return `已接入 · ${status.deviceName ?? 'ClassIsland 设备'} · ${seen}`;
});
const channelOptions = computed(() =>
CLASSISLAND_NOTIFICATION_CHANNELS.map((value) => ({
value,
label: CLASSISLAND_NOTIFICATION_CHANNEL_LABELS[value],
disabled: value === 'classisland' && !classIslandConnected.value,
})),
);
async function applyChannel(value: ClassIslandNotificationChannel): Promise<void> {
channelSaving.value = true;
try {
const saved = await appStore.setNotificationChannel(auth.classId, value);
if (saved) ElMessage.success('提醒显示位置已更新');
else ElMessage.warning('已保存在本机,但同步到服务器失败(离线或权限不足),联网后请再点一次');
} finally {
channelSaving.value = false;
}
}
onMounted(async () => {
await appStore.loadNotificationChannel(auth.classId);
// 本班 ClassIsland 联动状态:没接设备就别让选「只在 ClassIsland 上弹」
if (auth.classId) {
const status = await classIslandStatusApi.get(auth.classId).catch(() => null);
classIslandStatus.value = status;
classIslandConnected.value = status?.connected === true;
}
});
</script>
<template>
<div class="page">
<div class="page-header">
<div>
<h2 class="page-title">提醒</h2>
<p class="page-subtitle">老师发通知 / 叫人时,提醒弹在哪个端</p>
</div>
</div>
<el-card shadow="never">
<template #header><span>ClassIsland 联动</span></template>
<el-descriptions :column="1" border size="small" class="mb-12">
<el-descriptions-item label="联动状态">{{ classIslandStatusText }}</el-descriptions-item>
<el-descriptions-item label="插件 / ClassIsland">
{{ classIslandStatus?.pluginVersion ?? '—' }} /
{{ classIslandStatus?.classIslandVersion ?? '—' }}
</el-descriptions-item>
</el-descriptions>
<p class="text-muted">
<strong>通知模式</strong>
:老师在班级小助手上发布通知 / 叫人时,提醒弹在灵动岛还是 ClassIsland,
由这台教室机器决定。选择会同步到班级,服务端据此决定是否推送到教室的 ClassIsland。
</p>
<el-radio-group
:model-value="appStore.notificationChannel"
:disabled="channelSaving"
class="channel-group"
@change="
(value: string | number | boolean | undefined) =>
applyChannel(value as ClassIslandNotificationChannel)
"
>
<el-radio v-for="item in channelOptions" :key="item.value" :value="item.value" :disabled="item.disabled">
{{ item.label }}
</el-radio>
</el-radio-group>
<p class="text-muted channel-hint">
{{ CLASSISLAND_NOTIFICATION_CHANNEL_HINTS[appStore.notificationChannel] }}
<template v-if="!classIslandConnected">
<br />
提示:本班还没有接入 ClassIsland 设备(在 Web 端「ClassIsland 联动」里接入后才能选"只在
ClassIsland 上弹")。
</template>
</p>
</el-card>
</div>
</template>
<style scoped>
.channel-group {
display: flex;
flex-direction: column;
align-items: flex-start;
gap: 6px;
margin-top: 10px;
}
.channel-hint {
margin-top: 10px;
}
.mb-12 {
margin-bottom: 12px;
}
</style>
+77 -1
View File
@@ -7,6 +7,7 @@ import type {
IslandAppearance, IslandAppearance,
IslandNotification, IslandNotification,
IslandState, IslandState,
UpdateInfo,
} from '@classhelper/shared'; } from '@classhelper/shared';
/** 作业页展示偏好(看板 / 列表,看板外观) */ /** 作业页展示偏好(看板 / 列表,看板外观) */
@@ -47,6 +48,24 @@ export interface DesktopStoredConfig {
* 与班级记录(服务端据此决定要不要推给 ClassIsland)。 * 与班级记录(服务端据此决定要不要推给 ClassIsland)。
*/ */
notificationChannel: ClassIslandNotificationChannel; notificationChannel: ClassIslandNotificationChannel;
/**
* 是否已看过「初次启动引导」。
*
* 首次启动自动弹出一次(完成或跳过即记为看过并写入配置,之后不再自动弹出);
* 登录页与设置页的「使用引导」入口可随时重看(重看不改变该值)。
*/
onboardingDone: boolean;
/** 界面主题:light=浅色(默认)/ dark=深色(黑夜模式) */
theme: 'light' | 'dark';
/** 主侧边栏是否折叠成图标栏(可由顶栏汉堡按钮切换) */
sidebarCollapsed: boolean;
/**
* 用户点过「忽略此版本」的版本号(空串 = 没忽略过)。
*
* 启动时的自动检查会跳过这个版本,避免每次开客户端都弹一次同样的提示;
* 在「关于」页手动检查时仍会正常显示结果。
*/
ignoredUpdateVersion: string;
} }
export interface DesktopAppInfo { export interface DesktopAppInfo {
@@ -56,6 +75,8 @@ export interface DesktopAppInfo {
node: string; node: string;
platform: string; platform: string;
userDataPath: string; userDataPath: string;
/** 主进程配置文件(config.json)的绝对路径(关于页「诊断信息」展示) */
configPath: string;
/** 是否处于冒烟验证模式(由 ELECTRON_SMOKE_TEST=1 触发) */ /** 是否处于冒烟验证模式(由 ELECTRON_SMOKE_TEST=1 触发) */
smokeTest: boolean; smokeTest: boolean;
} }
@@ -80,6 +101,20 @@ export interface IslandClassStatePayload {
export interface DesktopBridge { export interface DesktopBridge {
/** 是否处于冒烟验证模式(由 ELECTRON_SMOKE_TEST=1 触发),同步可读 */ /** 是否处于冒烟验证模式(由 ELECTRON_SMOKE_TEST=1 触发),同步可读 */
smokeTest: boolean; smokeTest: boolean;
/**
* 冒烟凭据(仅冒烟模式下发,否则 `undefined`)。
*
* 为什么要从环境变量绕一圈:这些凭据被渲染进程的冒烟钩子用来"造测试数据",
* 而渲染产物(`dist/renderer/assets/*.js`)会进 `app.asar` 发给每台学生机 —— asar 可直接解包,
* 把账号口令写在代码里等于随安装包一起发出去。凭据只由
* `scripts/smoke.mjs` / `scripts/verify-packaged.mjs` 通过环境变量提供(这两个脚本不进安装包)。
*/
smokeCredentials?: {
username: string;
password: string;
classCode: string;
classPassword: string;
};
getConfig(): Promise<DesktopStoredConfig>; getConfig(): Promise<DesktopStoredConfig>;
/** /**
* 局部更新配置。 * 局部更新配置。
@@ -94,6 +129,21 @@ export interface DesktopBridge {
getAppInfo(): Promise<DesktopAppInfo>; getAppInfo(): Promise<DesktopAppInfo>;
openExternal(url: string): Promise<boolean>; openExternal(url: string): Promise<boolean>;
/* 更新检查 */
/**
* 检查 GitHub 上有没有新版本(主进程直连,不经后端)。
*
* @param force true = 绕过主进程缓存(对应「关于」页里用户主动点的那次检查)
*
* 返回的 `ok:false` 是**正常结果**(教室机器没有外网 / GitHub 限流 / 超时),不是异常,
* 界面按"暂时查不到更新"呈现即可。
*/
checkForUpdates(force?: boolean): Promise<UpdateInfo>;
/** 忽略某个版本的更新提示(写入 config.json,启动自动检查不再提示它) */
ignoreUpdateVersion(version: string): Promise<void>;
/** 订阅"启动自动检查发现新版本"(仅新版本且未被忽略时触发一次) */
onUpdateAvailable(handler: (info: UpdateInfo) => void): void;
/* 灵动岛 */ /* 灵动岛 */
/** 把一条通知投递到灵动岛(payload 必须是纯数据,说明见 saveConfig) */ /** 把一条通知投递到灵动岛(payload 必须是纯数据,说明见 saveConfig) */
islandPush(payload: { notification: IslandNotification; context?: IslandPushContext }): void; islandPush(payload: { notification: IslandNotification; context?: IslandPushContext }): void;
@@ -113,6 +163,8 @@ export interface DesktopBridge {
islandGetAppearance(): Promise<IslandAppearance>; islandGetAppearance(): Promise<IslandAppearance>;
/** 订阅"灵动岛点了标为已读"事件,用于同步通知中心 */ /** 订阅"灵动岛点了标为已读"事件,用于同步通知中心 */
onIslandMarkRead(handler: (id: string) => void): void; onIslandMarkRead(handler: (id: string) => void): void;
/** 订阅"灵动岛点了标为已读(多条通知的整批)",一次把这一批都标记已读 */
onIslandMarkAllRead(handler: (ids: string[]) => void): void;
} }
/** 灵动岛窗口自身的桥接(只暴露订阅状态与发送操作) */ /** 灵动岛窗口自身的桥接(只暴露订阅状态与发送操作) */
@@ -121,7 +173,18 @@ export interface IslandRendererBridge {
/** 订阅外观设置(CSS 变量实时生效) */ /** 订阅外观设置(CSS 变量实时生效) */
onAppearance(handler: (appearance: IslandAppearance) => void): void; onAppearance(handler: (appearance: IslandAppearance) => void): void;
getAppearance(): Promise<IslandAppearance>; getAppearance(): Promise<IslandAppearance>;
sendAction(action: 'expand' | 'collapse' | 'dismiss' | 'mark-read' | 'open-app', id?: string): void; sendAction(
action:
| 'expand'
| 'expand-list'
| 'collapse'
| 'dismiss'
| 'dismiss-all'
| 'mark-read'
| 'mark-all-read'
| 'open-app',
id?: string,
): void;
getState(): Promise<IslandState>; getState(): Promise<IslandState>;
/** /**
* 命中提示:指针在岛体上时应让固定大窗口接收鼠标(比主进程 60ms 轮询更快)。 * 命中提示:指针在岛体上时应让固定大窗口接收鼠标(比主进程 60ms 轮询更快)。
@@ -131,6 +194,11 @@ export interface IslandRendererBridge {
setInteractive(interactive: boolean): void; setInteractive(interactive: boolean): void;
/** 上报岛体矩形(窗口内 CSS px):主进程据此按光标位置兜底校正命中 */ /** 上报岛体矩形(窗口内 CSS px):主进程据此按光标位置兜底校正命中 */
setHitRect(rect: { x: number; y: number; width: number; height: number } | null): void; setHitRect(rect: { x: number; y: number; width: number; height: number } | null): void;
/**
* 上报"本机是触摸屏"(`navigator.maxTouchPoints > 0`):主进程据此让窗口贴合岛体并始终接收
* 输入,否则触摸屏上手指永远点不到岛(触摸不产生 mousemove、也不移动系统光标)。
*/
setTouchMode(enabled: boolean): void;
/** 心跳:主进程据此发现"渲染进程卡死的幽灵窗口"(岛还在屏幕上但点不动)并重建窗口 */ /** 心跳:主进程据此发现"渲染进程卡死的幽灵窗口"(岛还在屏幕上但点不动)并重建窗口 */
alive(): void; alive(): void;
} }
@@ -175,6 +243,14 @@ declare global {
scheduleTimelineSelfTest(): Promise<{ ok: boolean; detail: string }>; scheduleTimelineSelfTest(): Promise<{ ok: boolean; detail: string }>;
/** 作业看板全屏自适应自检(切看板 → 打开全屏 → 量尺寸) */ /** 作业看板全屏自适应自检(切看板 → 打开全屏 → 量尺寸) */
homeworkBoardSelfTest(): Promise<{ ok: boolean; detail: string }>; homeworkBoardSelfTest(): Promise<{ ok: boolean; detail: string }>;
/** 本机录入的作业不上灵动岛自检(内容指纹 + id 双重判定) */
islandHomeworkSuppressionCheck(): Promise<{ ok: boolean; detail: string }>;
/** 初次启动引导自检(首启自动出现 → 真实点击走完 → 完成状态写入配置) */
onboardingSelfTest(): Promise<{ ok: boolean; detail: string }>;
/** 主界面外观件自检(真实点击:主题切换 html.dark + 落盘、侧边栏折叠 + 落盘) */
layoutChromeSelfTest(): Promise<{ ok: boolean; detail: string }>;
/** 关于页自检(/settings/about 渲染 + getAppInfo 含 configPath) */
aboutPageSelfTest(): Promise<{ ok: boolean; detail: string }>;
sessionCleanup(): Promise<{ ok: boolean; detail: string }>; sessionCleanup(): Promise<{ ok: boolean; detail: string }>;
}; };
} }
+4 -3
View File
@@ -29,9 +29,10 @@ CORS_ORIGIN=*
# bcrypt 加密强度 # bcrypt 加密强度
BCRYPT_ROUNDS=10 BCRYPT_ROUNDS=10
# 教师新增学生账号时未指定密码所使用的初始密码 # 新建班级 / 新增教师未指定密码时使用的初始密码
DEFAULT_STUDENT_PASSWORD=123456 # (学生没有个人账号,因此没有 DEFAULT_STUDENT_PASSWORD —— 见 AGENTS.md §5 第 31 条)
DEFAULT_CLASS_PASSWORD=123456
DEFAULT_TEACHER_PASSWORD=123456
# 学期配置:第 1 教学周的周一日期(YYYY-MM-DD),用于“当前周次”换算 # 学期配置:第 1 教学周的周一日期(YYYY-MM-DD),用于“当前周次”换算
TERM_START_DATE=2026-02-23 TERM_START_DATE=2026-02-23
+4 -1
View File
@@ -1,6 +1,6 @@
{ {
"name": "@classhelper/server", "name": "@classhelper/server",
"version": "0.1.0", "version": "1.1.0",
"private": true, "private": true,
"description": "班级小助手后端服务:REST API + Socket.IO 实时推送 + Prisma 数据访问", "description": "班级小助手后端服务:REST API + Socket.IO 实时推送 + Prisma 数据访问",
"type": "module", "type": "module",
@@ -25,6 +25,7 @@
"@classhelper/shared": "workspace:*", "@classhelper/shared": "workspace:*",
"@libsql/client": "^0.17.0", "@libsql/client": "^0.17.0",
"@prisma/adapter-libsql": "7.10.0", "@prisma/adapter-libsql": "7.10.0",
"@prisma/adapter-mariadb": "7.10.0",
"@prisma/client": "7.10.0", "@prisma/client": "7.10.0",
"bcryptjs": "^3.0.3", "bcryptjs": "^3.0.3",
"compression": "^1.8.2", "compression": "^1.8.2",
@@ -34,7 +35,9 @@
"express-rate-limit": "^8.7.0", "express-rate-limit": "^8.7.0",
"helmet": "^8.3.0", "helmet": "^8.3.0",
"jsonwebtoken": "^9.0.3", "jsonwebtoken": "^9.0.3",
"prisma": "7.10.0",
"socket.io": "^4.8.3", "socket.io": "^4.8.3",
"typescript": "~5.9.3",
"xlsx": "0.18.5", "xlsx": "0.18.5",
"zod": "^4.6.2" "zod": "^4.6.2"
}, },
@@ -0,0 +1,7 @@
-- 课表行来源:manual=手工建立(Web 端录入 / JSON 导入)/ classisland=ClassIsland 插件上报同步。
--
-- 用途:插件每次全量上报课表时,只清理「source=classisland 且本次未再上报」的行。
-- 这样"老师在 ClassIsland 里删掉一节"能被真正同步下来(原先 merge 只 upsert,
-- 服务端会永远留着那行幽灵课),同时老师在小助手这边手排的课不受影响。
-- 存量数据默认按 manual 处理(保守:宁可留下也不误删)。
ALTER TABLE "Schedule" ADD COLUMN "source" TEXT NOT NULL DEFAULT 'manual';
+9 -3
View File
@@ -4,7 +4,8 @@
// 1) 本 schema 使用 sqlite provider(本地 MVP / 离线开发)。 // 1) 本 schema 使用 sqlite provider(本地 MVP / 离线开发)。
// 字段全部使用 String / Int / Float / Boolean / DateTime 等跨库通用类型, // 字段全部使用 String / Int / Float / Boolean / DateTime 等跨库通用类型,
// 不使用 Prisma enum 与 @db.* 原生类型,因此可平移到 MySQL。 // 不使用 Prisma enum 与 @db.* 原生类型,因此可平移到 MySQL。
// MySQL 版本见同目录 schema.mysql.prisma,切换步骤见 docs/mysql.md。 // MySQL 复用这一份 schema(就地改写下面的 provider,见 `pnpm db:switch:mysql`),
// 没有第二份 schema.mysql.prisma;切换步骤见 docs/mysql.md。
// 2) 角色与优先级用 String 存储('ADMIN' | 'TEACHER' | 'STUDENT'、 // 2) 角色与优先级用 String 存储('ADMIN' | 'TEACHER' | 'STUDENT'、
// 'LOW' | 'NORMAL' | 'HIGH' | 'URGENT'),在 API 层用 zod 校验, // 'LOW' | 'NORMAL' | 'HIGH' | 'URGENT'),在 API 层用 zod 校验,
// 这样 SQLite / MySQL 行为完全一致。 // 这样 SQLite / MySQL 行为完全一致。
@@ -146,8 +147,13 @@ model Schedule {
weekEnd Int @default(20) weekEnd Int @default(20)
/// 单双周:ALL=每周(默认)/ ODD=单周 / EVEN=双周(ClassIsland WeekCountDiv + WeekCountDivTotal 的映射) /// 单双周:ALL=每周(默认)/ ODD=单周 / EVEN=双周(ClassIsland WeekCountDiv + WeekCountDivTotal 的映射)
weekParity String @default("ALL") weekParity String @default("ALL")
createdAt DateTime @default(now()) /// 该行的来源:manual=手工建立(Web 端录入 / ClassIsland JSON 导入)
updatedAt DateTime @updatedAt /// / classisland=插件上报同步得到。
/// 插件每次全量上报时只清理「classisland 来源且本次未再上报」的行(解决"老师在 ClassIsland
/// 里删掉一节、服务端却永远留着"的幽灵课),老师手排的课一律不删。
source String @default("manual")
createdAt DateTime @default(now())
updatedAt DateTime @updatedAt
class Class @relation(fields: [classId], references: [id], onDelete: Cascade) class Class @relation(fields: [classId], references: [id], onDelete: Cascade)
course Course @relation(fields: [courseId], references: [id], onDelete: Cascade) course Course @relation(fields: [courseId], references: [id], onDelete: Cascade)
+6 -7
View File
@@ -86,10 +86,10 @@ async function main(): Promise<void> {
const random = createRandom(20260901); const random = createRandom(20260901);
// 同一角色共用密码,只需各哈希一次 // 同一角色共用密码,只需各哈希一次
const [adminHash, teacherHash, studentHash, classPasswordHash] = await Promise.all([ // 学生没有密码:个人学生账号已清理(2026-10-01),学生端统一用班级码 + 班级密码登录
const [adminHash, teacherHash, classPasswordHash] = await Promise.all([
hashPassword('admin123'), hashPassword('admin123'),
hashPassword('teacher123'), hashPassword('teacher123'),
hashPassword('student123'),
// 班级账号默认密码(学生端「班级登录」) // 班级账号默认密码(学生端「班级登录」)
hashPassword('123456'), hashPassword('123456'),
]); ]);
@@ -142,7 +142,8 @@ async function main(): Promise<void> {
name: STUDENT_NAMES[index] ?? `学生${index + 1}`, name: STUDENT_NAMES[index] ?? `学生${index + 1}`,
role: 'STUDENT', role: 'STUDENT',
classId: targetClass.id, classId: targetClass.id,
passwordHash: studentHash, // 空串占位:User.passwordHash 必填,但学生登录的 403 判定在密码校验之前,永远用不到
passwordHash: '',
}, },
}); });
students.push(student); students.push(student);
@@ -376,10 +377,8 @@ async function main(): Promise<void> {
console.log(`管理员 admin / admin123 (${admin.name})`); console.log(`管理员 admin / admin123 (${admin.name})`);
console.log(`教师 teacher1 / teacher123 (${teacher1.name} · 高一(1)班、高二(3)班)`); console.log(`教师 teacher1 / teacher123 (${teacher1.name} · 高一(1)班、高二(3)班)`);
console.log(`教师 teacher2 / teacher123 (${teacher2.name} · 高一(2)班、高二(3)班协作)`); console.log(`教师 teacher2 / teacher123 (${teacher2.name} · 高一(2)班、高二(3)班协作)`);
console.log('学生 student01 / student123 (高一(1)班)'); console.log('学生端(班级账号):G101 / G102 / G203,密码 123456');
console.log('学生 student06 / student123 (高一(2)班)'); console.log('(学生只有名单、没有个人账号,成绩/未交/叫人按名单记录)');
console.log('学生 student11 / student123 (高二(3)班)');
console.log('学生 student15 / student123 (高二(3)班)');
console.log('==========================================\n'); console.log('==========================================\n');
} }
+139 -1
View File
@@ -105,6 +105,34 @@ async function loginWithCandidates(username, passwords) {
return null; return null;
} }
/**
* 反复「拉取待提醒 → 逐条确认」,直到该设备视角下没有积压。
*
* 为什么验证脚本要做这件事:`GET /integrations/classisland/pending` 是
* 「本班全部未确认且未过期的提醒,按时间升序取前 20 条」。而 `verify:desktop` /
* `verify:web` 等冒烟会**真的往演示班发通知**(AGENTS.md §5 第 38 条),
* 那些条如果没被确认就会一直堆着 —— 攒够 20 条之后,本脚本刚发的提醒会被挤到窗口之外,
* 表现为「待提醒里找不到刚发的那条」,与代码对不对完全无关(2026-10-05 实测踩过:
* 库里积了 45 条历次冒烟残条,本脚本从 42/42 掉到 35/40)。
*
* 这里做的事情与真实插件重连后的行为完全一致(补弹积压并逐条确认),
* 因此不会掩盖任何产品侧问题。可见范围也一致:只处理 `deviceId` 为空的班级广播
* 与本设备自己的推送,别的设备的目标推送取不到、也确认不了。
*/
async function drainPending(deviceToken) {
let total = 0;
for (let round = 0; round < 20; round += 1) {
const pending = await api('/integrations/classisland/pending', { deviceToken });
const items = pending.payload?.data?.notifications ?? [];
if (items.length === 0) break;
for (const item of items) {
await api('/integrations/classisland/ack', { method: 'POST', deviceToken, body: { id: item.id } });
total += 1;
}
}
return total;
}
async function main() { async function main() {
console.log(`\n=== ClassIsland 联动验证(${BASE_URL})===\n`); console.log(`\n=== ClassIsland 联动验证(${BASE_URL})===\n`);
@@ -182,7 +210,7 @@ async function main() {
// ---------------------------------------------------------------- 3. 上报(状态 + 课表 + 节次) // ---------------------------------------------------------------- 3. 上报(状态 + 课表 + 节次)
const reportBody = { const reportBody = {
pluginVersion: '0.1.0.0', pluginVersion: '1.1.0.0',
classIslandVersion: '2.1.0.0', classIslandVersion: '2.1.0.0',
state: { state: {
inClass: true, inClass: true,
@@ -237,6 +265,13 @@ async function main() {
); );
// ---------------------------------------------------------------- 4. 下发提醒 // ---------------------------------------------------------------- 4. 下发提醒
// 先确认掉本班的历史积压(历次冒烟留下的未确认提醒),否则 /pending 的前 20 条窗口
// 会被它们占满,下面「插件拉取到待提醒」等用例会拿不到刚发的这条(理由见 drainPending)
const drained = await drainPending(deviceToken);
if (drained > 0) {
console.log(`(已确认本班 ${drained} 条历史积压提醒,避免挤占待提醒窗口)\n`);
}
const notify = await api('/integrations/classisland/notify', { const notify = await api('/integrations/classisland/notify', {
method: 'POST', method: 'POST',
token: teacherToken, token: teacherToken,
@@ -466,6 +501,109 @@ async function main() {
`上课点=${classPoints.length} 条目=${(plan?.entries ?? []).length}`, `上课点=${classPoints.length} 条目=${(plan?.entries ?? []).length}`,
); );
/* ---------------------------------------------------------------- 5.1 课表同步:幽灵行清理 + 机器码回填 */
// 老师在 Web 端手排的一节课(source=manual):插件同步时**绝不能**删它
const courseList = await api(`/courses?classId=${target.id}`, { token: teacherToken });
const courseId = (courseList.payload?.data ?? [])[0]?.id;
const manualCreated = await api('/schedules', {
method: 'POST',
token: teacherToken,
body: {
classId: target.id,
courseId,
dayOfWeek: 7,
startTime: '21:00',
endTime: '21:45',
weekStart: 1,
weekEnd: 20,
weekParity: 'ALL',
},
});
const manualScheduleId = manualCreated.payload?.data?.id;
record(
'(准备)Web 端手排一节课(source=manual)',
manualCreated.status === 201 && Boolean(manualScheduleId),
`status=${manualCreated.status}`,
);
const entry = (startTime, endTime) => ({
dayOfWeek: 6,
startTime,
endTime,
subject: '语文',
weekParity: 'ALL',
});
/** 该班课表里"周六 19:xx"的行(插件上报写入的那些) */
const listSaturday = async () => {
const list = await api(`/schedules?classId=${target.id}`, { token: teacherToken });
return (list.payload?.data ?? []).filter(
(item) => item.dayOfWeek === 6 && item.startTime.startsWith('19:'),
);
};
// 第一次上报:两节(第二节随后会被"老师在 ClassIsland 里删掉")
const ghostReport = await api('/integrations/classisland/report', {
method: 'POST',
deviceToken,
body: {
deviceKey: 'smoke-machine-01',
schedule: { mode: 'merge', entries: [entry('19:00', '19:45'), entry('19:50', '20:35')] },
},
});
record(
'插件上报两节课(其中一节随后会被删除)',
ghostReport.payload?.data?.scheduleApplied === true,
`status=${ghostReport.status}`,
);
const beforePrune = await listSaturday();
record('上报后两节都在库里', beforePrune.length === 2, `周六 19 点=${beforePrune.length} 节`);
// 第二次上报:只报第二节 → 第一节应当被清理。
// 原先 merge 只 upsert、从不删除,老师删掉的课会永远留在服务端(幽灵课),
// 学生端与 Web 端会一直显示一节实际上已经不上的课。
const pruneReport = await api('/integrations/classisland/report', {
method: 'POST',
deviceToken,
body: {
deviceKey: 'smoke-machine-01',
schedule: { mode: 'merge', entries: [entry('19:50', '20:35')] },
},
});
const afterPrune = await listSaturday();
record(
'插件侧删除的课被同步清理(不再留幽灵课)',
pruneReport.payload?.data?.scheduleApplied === true &&
afterPrune.length === 1 &&
afterPrune[0]?.startTime === '19:50',
`周六 19 点=${afterPrune.map((item) => item.startTime).join(',') || '空'}`,
);
// 只清理"插件同步出来的行":老师手排的课必须活着
const scheduleList = await api(`/schedules?classId=${target.id}`, { token: teacherToken });
const manualAlive = (scheduleList.payload?.data ?? []).some((item) => item.id === manualScheduleId);
record('Web 端手排的课不被插件同步删除', manualAlive, `手排行 id=${manualScheduleId ?? '-'}`);
// 机器码回填:设备列表里不再是 pending-…
const deviceList = await api(`/integrations/devices?classId=${target.id}`, { token: teacherToken });
const backfilledKey =
(deviceList.payload?.data ?? []).find((item) => item.id === deviceId)?.deviceKey ?? '';
record(
'插件上报的机器码已回填到设备记录',
backfilledKey === 'smoke-machine-01',
`deviceKey=${backfilledKey}`,
);
// 清理:把手排的课与本次上报写进去的课都删掉,避免污染演示数据
if (manualScheduleId) {
await api(`/schedules/${manualScheduleId}`, { method: 'DELETE', token: teacherToken });
}
for (const row of await listSaturday()) {
await api(`/schedules/${row.id}`, { method: 'DELETE', token: teacherToken });
}
record('清理:本次验证写入的课表与手排课已删除', (await listSaturday()).length === 0, '周六 19 点已清空');
// ---------------------------------------------------------------- 6. 停用设备 // ---------------------------------------------------------------- 6. 停用设备
await api(`/integrations/devices/${deviceId}`, { await api(`/integrations/devices/${deviceId}`, {
method: 'PATCH', method: 'PATCH',
+346 -9
View File
@@ -67,6 +67,17 @@ async function main() {
} }
console.log(` 已挂载模块:${(health.payload?.data?.modules ?? []).join(', ')}\n`); console.log(` 已挂载模块:${(health.payload?.data?.modules ?? []).join(', ')}\n`);
// 版本号不再硬编码(见 lib/version.ts):健康检查必须暴露一个像样的版本,
// 更新检查要靠它判断"本机是不是旧版";同时确认 update 模块已进注册表。
const healthData = health.payload?.data ?? {};
record(
'健康检查暴露版本号与模块清单(含 update 模块)',
typeof healthData.version === 'string' &&
/^\d+\.\d+\.\d+/.test(healthData.version) &&
(healthData.modules ?? []).includes('update'),
`版本=${healthData.version} 模块数=${(healthData.modules ?? []).length}`,
);
// ---------------------------------------------------------------- 1. 登录 // ---------------------------------------------------------------- 1. 登录
const teacherLogin = await api('/auth/login', { const teacherLogin = await api('/auth/login', {
method: 'POST', method: 'POST',
@@ -676,12 +687,13 @@ async function main() {
`共 ${studentListAfter.payload?.data?.length ?? 0} 人`, `共 ${studentListAfter.payload?.data?.length ?? 0} 人`,
); );
const resetResult = await api(`/students/${addedStudentId}/reset-password`, { // 学生没有密码相关接口(个人学生账号已清理,重置密码入口已下线):这里改为断言接口确实不存在
const resetGone = await api(`/students/${addedStudentId}/reset-password`, {
method: 'POST', method: 'POST',
token: adminToken, token: adminToken,
body: {}, body: {},
}); });
record('重置学生密码', resetResult.status === 200, `status=${resetResult.status}`); record('学生重置密码接口已下线(404)', resetGone.status === 404, `status=${resetGone.status}`);
const renamed = await api(`/students/${addedStudentId}`, { const renamed = await api(`/students/${addedStudentId}`, {
method: 'PATCH', method: 'PATCH',
@@ -1597,11 +1609,8 @@ async function main() {
// 8.4 学生名单导入(仅管理员)+ 数据清理 // 8.4 学生名单导入(仅管理员)+ 数据清理
const importedUsername = `imp${Date.now().toString(36).slice(-6)}`; const importedUsername = `imp${Date.now().toString(36).slice(-6)}`;
const studentsCsv = [ // 学生导入模板已无"初始密码"列(学生没有账号属性)
'用户名,姓名,初始密码', const studentsCsv = ['用户名,姓名', `${importedUsername},导入测试生`, 'bad user,非法用户名'].join(NL);
`${importedUsername},导入测试生,imp123456`,
'bad user,非法用户名,imp123456',
].join(NL);
const studentsCommit = await api('/imports/table/commit', { const studentsCommit = await api('/imports/table/commit', {
method: 'POST', method: 'POST',
token: adminToken, token: adminToken,
@@ -1610,7 +1619,7 @@ async function main() {
classId, classId,
fileName: 'students.csv', fileName: 'students.csv',
contentBase64: Buffer.from(`\ufeff${studentsCsv}${NL}`, 'utf8').toString('base64'), contentBase64: Buffer.from(`\ufeff${studentsCsv}${NL}`, 'utf8').toString('base64'),
mapping: { username: '用户名', name: '姓名', password: '初始密码' }, mapping: { username: '用户名', name: '姓名' },
mode: 'append', mode: 'append',
}, },
}); });
@@ -1740,7 +1749,7 @@ async function main() {
classId, classId,
fileName: 'students.csv', fileName: 'students.csv',
contentBase64: Buffer.from(`\ufeff${studentsCsv}${NL}`, 'utf8').toString('base64'), contentBase64: Buffer.from(`\ufeff${studentsCsv}${NL}`, 'utf8').toString('base64'),
mapping: { username: '用户名', name: '姓名', password: '初始密码' }, mapping: { username: '用户名', name: '姓名' },
mode: 'append', mode: 'append',
}, },
}); });
@@ -2228,6 +2237,68 @@ async function main() {
`班主任账号=${deleteHeadTeacher.status}(${deleteHeadTeacher.payload?.message ?? ''}) 冒烟账号=${deleteSmokeTeacher.status}`, `班主任账号=${deleteHeadTeacher.status}(${deleteHeadTeacher.payload?.message ?? ''}) 冒烟账号=${deleteSmokeTeacher.status}`,
); );
// 级联删除护栏:`Homework.createdBy` / `Notification.createdBy` 都是 ON DELETE CASCADE,
// 因此"已不在任何班级、名下无课程,但发布过内容"的账号也必须被拒 ——
// 否则"班主任转给别人 → 解除协作 → 删除账号"会静默清掉他在各班发过的作业与通知。
const cascadeTeacherUsername = `smoke_cas_${Date.now().toString().slice(-8)}`;
const cascadeTeacher = await api('/teachers', {
method: 'POST',
token: adminToken,
body: { username: cascadeTeacherUsername, name: '冒烟级联教师', password: 'cascade123456' },
});
const cascadeTeacherId = cascadeTeacher.payload?.data?.id;
const cascadeTeacherLogin = await api('/auth/login', {
method: 'POST',
body: { username: cascadeTeacherUsername, password: 'cascade123456' },
});
const cascadeTeacherToken = cascadeTeacherLogin.payload?.data?.token;
// 1) 先让他成为该班科任(这样才有发布权限),发一条通知
await api(`/classes/${classId}/teachers`, {
method: 'POST',
token: adminToken,
body: { teacherId: cascadeTeacherId },
});
const cascadeNotification = await api('/notifications', {
method: 'POST',
token: cascadeTeacherToken,
body: { classId, title: '级联删除回归', content: '用于验证删除教师不会连带删除已发布内容' },
});
const cascadeNotificationId = cascadeNotification.payload?.data?.id;
// 2) 解除班级分配:此时他"不在任何班级、名下无课程",但发布过内容
await api(`/classes/${classId}/teachers/${cascadeTeacherId}`, {
method: 'DELETE',
token: adminToken,
});
// 3) 删除账号应当被拒(409),且那条通知必须还在
const cascadeDelete = await api(`/teachers/${cascadeTeacherId}`, {
method: 'DELETE',
token: adminToken,
});
const afterCascadeList = await api(`/notifications?classId=${classId}`, { token: adminToken });
const notificationAlive = (afterCascadeList.payload?.data ?? []).some(
(item) => item.id === cascadeNotificationId,
);
record(
'删除教师护栏覆盖"发布过作业/通知"的账号(不再级联删除内容)',
cascadeDelete.status === 409 && notificationAlive,
`删除=${cascadeDelete.status}(${cascadeDelete.payload?.message ?? ''}) 通知仍在=${notificationAlive}`,
);
// 清理:内容删掉后账号即可删除
if (cascadeNotificationId) {
await api(`/notifications/${cascadeNotificationId}`, { method: 'DELETE', token: adminToken });
}
const cascadeDeleteAfter = await api(`/teachers/${cascadeTeacherId}`, {
method: 'DELETE',
token: adminToken,
});
record(
'清理:内容删除后该教师账号可删除',
cascadeDeleteAfter.status === 200,
`status=${cascadeDeleteAfter.status}`,
);
// 创建班级仅管理员 + 设置/更改班主任 // 创建班级仅管理员 + 设置/更改班主任
const teacherCreateClass = await api('/classes', { const teacherCreateClass = await api('/classes', {
method: 'POST', method: 'POST',
@@ -2279,6 +2350,236 @@ async function main() {
`教师改=${teacherChangeHead.status} 管理员改=${changedHead.status} 详情班主任=${changedDetail.payload?.data?.teacher?.name ?? '-'}`, `教师改=${teacherChangeHead.status} 管理员改=${changedHead.status} 详情班主任=${changedDetail.payload?.data?.teacher?.name ?? '-'}`,
); );
// 清理:删除实时推送用例造的通知/作业、冒烟班级、临时权限校验班级与冒烟教师账号
// ---------------------------------------------------------------- 数据库管理(仅管理员)
// 覆盖:状态 / 越权 403 / 连接测试 / 备份→导入导出→恢复 roundtrip / 定时配置校验 / 切换校验分支。
// 注意:**不真跑切换**(会改写 .env 与 schema.prisma),只验证拒绝分支;真实切换需人工复验。
const dbStatus = await api('/database/status', { token: adminToken });
const dbStatusData = dbStatus.payload?.data ?? {};
record(
'数据库状态(管理员):已连接且返回 14 张表行数',
dbStatus.status === 200 &&
dbStatusData.connected === true &&
Array.isArray(dbStatusData.tables) &&
dbStatusData.tables.length === 14 &&
dbStatusData.tables.every((item) => item.count >= 0),
`provider=${dbStatusData.provider} 延迟=${dbStatusData.latencyMs}ms 版本=${dbStatusData.version} 表=${
(dbStatusData.tables ?? []).length
}`,
);
const dbStatusTeacher = await api('/database/status', { token: teacherToken });
const dbBackupTeacher = await api('/database/backups', { method: 'POST', token: teacherToken });
const dbScheduleTeacher = await api('/database/backup-schedule', {
method: 'PUT',
token: teacherToken,
body: { enabled: true, intervalHours: 24, keepCount: 7 },
});
const dbSwitchTeacher = await api('/database/switch', {
method: 'POST',
token: teacherToken,
body: { provider: 'sqlite', url: 'file:./data/teacher-forbidden.db' },
});
record(
'数据库管理越权(教师全部 403)',
dbStatusTeacher.status === 403 &&
dbBackupTeacher.status === 403 &&
dbScheduleTeacher.status === 403 &&
dbSwitchTeacher.status === 403,
`status=${dbStatusTeacher.status} 备份=${dbBackupTeacher.status} 定时=${dbScheduleTeacher.status} 切换=${dbSwitchTeacher.status}`,
);
// 连接测试:当前库必须可达(SQLite 用相对路径,MySQL 用一个不可达地址测失败分支)
let testOkResult;
let testOkName;
if (dbStatusData.provider === 'sqlite') {
testOkResult = await api('/database/test-connection', {
method: 'POST',
token: adminToken,
body: { provider: 'sqlite', url: 'file:./prisma/dev.db' },
});
testOkName = '连接测试(当前 SQLite 库可达)';
} else {
testOkResult = await api('/database/test-connection', {
method: 'POST',
token: adminToken,
body: { provider: 'mysql', url: 'mysql://root:wrong-password@127.0.0.1:1/none' },
});
testOkName = '连接测试(不可达 MySQL 返回 ok=false)';
}
record(
testOkName,
testOkResult.status === 200 &&
(dbStatusData.provider === 'sqlite'
? testOkResult.payload?.data?.ok === true
: testOkResult.payload?.data?.ok === false),
`ok=${testOkResult.payload?.data?.ok} 版本=${testOkResult.payload?.data?.version} 详情=${testOkResult.payload?.data?.error ?? testOkResult.payload?.data?.note ?? '-'}`,
);
const dbTestRedis = await api('/database/test-connection', {
method: 'POST',
token: adminToken,
body: { provider: 'redis', url: 'redis://127.0.0.1:6379' },
});
record(
'Redis 作为主库被拒绝(schema 层面 422,产品口径:主库仅 SQLite/MySQL)',
dbTestRedis.status === 422,
`status=${dbTestRedis.status}`,
);
const badConnection = await api('/database/test-connection', {
method: 'POST',
token: adminToken,
body: { provider: 'mysql', url: 'mysql://root:wrong@127.0.0.1:1/none' },
});
record(
'连接测试(不可达 MySQL → ok=false 且不抛 500)',
badConnection.status === 200 && badConnection.payload?.data?.ok === false,
`ok=${badConnection.payload?.data?.ok} error=${(badConnection.payload?.data?.error ?? '').slice(0, 60)}`,
);
// 切换校验分支:同库拒绝(真实切换不在此跑,避免改写 .env)
const switchSame =
dbStatusData.provider === 'sqlite'
? await api('/database/switch', {
method: 'POST',
token: adminToken,
body: { provider: 'sqlite', url: dbStatusData.databaseUrlMasked },
})
: { status: 0, payload: null };
const switchInvalid = await api('/database/switch', {
method: 'POST',
token: adminToken,
body: { provider: 'redis', url: 'redis://127.0.0.1:6379' },
});
record(
'一键切换校验分支(同库 400 / 非法 provider 422,不真跑切换)',
(dbStatusData.provider === 'sqlite' ? switchSame.status === 400 : true) && switchInvalid.status === 422,
`同库=${switchSame.status}(${dbStatusData.provider === 'sqlite' ? 'sqlite 当前库' : 'mysql 跳过'}) redis=${switchInvalid.status}`,
);
// 备份 → 导出快照 → 造数据 → 快照导入 → 造数据 → 从备份恢复(三个恢复路径全验)
const dbBackup = await api('/database/backups', { method: 'POST', token: adminToken });
const backupName = dbBackup.payload?.data?.name ?? '';
record(
'手动备份(201,文件名符合约定格式)',
dbBackup.status === 201 && /^backup-manual-\d{8}-\d{6}\.json\.gz$/.test(backupName),
`name=${backupName} size=${dbBackup.payload?.data?.sizeBytes ?? '-'}`,
);
const dbExport = await fetch(`${BASE_URL}/api/database/export`, {
headers: { Authorization: `Bearer ${adminToken}` },
});
const snapshotJson = dbExport.status === 200 ? await dbExport.text() : '';
let snapshotParsed = null;
try {
snapshotParsed = JSON.parse(snapshotJson);
} catch {
snapshotParsed = null;
}
record(
'导出快照(JSON 格式正确、14 张表、用户数 > 0)',
dbExport.status === 200 &&
snapshotParsed?.format === 'classhelper-snapshot' &&
Object.keys(snapshotParsed?.data ?? {}).length === 14 &&
(snapshotParsed?.counts?.User ?? 0) > 0,
`status=${dbExport.status} 格式=${snapshotParsed?.format ?? '-'} 用户=${snapshotParsed?.counts?.User ?? '-'}`,
);
// 造一条临时通知 → 快照导入(应被清掉)→ 再造一条 → 从备份恢复(也应被清掉)
const dbRoundtripNotice = await api('/notifications', {
method: 'POST',
token: adminToken,
body: { classId, title: '数据库roundtrip自检', content: '导入/恢复后应消失' },
});
const dbRoundtripNoticeId = dbRoundtripNotice.payload?.data?.id;
const dbImport = await api('/database/import', {
method: 'POST',
token: adminToken,
body: { data: Buffer.from(snapshotJson, 'utf8').toString('base64') },
});
const afterImport = await api(`/notifications?classId=${classId}`, { token: adminToken });
const roundtripNoticeGone = !(afterImport.payload?.data ?? []).some(
(item) => item.id === dbRoundtripNoticeId,
);
record(
'快照导入(整库覆盖:导入后临时通知消失)',
dbImport.status === 200 && roundtripNoticeGone,
`导入=${dbImport.status} 通知已清除=${roundtripNoticeGone} 行数=${JSON.stringify(dbImport.payload?.data?.counts ?? {}).slice(0, 80)}`,
);
const dbRoundtripNotice2 = await api('/notifications', {
method: 'POST',
token: adminToken,
body: { classId, title: '数据库roundtrip自检2', content: '备份恢复后应消失' },
});
const dbRoundtripNotice2Id = dbRoundtripNotice2.payload?.data?.id;
const dbRestore = await api(`/database/backups/${backupName}/restore`, {
method: 'POST',
token: adminToken,
});
const afterRestore = await api(`/notifications?classId=${classId}`, { token: adminToken });
const restoreNoticeGone = !(afterRestore.payload?.data ?? []).some(
(item) => item.id === dbRoundtripNotice2Id,
);
record(
'从备份恢复(整库覆盖:恢复后临时通知消失)',
dbRestore.status === 200 && restoreNoticeGone,
`恢复=${dbRestore.status} 通知已清除=${restoreNoticeGone}`,
);
if (dbRoundtripNoticeId) {
await api(`/notifications/${dbRoundtripNoticeId}`, { method: 'DELETE', token: adminToken });
}
if (dbRoundtripNotice2Id) {
await api(`/notifications/${dbRoundtripNotice2Id}`, { method: 'DELETE', token: adminToken });
}
const dbBackupList = await api('/database/backups', { token: adminToken });
const dbBackupDelete = await api(`/database/backups/${backupName}`, {
method: 'DELETE',
token: adminToken,
});
const dbBackupListAfter = await api('/database/backups', { token: adminToken });
record(
'备份列表与删除(创建后可见,删除后消失)',
dbBackupList.status === 200 &&
(dbBackupList.payload?.data ?? []).some((item) => item.name === backupName) &&
dbBackupDelete.status === 200 &&
!(dbBackupListAfter.payload?.data ?? []).some((item) => item.name === backupName),
`删除前=${(dbBackupList.payload?.data ?? []).length} 删除后=${(dbBackupListAfter.payload?.data ?? []).length}`,
);
const dbScheduleInvalid = await api('/database/backup-schedule', {
method: 'PUT',
token: adminToken,
body: { enabled: true, intervalHours: 0, keepCount: 7 },
});
const dbScheduleSave = await api('/database/backup-schedule', {
method: 'PUT',
token: adminToken,
body: { enabled: false, intervalHours: 24, keepCount: 7 },
});
record(
'定时备份配置(非法间隔 422 / 合法保存并回读)',
dbScheduleInvalid.status === 422 &&
dbScheduleSave.status === 200 &&
dbScheduleSave.payload?.data?.enabled === false &&
dbScheduleSave.payload?.data?.intervalHours === 24,
`非法=${dbScheduleInvalid.status} 保存=${dbScheduleSave.status} enabled=${dbScheduleSave.payload?.data?.enabled}`,
);
if (dbStatusData.provider === 'sqlite') {
const sqliteFile = await fetch(`${BASE_URL}/api/database/sqlite-file`, {
headers: { Authorization: `Bearer ${adminToken}` },
});
const sqliteBytes = sqliteFile.status === 200 ? (await sqliteFile.arrayBuffer()).byteLength : 0;
record(
'SQLite 数据文件下载(快捷导出 .db 文件)',
sqliteFile.status === 200 && sqliteBytes > 0,
`status=${sqliteFile.status} bytes=${sqliteBytes}`,
);
}
// 清理:删除实时推送用例造的通知/作业、冒烟班级、临时权限校验班级与冒烟教师账号 // 清理:删除实时推送用例造的通知/作业、冒烟班级、临时权限校验班级与冒烟教师账号
const realtimeNoticeId = createdNotification.payload?.data?.id; const realtimeNoticeId = createdNotification.payload?.data?.id;
if (realtimeNoticeId) { if (realtimeNoticeId) {
@@ -2328,6 +2629,42 @@ async function main() {
} 残留班级=${leftoverClasses.map((item) => item.name).join(',') || '无'}`, } 残留班级=${leftoverClasses.map((item) => item.name).join(',') || '无'}`,
); );
// ---------------------------------------------------------------- 更新检查
// 验的是"结构完整 + 权限 + 可降级",**刻意不断言"一定有新版本"** ——
// 那会把用例绑死在外网可达上,而学校机房/内网服务器查不到 GitHub 是常态
// (`ok:false` 是设计内的结果,不是失败)。真实联网取值在交付前人工验一次。
const updateAnon = await api('/update/check');
record('更新检查未登录 401', updateAnon.status === 401, `status=${updateAnon.status}`);
const updateRes = await api('/update/check', { token: adminToken });
const updateData = updateRes.payload?.data ?? {};
const isVersionLike = (value) => typeof value === 'string' && /^\d/.test(value);
record(
'更新检查(管理员):结构完整,本机版本取自 package.json',
updateRes.status === 200 &&
isVersionLike(updateData.currentVersion) &&
typeof updateData.ok === 'boolean' &&
typeof updateData.hasUpdate === 'boolean' &&
(updateData.ok
? isVersionLike(updateData.latestVersion) &&
Array.isArray(updateData.assets) &&
/^https:\/\//.test(updateData.releaseUrl ?? '') &&
updateData.error === null
: typeof updateData.error === 'string' && updateData.error.length > 0),
`ok=${updateData.ok} 本机=${updateData.currentVersion} 最新=${updateData.latestVersion ?? '-'} ` +
`有新版本=${updateData.hasUpdate} 附件=${(updateData.assets ?? []).length}` +
`${updateData.error ? ` 原因=${updateData.error}` : ''}`,
);
// force 只对管理员生效:教师带 force=1 也必须命中缓存(否则任意登录用户都能刷爆匿名限流)
const updateTeacherForced = await api('/update/check?force=1', { token: teacherToken });
record(
'更新检查:教师可查(公开信息),但 force 仅管理员生效',
updateTeacherForced.status === 200 &&
updateTeacherForced.payload?.data?.checkedAt === updateData.checkedAt,
`status=${updateTeacherForced.status} 命中缓存=${updateTeacherForced.payload?.data?.checkedAt === updateData.checkedAt}`,
);
socket.close(); socket.close();
// ---------------------------------------------------------------- 汇总 // ---------------------------------------------------------------- 汇总
+18 -6
View File
@@ -6,6 +6,7 @@ import { env } from './config/env.js';
import { pingDatabase } from './lib/db.js'; import { pingDatabase } from './lib/db.js';
import { sendOk } from './lib/http.js'; import { sendOk } from './lib/http.js';
import { logger } from './lib/logger.js'; import { logger } from './lib/logger.js';
import { APP_VERSION } from './lib/version.js';
import { mountWebAdmin, resolveWebDistDir } from './lib/web-static.js'; import { mountWebAdmin, resolveWebDistDir } from './lib/web-static.js';
import { errorHandler, notFoundHandler } from './middleware/error.js'; import { errorHandler, notFoundHandler } from './middleware/error.js';
import { apiRateLimiter, loginRateLimiter, requestLogger, securityHeaders } from './middleware/security.js'; import { apiRateLimiter, loginRateLimiter, requestLogger, securityHeaders } from './middleware/security.js';
@@ -37,7 +38,8 @@ async function healthHandler(_req: Request, res: Response): Promise<void> {
res, res,
{ {
status: 'ok', status: 'ok',
version: '0.1.0', // 版本号取自 package.json(见 lib/version.ts):更新检查要拿它跟 GitHub 上的 Release 比
version: APP_VERSION,
env: env.nodeEnv, env: env.nodeEnv,
uptimeSeconds: Math.round(process.uptime()), uptimeSeconds: Math.round(process.uptime()),
database: { database: {
@@ -68,7 +70,7 @@ function createRootHandler(webDistDir: string | null) {
res, res,
{ {
service: 'class-helper-server', service: 'class-helper-server',
version: '0.1.0', version: APP_VERSION,
environment: env.nodeEnv, environment: env.nodeEnv,
apiPrefix: API_PREFIX, apiPrefix: API_PREFIX,
socket: '/socket.io', socket: '/socket.io',
@@ -115,7 +117,7 @@ function renderLandingPage(webAdminServed: boolean): string {
<body> <body>
<div class="card"> <div class="card">
<h1>班级小助手 · 后端服务 <span class="ok">running</span></h1> <h1>班级小助手 · 后端服务 <span class="ok">running</span></h1>
<p class="sub">版本 0.1.0 · 运行环境 ${env.nodeEnv} · 数据库 ${env.databaseProvider}</p> <p class="sub">版本 ${APP_VERSION} · 运行环境 ${env.nodeEnv} · 数据库 ${env.databaseProvider}</p>
<p class="sub"> <p class="sub">
健康检查 <a href="${API_PREFIX}/health">${API_PREFIX}/health</a> · 健康检查 <a href="${API_PREFIX}/health">${API_PREFIX}/health</a> ·
存活 /healthz · 就绪 /readyz 存活 /healthz · 就绪 /readyz
@@ -145,8 +147,15 @@ export function createApp(): Express {
app.use(securityHeaders()); app.use(securityHeaders());
app.use(compression()); app.use(compression());
app.use(cors({ origin: env.corsOrigins, credentials: true })); app.use(cors({ origin: env.corsOrigins, credentials: true }));
app.use(express.json({ limit: '2mb' })); /**
app.use(express.urlencoded({ extended: true })); * 请求体上限:表格导入是把文件以 **base64** 放进 JSON 的,base64 约为原文件的 4/3,
* 再算上 JSON 包装,8MB 的表格文件约需 11MB 请求体。
* 这里必须留够余量,否则「导入模板写的 8MB 上限」永远到不了(文件到 1.5MB 就被 body-parser 拦掉),
* 而且用户看到的是一句 500「服务器内部错误:request entity too large」——
* 与 `table-import.service.ts` 的 MAX_IMPORT_BYTES(8MB) 校验完全对不上。
*/
app.use(express.json({ limit: '12mb' }));
app.use(express.urlencoded({ extended: true, limit: '1mb' }));
app.use(requestLogger()); app.use(requestLogger());
// 探针(不参与限流) // 探针(不参与限流)
@@ -173,7 +182,10 @@ export function createApp(): Express {
// 限流:先挂通用限流,再挂更严格的登录限流(后挂者决定响应头里的策略,便于观察暴力破解防护) // 限流:先挂通用限流,再挂更严格的登录限流(后挂者决定响应头里的策略,便于观察暴力破解防护)
app.use(API_PREFIX, apiRateLimiter()); app.use(API_PREFIX, apiRateLimiter());
app.use(`${API_PREFIX}/auth/login`, loginRateLimiter()); // 登录限流必须覆盖**两个**登录入口:`/auth/login`(教师/管理员)与 `/auth/class-login`(学生端
// 班级账号)。后者的密码默认就是 123456,漏掉它等于形同虚设 —— 这里用数组形式挂载,
// 两个路径共享同一个计数器(同一 IP 对两种登录的失败次数合并计算)。
app.use([`${API_PREFIX}/auth/login`, `${API_PREFIX}/auth/class-login`], loginRateLimiter());
// 模块化装配:注册表里的每个模块挂载到 /api<basePath> // 模块化装配:注册表里的每个模块挂载到 /api<basePath>
for (const module of apiModules) { for (const module of apiModules) {
+16 -3
View File
@@ -27,7 +27,6 @@ const envSchema = z.object({
JWT_EXPIRES_IN: z.string().default('7d'), JWT_EXPIRES_IN: z.string().default('7d'),
CORS_ORIGIN: z.string().default('*'), CORS_ORIGIN: z.string().default('*'),
BCRYPT_ROUNDS: z.coerce.number().int().min(4).max(15).default(10), BCRYPT_ROUNDS: z.coerce.number().int().min(4).max(15).default(10),
DEFAULT_STUDENT_PASSWORD: z.string().min(6).default('123456'),
/** 新建班级时的默认班级密码(学生端班级账号登录用),管理员可随时重置 */ /** 新建班级时的默认班级密码(学生端班级账号登录用),管理员可随时重置 */
DEFAULT_CLASS_PASSWORD: z.string().min(6).default('123456'), DEFAULT_CLASS_PASSWORD: z.string().min(6).default('123456'),
/** 新建/重置教师账号时的默认密码(管理员录入教师用) */ /** 新建/重置教师账号时的默认密码(管理员录入教师用) */
@@ -109,6 +108,22 @@ if (isProduction) {
'请修改 packages/server/.env 后重试。', '请修改 packages/server/.env 后重试。',
); );
} }
/**
* CORS 默认值告警(**不拦截启动**)。
*
* `CORS_ORIGIN=*` 与 `credentials: true` 同时开启时,cors 中间件会反射请求方 Origin 并带上
* `Access-Control-Allow-Credentials: true`。本项目的鉴权走 `Authorization` 头(不是 cookie),
* 第三方页面拿不到用户的 token,因此实际风险有限;但"允许任意站点带凭据访问"是没有必要的暴露面,
* 生产部署应填成实际域名。这里只告警:真要卡死会挡住"教室机 file:// 页面直连后端"这类合法部署
* (那类请求的 Origin 是 `file://`,无法提前枚举),代价不值得。
*/
if (raw.CORS_ORIGIN.trim() === '*') {
console.warn(
'⚠ CORS_ORIGIN=* 且已开启 credentials:生产环境建议改成具体来源(逗号分隔),' +
'例如 CORS_ORIGIN=https://your-domain.example(教室机 file:// 客户端不受影响)。',
);
}
} }
/** trust proxy 支持 false / 数字跳数 / loopback 等字符串形式 */ /** trust proxy 支持 false / 数字跳数 / loopback 等字符串形式 */
@@ -141,8 +156,6 @@ export const env = {
.map((item) => item.trim()) .map((item) => item.trim())
.filter(Boolean), .filter(Boolean),
bcryptRounds: raw.BCRYPT_ROUNDS, bcryptRounds: raw.BCRYPT_ROUNDS,
/** 新增学生时未指定密码时的初始密码 */
defaultStudentPassword: raw.DEFAULT_STUDENT_PASSWORD,
/** 新建班级时的默认班级密码(班级账号登录) */ /** 新建班级时的默认班级密码(班级账号登录) */
defaultClassPassword: raw.DEFAULT_CLASS_PASSWORD, defaultClassPassword: raw.DEFAULT_CLASS_PASSWORD,
/** 新建/重置教师账号时的初始密码 */ /** 新建/重置教师账号时的初始密码 */
+3
View File
@@ -9,6 +9,7 @@ import { ensureInitialAdmin, ensureSchema } from './lib/db-bootstrap.js';
import { logger } from './lib/logger.js'; import { logger } from './lib/logger.js';
import { resolveWebDistDir } from './lib/web-static.js'; import { resolveWebDistDir } from './lib/web-static.js';
import { initRealtime } from './realtime/socket.js'; import { initRealtime } from './realtime/socket.js';
import { startBackupScheduler } from './modules/database/database.service.js';
/** 数据库自检与可选的首次初始化 */ /** 数据库自检与可选的首次初始化 */
async function prepareDatabase(): Promise<void> { async function prepareDatabase(): Promise<void> {
@@ -85,6 +86,8 @@ httpServer.listen(env.port, env.host, () => {
} }
logger.info(`探针:/healthz(存活) · /readyz(就绪) · ${API_PREFIX}/health(详情)`); logger.info(`探针:/healthz(存活) · /readyz(就绪) · ${API_PREFIX}/health(详情)`);
logger.info(`WebSocket:ws://${displayHost}:${env.port}/socket.io`); logger.info(`WebSocket:ws://${displayHost}:${env.port}/socket.io`);
// 数据库管理模块的定时备份调度(配置与"到点时间"持久化在 data/database-settings.json)
startBackupScheduler();
}); });
let shuttingDown = false; let shuttingDown = false;
+4 -1
View File
@@ -1,3 +1,4 @@
import { randomInt } from 'node:crypto';
import { prisma } from './db.js'; import { prisma } from './db.js';
import { ApiError } from './http.js'; import { ApiError } from './http.js';
import { hashPassword, verifyPassword } from './password.js'; import { hashPassword, verifyPassword } from './password.js';
@@ -30,7 +31,9 @@ export async function generateClassCode(prefix = ''): Promise<string> {
const length = Math.max(4, 6 - prefix.length); const length = Math.max(4, 6 - prefix.length);
let body = ''; let body = '';
for (let index = 0; index < length; index += 1) { for (let index = 0; index < length; index += 1) {
body += CODE_ALPHABET[Math.floor(Math.random() * CODE_ALPHABET.length)]; // 用 CSPRNG 而不是 Math.random():班级码会作为学生端登录的账号名打印/张贴,
// 用可预测的 PRNG 生成等于把"半个凭证"送给猜码的人(randomInt 无取模偏差)
body += CODE_ALPHABET[randomInt(0, CODE_ALPHABET.length)];
} }
const code = `${prefix}${body}`.toUpperCase(); const code = `${prefix}${body}`.toUpperCase();
const exists = await prisma.class.findUnique({ where: { code }, select: { id: true } }); const exists = await prisma.class.findUnique({ where: { code }, select: { id: true } });
+15 -9
View File
@@ -3,27 +3,33 @@ import { PrismaClient } from '../generated/prisma/client.js';
import { env } from '../config/env.js'; import { env } from '../config/env.js';
import { logger } from './logger.js'; import { logger } from './logger.js';
/** 本项目支持的主数据库类型(Redis 等键值库不是 Prisma 支持的主库,不在范围内) */
export type DatabaseProvider = 'sqlite' | 'mysql';
/** /**
* Prisma 7 要求所有数据库都通过 driver adapter 接入: * Prisma 7 要求所有数据库都通过 driver adapter 接入:
* - SQLite -> @prisma/adapter-libsql(libSQL 内嵌模式,npm 预编译二进制,无需本地编译) * - SQLite -> @prisma/adapter-libsql(libSQL 内嵌模式,npm 预编译二进制,无需本地编译)
* - MySQL -> @prisma/adapter-mariadb(切换数据库时安装,见 docs/mysql.md) * - MySQL -> @prisma/adapter-mariadb(依赖里常驻,切换数据库时直接可用)
* *
* MySQL 分支使用「非字面量模块名」动态导入,这样未安装 mariadb 适配器时 * MySQL 分支使用「非字面量模块名」动态导入,这样未安装 mariadb 适配器时
* 也不会影响类型检查与 SQLite 模式的运行。 * 也不会影响类型检查与 SQLite 模式的运行。
*
* 该工厂独立于进程级单例:数据库管理模块的「连接测试」与跨库迁移的工具进程
* 都需要按任意 provider/url 构建临时客户端,而不是读 env 单例。
*/ */
async function createAdapter(): Promise<unknown> { export async function createPrismaClient(
if (env.databaseProvider === 'mysql') { provider: DatabaseProvider,
url: string,
): Promise<PrismaClient> {
if (provider === 'mysql') {
const adapterModule = '@prisma/adapter-mariadb'; const adapterModule = '@prisma/adapter-mariadb';
const mod = (await import(adapterModule)) as { PrismaMariaDb: new (url: string) => unknown }; const mod = (await import(adapterModule)) as { PrismaMariaDb: new (url: string) => unknown };
logger.info('已加载 MySQL/MariaDB 驱动适配器'); return new PrismaClient({ adapter: new mod.PrismaMariaDb(url) as never });
return new mod.PrismaMariaDb(env.databaseUrl);
} }
return new PrismaLibSql({ url: env.databaseUrl }); return new PrismaClient({ adapter: new PrismaLibSql({ url }) as never });
} }
const adapter = await createAdapter(); export const prisma = await createPrismaClient(env.databaseProvider, env.databaseUrl);
export const prisma = new PrismaClient({ adapter: adapter as never });
logger.info(`Prisma 客户端已初始化(provider=${env.databaseProvider})`); logger.info(`Prisma 客户端已初始化(provider=${env.databaseProvider})`);
+19
View File
@@ -31,5 +31,24 @@ export const booleanFlagSchema = z
/** 关键字查询 */ /** 关键字查询 */
export const keywordSchema = z.string().trim().max(64).optional(); export const keywordSchema = z.string().trim().max(64).optional();
/**
* 附件链接。
*
* 只允许 http(s) 绝对地址或站内相对路径:这一层是为**渲染端**兜底 ——
* 该字段最终会绑到前端的 `<a href>` / `el-link :href` 上,
* 若放行 `javascript:` / `data:text/html` 就会变成一条存储型 XSS 的注入点。
* 空串与 null 都表示"没有附件"。
*/
export const attachmentUrlSchema = z
.string()
.trim()
.max(500)
.refine(
(value) =>
value === '' || value.startsWith('/') || /^https?:\/\//i.test(value),
{ message: '附件链接需为 http(s):// 地址或站内相对路径' },
)
.nullish();
/** 周次:1..30 */ /** 周次:1..30 */
export const weekNumberSchema = z.coerce.number().int().min(1).max(30); export const weekNumberSchema = z.coerce.number().int().min(1).max(30);
+159
View File
@@ -0,0 +1,159 @@
import type { PrismaClient } from '../generated/prisma/client.js';
import type { DatabaseProvider } from './db.js';
/**
* 全库 JSON 快照:备份 / 恢复 / 导入导出 / 跨库迁移共用这一种格式。
*
* 为什么不用「复制数据库文件」或 mysqldump:
* - 文件级备份只对 SQLite 有意义,跨库迁移根本用不上;
* - JSON 快照与 provider 无关,一份实现同时服务备份、导入导出和 SQLite⇄MySQL 迁移。
*
* 外键注意:schema 里 User.classId → Class 且 Class.teacherId → User(互相引用),
* 恢复时必须**临时关闭外键检查**再按序写入,否则任何排序都会被其中一侧卡死。
* - SQLite:PRAGMA foreign_keys=OFF(libsql 连接级,进程内安全)
* - MySQL:SET FOREIGN_KEY_CHECKS=0/1(会话级,连接池下同一客户端实例内生效)
*/
export const SNAPSHOT_FORMAT = 'classhelper-snapshot';
export const SNAPSHOT_VERSION = 1;
/** 导出与恢复顺序(外键关闭后顺序不再影响写入,但保持拓扑序便于人工阅读与排查) */
export const SNAPSHOT_TABLES = [
'User',
'Class',
'Course',
'ClassTeacher',
'Enrollment',
'Schedule',
'TimeLayout',
'Homework',
'HomeworkStatus',
'Notification',
'NotificationRead',
'Grade',
'IntegrationDevice',
'ClassIslandPush',
] as const;
export type SnapshotTable = (typeof SNAPSHOT_TABLES)[number];
export interface DatabaseSnapshot {
format: string;
version: number;
createdAt: string;
source: { provider: string };
/** 每张表的行数(导出时统计,恢复时校验总量用) */
counts: Record<string, number>;
/** 表名 → 行数组(DateTime 已是 ISO 字符串,Prisma 接受 ISO 字符串作为 DateTime 输入) */
data: Record<SnapshotTable, Record<string, unknown>[]>;
}
/** 模型代理的最小接口(避免 any:Prisma 各模型的 delegate 形状一致) */
interface ModelDelegate {
findMany(): Promise<Record<string, unknown>[]>;
count(): Promise<number>;
createMany(args: { data: Record<string, unknown>[] }): Promise<unknown>;
deleteMany(): Promise<unknown>;
}
function delegatesOf(prisma: PrismaClient): Record<SnapshotTable, ModelDelegate> {
return prisma as unknown as Record<SnapshotTable, ModelDelegate>;
}
/** 单次 createMany 的批量大小(班级规模数据量小,小批次足够且省内存) */
const CHUNK_SIZE = 200;
/** 导出全库快照(行内 DateTime 为 Date 对象,JSON.stringify 时自动转 ISO) */
export async function exportSnapshot(
prisma: PrismaClient,
provider: DatabaseProvider,
): Promise<DatabaseSnapshot> {
const delegates = delegatesOf(prisma);
const data = {} as Record<SnapshotTable, Record<string, unknown>[]>;
const counts: Record<string, number> = {};
for (const table of SNAPSHOT_TABLES) {
const rows = await delegates[table].findMany();
data[table] = rows;
counts[table] = rows.length;
}
return {
format: SNAPSHOT_FORMAT,
version: SNAPSHOT_VERSION,
createdAt: new Date().toISOString(),
source: { provider },
counts,
data,
};
}
/** 快照结构校验:给出可读的失败原因("为什么恢复失败"比失败本身重要) */
export function assertValidSnapshot(value: unknown): asserts value is DatabaseSnapshot {
if (typeof value !== 'object' || value === null) {
throw new Error('快照内容不是合法的 JSON 对象');
}
const snapshot = value as Partial<DatabaseSnapshot>;
if (snapshot.format !== SNAPSHOT_FORMAT) {
throw new Error(`快照格式不正确(期望 ${SNAPSHOT_FORMAT},收到 ${String(snapshot.format ?? '未知')})`);
}
if (snapshot.version !== SNAPSHOT_VERSION) {
throw new Error(`快照版本不兼容(期望 v${SNAPSHOT_VERSION},收到 v${String(snapshot.version)})`);
}
if (typeof snapshot.data !== 'object' || snapshot.data === null) {
throw new Error('快照缺少 data 字段');
}
for (const table of SNAPSHOT_TABLES) {
const rows = (snapshot.data as Record<string, unknown>)[table];
if (!Array.isArray(rows)) {
throw new Error(`快照缺少表 ${table} 的数据`);
}
}
}
async function setForeignKeys(prisma: PrismaClient, provider: DatabaseProvider, enabled: boolean): Promise<void> {
const sql =
provider === 'mysql'
? `SET FOREIGN_KEY_CHECKS=${enabled ? 1 : 0}`
: `PRAGMA foreign_keys=${enabled ? 'ON' : 'OFF'}`;
await prisma.$executeRawUnsafe(sql);
}
/**
* 把快照写入目标库(先清空再写入)。
* 用于:备份恢复、快照导入、跨库迁移的子进程。
*/
export async function restoreSnapshot(
prisma: PrismaClient,
provider: DatabaseProvider,
snapshot: DatabaseSnapshot,
options: { clean?: boolean } = {},
): Promise<{ counts: Record<string, number> }> {
assertValidSnapshot(snapshot);
const delegates = delegatesOf(prisma);
const clean = options.clean !== false;
const counts: Record<string, number> = {};
await setForeignKeys(prisma, provider, false);
try {
if (clean) {
// 反向清空,保证被引用的表最后清(外键关闭后只是防御性的,保持确定性)
for (const table of [...SNAPSHOT_TABLES].reverse()) {
await delegates[table].deleteMany();
}
}
for (const table of SNAPSHOT_TABLES) {
const rows = snapshot.data[table];
for (let index = 0; index < rows.length; index += CHUNK_SIZE) {
await delegates[table].createMany({ data: rows.slice(index, index + CHUNK_SIZE) });
}
counts[table] = rows.length;
}
} finally {
await setForeignKeys(prisma, provider, true).catch(() => undefined);
}
return { counts };
}
/** 汇总快照总行数(列表展示 / 切换任务结果用) */
export function snapshotTotalRows(snapshot: DatabaseSnapshot): number {
return Object.values(snapshot.counts).reduce((sum, count) => sum + count, 0);
}
+41
View File
@@ -0,0 +1,41 @@
import fs from 'node:fs';
import path from 'node:path';
import { env } from '../config/env.js';
import { logger } from './logger.js';
/**
* 服务端版本号。
*
* 为什么不再硬编码:`app.ts` 里原本写了两个字面量 `'1.0.0'`(健康检查 + 首页),
* 而版本号在仓库里已经有 5 份 package.json —— 更新检查要靠它判断"本机是不是旧版",
* 再留一份手写副本就一定会漂移。
*
* 取哪一份(按顺序):
* 1. `serverRoot/..` —— 打包形态下是运行时清单(`scripts/dist-server.mjs` 把**根**
* package.json 的 version 写进 `staging/package.json`),也就是产物命名用的那个版本;
* 2. `serverRoot` —— 开发形态下是 `packages/server/package.json`。
*
* 与 `config/env.ts` 加载 `.env` 的双候选写法同一思路:不依赖启动时的 cwd。
*/
function readVersion(): string {
const candidates = [
path.resolve(env.serverRoot, '..', 'package.json'),
path.resolve(env.serverRoot, 'package.json'),
];
for (const file of candidates) {
try {
const parsed = JSON.parse(fs.readFileSync(file, 'utf8')) as { version?: unknown };
if (typeof parsed.version === 'string' && parsed.version.trim()) {
return parsed.version.trim();
}
} catch {
// 换下一个候选
}
}
logger.warn(`未能从 package.json 读到版本号(候选:${candidates.join('、')}),暂时按 0.0.0 处理`);
return '0.0.0';
}
export const APP_VERSION = readVersion();
+1 -7
View File
@@ -1,6 +1,6 @@
import fs from 'node:fs'; import fs from 'node:fs';
import path from 'node:path'; import path from 'node:path';
import express, { type Express, type RequestHandler } from 'express'; import express, { type Express } from 'express';
import { env } from '../config/env.js'; import { env } from '../config/env.js';
import { logger } from './logger.js'; import { logger } from './logger.js';
@@ -100,9 +100,3 @@ export function mountWebAdmin(app: Express): string | null {
logger.info(`Web 管理端已挂载:${distDir}`); logger.info(`Web 管理端已挂载:${distDir}`);
return distDir; return distDir;
} }
/** 静态资源请求判断(用于日志降噪等场景) */
export const staticAssetMatcher: RequestHandler = (req, _res, next) => {
req.headers['x-classhelper-static'] = req.path.startsWith('/assets/') ? '1' : '0';
next();
};
+18
View File
@@ -40,6 +40,24 @@ export const errorHandler: ErrorRequestHandler = (error, req, res, _next) => {
return; return;
} }
/**
* 请求体超限(body-parser 抛的 `entity.too.large`)。
*
* 必须单独处理:它带 `status: 413` 但不是 ApiError,落进下面的兜底分支会变成
* 「500 服务器内部错误:request entity too large」——既是错的状态码,也把英文原文抛给用户,
* 而用户真正需要知道的是"文件太大了、请拆分"(表格导入的 8MB 上限见 table-import.service)。
*/
if ((error as { type?: string }).type === 'entity.too.large') {
logger.warn(`请求体超过上限:${req.method} ${req.originalUrl}`);
sendError(
res,
413,
'上传内容过大:请把文件拆分后分批导入(表格文件上限 8MB)',
'IMPORT_TOO_LARGE',
);
return;
}
// Prisma 已知错误码(P2002 唯一约束 / P2025 记录不存在 / P2003 外键约束) // Prisma 已知错误码(P2002 唯一约束 / P2025 记录不存在 / P2003 外键约束)
const prismaCode = (error as { code?: string }).code; const prismaCode = (error as { code?: string }).code;
if (prismaCode === 'P2002') { if (prismaCode === 'P2002') {
+10 -1
View File
@@ -85,11 +85,20 @@ export function loginRateLimiter(): RequestHandler {
}); });
} }
/** 请求耗时日志(生产 info,开发 debug) */ /**
* 请求耗时日志(生产 info,开发 debug)。
*
* 静态构建产物(`/assets/*`,带内容哈希、长缓存)**成功的请求不打点**:
* Web 管理端首屏一次就有十几个资源请求,逐条刷 info 会把真正有用的接口日志淹掉,
* 而且每条都要走一次 stdout 写入。失败的静态请求(404 / 500)照常记录 ——
* 那种情况恰恰是最需要看见的(产物缺失、路径不对)。
*/
export function requestLogger(): RequestHandler { export function requestLogger(): RequestHandler {
return (req, res, next) => { return (req, res, next) => {
const isStaticAsset = req.path.startsWith('/assets/');
const startedAt = process.hrtime.bigint(); const startedAt = process.hrtime.bigint();
res.on('finish', () => { res.on('finish', () => {
if (isStaticAsset && res.statusCode < 400) return;
const durationMs = Number(process.hrtime.bigint() - startedAt) / 1_000_000; const durationMs = Number(process.hrtime.bigint() - startedAt) / 1_000_000;
const message = `${req.method} ${req.originalUrl} ${res.statusCode} ${durationMs.toFixed(1)}ms`; const message = `${req.method} ${req.originalUrl} ${res.statusCode} ${durationMs.toFixed(1)}ms`;
if (res.statusCode >= 500) logger.error(message); if (res.statusCode >= 500) logger.error(message);
@@ -19,14 +19,16 @@ export async function login(input: LoginInput): Promise<LoginResponse> {
const user = await prisma.user.findUnique({ where: { username: input.username } }); const user = await prisma.user.findUnique({ where: { username: input.username } });
if (!user) throw ApiError.unauthorized('用户名或密码错误'); if (!user) throw ApiError.unauthorized('用户名或密码错误');
const passwordMatched = await verifyPassword(input.password, user.passwordHash); // 角色判定必须放在密码校验**之前**:否则"密码错"与"密码对但学生账号已停用"会给出
if (!passwordMatched) throw ApiError.unauthorized('用户名或密码错误'); // 不同的响应(401 / 403),攻击者据此就能把学生账号的密码当成可离线验证的预言机。
// 文案与状态码保持不变(客户端按 403 提示"请用班级码登录")。
// 个人学生账号已停用登录入口(需求:以班级为单位,删掉学生用自己用户名登录)
if (user.role === 'STUDENT') { if (user.role === 'STUDENT') {
throw ApiError.forbidden('学生请使用「班级码 + 班级密码」登录(个人学生账号已停用)'); throw ApiError.forbidden('学生请使用「班级码 + 班级密码」登录(个人学生账号已停用)');
} }
const passwordMatched = await verifyPassword(input.password, user.passwordHash);
if (!passwordMatched) throw ApiError.unauthorized('用户名或密码错误');
const payload: TokenPayload = { const payload: TokenPayload = {
sub: user.id, sub: user.id,
username: user.username, username: user.username,
@@ -1,5 +1,5 @@
import { z } from 'zod'; import { z } from 'zod';
import { CLASSISLAND_NOTIFICATION_CHANNELS } from '@classhelper/shared'; import { CLASSISLAND_NOTIFICATION_CHANNELS, MAX_TERM_WEEK } from '@classhelper/shared';
import { keywordSchema } from '../../lib/schemas.js'; import { keywordSchema } from '../../lib/schemas.js';
export const createClassSchema = z.object({ export const createClassSchema = z.object({
@@ -13,13 +13,19 @@ export const createClassSchema = z.object({
.trim() .trim()
.regex(/^[A-Za-z0-9]{4,16}$/, '班级码需为 4~16 位字母或数字') .regex(/^[A-Za-z0-9]{4,16}$/, '班级码需为 4~16 位字母或数字')
.optional(), .optional(),
/**
* 本学期教学周数。上限与课表周次口径统一取 MAX_TERM_WEEK(30):
* 周次选择器与 weekNumberSchema 都只到 30,允许更大的值只会让用户设出一个
* 系统兑现不了的学期长度(第 31 周之后永远为空)。
*/
termWeeks: z.coerce.number().int().min(1).max(MAX_TERM_WEEK).optional(),
}); });
export const updateClassSchema = z.object({ export const updateClassSchema = z.object({
name: z.string().trim().min(1).max(64).optional(), name: z.string().trim().min(1).max(64).optional(),
grade: z.string().trim().min(1).max(32).optional(), grade: z.string().trim().min(1).max(32).optional(),
/** 本学期教学周数(1~40,班主任可调) */ /** 本学期教学周数(1~30,管理员可调) */
termWeeks: z.coerce.number().int().min(1).max(40).optional(), termWeeks: z.coerce.number().int().min(1).max(MAX_TERM_WEEK).optional(),
}); });
/** 设置 / 重置班级账号(班级码 + 班级密码):仅管理员 */ /** 设置 / 重置班级账号(班级码 + 班级密码):仅管理员 */
@@ -43,7 +49,6 @@ export const listClassesQuerySchema = z.object({
export const addStudentSchema = z.object({ export const addStudentSchema = z.object({
username: z.string().trim().min(3, '用户名至少 3 位').max(32), username: z.string().trim().min(3, '用户名至少 3 位').max(32),
name: z.string().trim().min(1, '请输入姓名').max(32), name: z.string().trim().min(1, '请输入姓名').max(32),
password: z.string().min(6, '密码至少 6 位').max(128).optional(),
}); });
export const assignTeacherSchema = z.object({ export const assignTeacherSchema = z.object({
@@ -28,7 +28,6 @@ import {
toStudentDto, toStudentDto,
toTeacherBrief, toTeacherBrief,
} from '../../lib/mappers.js'; } from '../../lib/mappers.js';
import { hashPassword } from '../../lib/password.js';
import { emitToClass } from '../../realtime/bus.js'; import { emitToClass } from '../../realtime/bus.js';
import { SOCKET_EVENTS } from '@classhelper/shared'; import { SOCKET_EVENTS } from '@classhelper/shared';
import type { import type {
@@ -152,6 +151,8 @@ export async function createClass(user: TokenPayload, input: CreateClassInput):
teacherId, teacherId,
code: account.code, code: account.code,
passwordHash: account.passwordHash, passwordHash: account.passwordHash,
// 新建时就能指定学期周数(之前只有编辑接口支持,Web 端表单里填了也会被丢弃)
...(input.termWeeks !== undefined ? { termWeeks: input.termWeeks } : {}),
}, },
include: { include: {
teacher: { select: { id: true, name: true, username: true } }, teacher: { select: { id: true, name: true, username: true } },
@@ -228,7 +229,7 @@ export async function updateClass(
data: { data: {
...(input.name ? { name: input.name } : {}), ...(input.name ? { name: input.name } : {}),
...(input.grade ? { grade: input.grade } : {}), ...(input.grade ? { grade: input.grade } : {}),
// 教学周数(班主任可调):课表周次选择与默认 weekEnd 都用它 // 教学周数(仅管理员可调,见 assertCanManageClasses):课表周次选择与默认 weekEnd 都用它
...(input.termWeeks !== undefined ? { termWeeks: input.termWeeks } : {}), ...(input.termWeeks !== undefined ? { termWeeks: input.termWeeks } : {}),
}, },
include: { include: {
@@ -260,9 +261,9 @@ export async function listClassStudents(user: TokenPayload, classId: string): Pr
} }
/** /**
* 添加学生到班级。 * 添加学生到班级(名单实体)。
* 已存在的学生账号直接转入本班(同时维护 Enrollment,保证"一个学生一个主班级")。 * 已存在的学生直接转入本班(同时维护 Enrollment,保证"一个学生一个主班级")。
* 新账号使用 DEFAULT_STUDENT_PASSWORD 作为初始密码。 * 学生没有账号属性:不设密码、不能登录,学生端统一用班级码 + 班级密码。
*/ */
export async function addStudent( export async function addStudent(
user: TokenPayload, user: TokenPayload,
@@ -292,7 +293,8 @@ export async function addStudent(
name: input.name, name: input.name,
role: 'STUDENT', role: 'STUDENT',
classId, classId,
passwordHash: await hashPassword(input.password ?? env.defaultStudentPassword), // 空串占位:User.passwordHash 必填,但学生的 403 登录判定在密码校验之前,永远用不到
passwordHash: '',
}, },
}); });
studentId = created.id; studentId = created.id;
@@ -17,8 +17,9 @@ router.get('/summary', async (req, res) => {
/** /**
* GET /api/dashboard/term?classId= - 学期信息(当前教学周 + 本班教学周数) * GET /api/dashboard/term?classId= - 学期信息(当前教学周 + 本班教学周数)
* *
* `maxWeek` 取**班级的教学周数**(`Class.termWeeks`,班主任可在班级设置里调,默认 20), * `maxWeek` 取**班级的教学周数**(`Class.termWeeks`,管理员在班级设置里调,默认 20),
* 这样周次选择器不会再出现"实际 20 周却给到 30 周"的情况;不带 classId 时退回全局默认值。 * 这样周次选择器不会再出现"实际 20 周却给到 30 周"的情况;不带 classId 时退回全局默认值。
* 带 classId 时会先校验班级访问权限(见 resolveTermWeeks)。
*/ */
router.get('/term', async (req, res) => { router.get('/term', async (req, res) => {
const user = getAuthUser(req); const user = getAuthUser(req);
@@ -1,5 +1,6 @@
import type { DashboardSummary, HomeworkDto, NotificationDto } from '@classhelper/shared'; import type { DashboardSummary, HomeworkDto, NotificationDto } from '@classhelper/shared';
import { import {
assertClassAccess,
classScopeIdFilter, classScopeIdFilter,
classScopeWhere, classScopeWhere,
isStudent, isStudent,
@@ -20,12 +21,14 @@ const creatorSelect = { select: { id: true, name: true, username: true } } as co
* 教师/管理员看到的是"自己管理的班级"的汇总;学生看到自己班级的汇总。 * 教师/管理员看到的是"自己管理的班级"的汇总;学生看到自己班级的汇总。
*/ */
/** /**
* 本班教学周数(班主任可调,默认 20)。 * 本班教学周数(默认 20)。
* - 学生 / 班级会话:固定为自己所在班级; * - 学生 / 班级会话:固定为自己所在班级;
* - 教师 / 管理员:优先用显式 classId(越权查不到时回退默认值); * - 教师 / 管理员:优先用显式 classId,**并且必须通过班级访问校验**(与其他接口同口径,
* 否则任意登录用户都能拿 classId 探测别班的教学周数);
* - 都不传:全局默认(MAX_TERM_WEEK 兜底)。 * - 都不传:全局默认(MAX_TERM_WEEK 兜底)。
*/ */
export async function resolveTermWeeks(user: TokenPayload, classId?: string): Promise<number> { export async function resolveTermWeeks(user: TokenPayload, classId?: string): Promise<number> {
if (classId) await assertClassAccess(user, classId);
const targetClassId = classId ?? (isStudent(user) ? requireStudentClassId(user) : undefined); const targetClassId = classId ?? (isStudent(user) ? requireStudentClassId(user) : undefined);
if (!targetClassId) return MAX_TERM_WEEK; if (!targetClassId) return MAX_TERM_WEEK;
const record = await prisma.class.findUnique({ const record = await prisma.class.findUnique({
Loaded 100 of 151 files, more files were not shown because too many files have changed in this diff. Show more