fix(release): 发布1.4.5并加固登录与灵动岛体验

登录连续五次失败封禁五分钟,修复两端错误提示;教师导入逐人生成随机密码并提供一次性清单。统一自定义岛外观与控件,修复圆角配置和全天课表对齐,临近下课显示课程旁秒数徽标;客户端更新改为云端统一下发。同步发布版本、帮助文档及隔离回归。
This commit is contained in:
LoveChengke committed 2026-11-08 09:55:33 +08:00
1 parent 9351203deb
commit 0b57e926bd
52 files changed
+746 -821

No files matched your search

+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@classhelper/desktop-client",
"version": "1.4.4",
"version": "1.4.5",
"private": true,
"description": "ClassHelper EXE 客户端(Electron + Vue 3 + Element Plus + Socket.IO + IndexedDB 离线缓存)",
"author": "Class Helper",
+2 -2
View File
@@ -84,8 +84,8 @@ function launchSmoke(extraEnv) {
child.kill();
resolve(124);
},
// 快速套件已包含本地 HTTP、校验下载和布局编辑;保留冷启动余量,单项断言不放宽。
mode === 'visual' ? 360_000 : 90_000,
// 快速套件包含两种布局的完整上下课时序、本地下载和编辑;总时限保留冷启动余量。
mode === 'visual' ? 360_000 : 120_000,
);
child.once('exit', (code) => {
clearTimeout(deadline);
@@ -37,8 +37,8 @@ const current = computed(() => today.value.find((s) => s.id === status.value.cur
const next = computed(() => today.value.find((s) => s.id === status.value.next?.scheduleId));
function timeAt(time: string) {
const d = new Date(props.now);
const [h, m] = time.split(':').map(Number);
d.setHours(h!, m!, 0, 0);
const [h, m, s = 0] = time.split(':').map(Number);
d.setHours(h!, m!, s, 0);
return d.getTime();
}
/**
@@ -106,6 +106,7 @@ const remaining = computed(() =>
currentLesson.value ? Math.max(0, Math.ceil((timeAt(currentLesson.value.endTime) - props.now) / 1000)) : 0,
);
const hidden = computed(
// 临近下课仍使用真实时间点,不因提醒切换而替换课程组件。
() =>
!props.editing &&
((['notification', 'homework', 'call'].includes(props.node.kind) &&
@@ -256,6 +257,13 @@ const style = computed<CSSProperties>(() => {
:class="{ current: p.id === currentPoint?.id, break: p.timeType === 'BREAK' }"
>
<strong>{{ p.courseName || p.name || '—' }}</strong>
<span
v-if="p.id === currentLesson?.id && state.lessonReminder?.kind === 'ending' && remaining > 0"
class="lesson-ending-badge"
:aria-label="`距下课${remaining}秒`"
>
-{{ remaining }}
</span>
<small v-if="p.id === currentPoint?.id && node.settings.showPeriod" class="lesson-time">
{{ p.startTime }}–{{ p.endTime }}
</small>
@@ -352,8 +360,11 @@ const style = computed<CSSProperties>(() => {
transform-origin: left;
transition: transform 1s linear;
}
.schedule > .lesson-line + .lesson-line {
margin-top: 8px;
.schedule {
display: flex;
flex-direction: column;
align-items: center;
gap: 8px;
}
.separator > span {
display: block;
@@ -441,3 +452,5 @@ strong,
}
}
</style>
<style src="./lesson-ending.css"></style>
<style src="./lesson-ending.css"></style>
@@ -27,7 +27,10 @@ const props = defineProps<{
}>();
const scheme = computed(() => props.settings.schemes.find((s) => s.id === props.settings.activeSchemeId)!);
const expanded = computed(() => props.state.mode === 'expanded');
const lesson = computed(() => props.state.lessonReminder ?? null);
// 即将下课只在当前课程旁显示秒数,保留常驻组件与消息入口。
const lesson = computed(() =>
props.state.lessonReminder?.kind === 'ending' ? null : (props.state.lessonReminder ?? null),
);
const lastLesson = ref<IslandLessonReminder | null>(null);
watch(
lesson,
@@ -283,7 +286,15 @@ watch(
{ deep: true, flush: 'post' },
);
watch(
[fit, motion, expanded, lesson, () => props.appearance.radius, () => props.appearance.speed],
[
fit,
motion,
expanded,
lesson,
() => scheme.value.radius,
() => props.appearance.radius,
() => props.appearance.speed,
],
() => {
animate();
trackHit();
@@ -10,7 +10,7 @@ const props = defineProps<{
}>();
const root = ref<HTMLElement>();
const width = ref(480);
const mask = computed(() => props.now < props.reminder.maskUntil);
const mask = computed(() => props.reminder.kind !== 'ending' && props.now < props.reminder.maskUntil);
const title = computed(
() =>
({
@@ -140,15 +140,14 @@ onUnmounted(() => {
aria-live="polite"
>
<div class="ci-lesson-info">
<span
v-if="reminder.kind === 'prepare' || reminder.kind === 'ending' || reminder.kind === 'in-class'"
class="ci-countdown"
>
<span v-if="reminder.kind === 'prepare' || reminder.kind === 'in-class'" class="ci-countdown">
{{ reminder.kind === 'prepare' ? '距上课还剩' : '距下课还剩' }}
<strong>{{ leftSeconds }}</strong>
秒
</span>
<span v-else class="ci-countdown">{{ reminder.kind === 'on-class' ? '开始上课' : '课间休息' }}</span>
<span v-else-if="reminder.kind !== 'ending'" class="ci-countdown">
{{ reminder.kind === 'on-class' ? '开始上课' : '课间休息' }}
</span>
<span class="ci-lesson-course">
<span>
{{
@@ -158,6 +157,13 @@ onUnmounted(() => {
}}
</span>
<strong>{{ course || '今日课程已结束' }}</strong>
<span
v-if="reminder.kind === 'ending'"
class="lesson-ending-badge"
:aria-label="`距下课${leftSeconds}秒`"
>
-{{ leftSeconds }}
</span>
<small v-if="course">{{ time }}</small>
</span>
</div>
@@ -309,3 +315,4 @@ onUnmounted(() => {
transition: transform 50ms linear;
}
</style>
<style src="./lesson-ending.css"></style>
@@ -0,0 +1,16 @@
/* 两种岛共用临近下课徽标;固定正圆,数字使用等宽字形。 */
.lesson-ending-badge {
display: inline-flex;
align-items: center;
justify-content: center;
flex: 0 0 auto;
width: 30px;
height: 30px;
border-radius: 50%;
color: #fff;
background: #0a84ff;
font-size: 12px;
font-weight: 600;
font-variant-numeric: tabular-nums;
line-height: 1;
}
@@ -19,8 +19,6 @@ export const IPC_CHANNELS = {
clearConfig: 'classhelper:config:clear',
appInfo: 'classhelper:app:info',
openExternal: 'classhelper:shell:open-external',
updateCheck: 'classhelper:update:check',
updateIgnore: 'classhelper:update:ignore',
getAutoLaunch: 'classhelper:app:get-autolaunch',
setAutoLaunch: 'classhelper:app:set-autolaunch',
openLogDir: 'classhelper:app:open-log-dir',
@@ -28,6 +26,3 @@ export const IPC_CHANNELS = {
clientStatus: 'classhelper:client:status',
clientBeatNow: 'classhelper:client:beat-now',
} as const;
/** 主进程 → 渲染进程的单向推送:有可用更新(同理,供 preload 与主进程共用) */
export const UPDATE_AVAILABLE_CHANNEL = 'classhelper:update:available';
+1 -1
View File
@@ -43,7 +43,7 @@ interface PersistedConfig {
theme?: 'light' | 'dark';
/** 主侧边栏是否折叠(向后兼容:旧配置没有该字段视为展开) */
sidebarCollapsed?: boolean;
/** 用户选择「忽略此版本」的版本号(向后兼容:旧配置没有该字段视为没忽略过任何版本) */
/** 旧版主动更新检查的兼容字段;统一云端下发更新后不再参与更新决策。 */
ignoredUpdateVersion?: string;
/** 本机设备标识(向后兼容:旧配置没有该字段时首次读取生成并落盘,之后永不变) */
deviceKey?: string;
@@ -10,7 +10,6 @@ import { island, registerIslandIpc } from './island.js';
import { logger } from './logger.js';
import { runSmokeTest } from './smoke.js';
import { createTray, destroyTray, isTrayReady } from './tray.js';
import { scheduleStartupUpdateCheck } from './update.js';
// 主进程由 esbuild 打包为 CommonJS,因此这里可以直接使用 __dirname
// (dist/main/index.js -> dist/preload/index.js 与 dist/renderer/index.html)
@@ -259,9 +258,6 @@ if (!gotLock) {
logger.warn(`系统托盘初始化失败(不影响主功能):${error instanceof Error ? error.message : error}`);
}
// 启动后自动查一次更新(延迟几秒,不跟首屏抢带宽);冒烟模式下自动跳过,见 main/update.ts
scheduleStartupUpdateCheck(() => mainWindow);
// 服务端统一下发:定时上报本机状态并领取「待执行命令 / 统一更新」(冒烟默认不上报)
startClientAgent();
-17
View File
@@ -9,12 +9,10 @@ import { island } from './island.js';
import { getIslandWeather } from './island-weather.js';
import { getUpdateProgress } from './auto-update.js';
import { app, BrowserWindow, ipcMain, shell } from 'electron';
import type { UpdateInfo } from '@classhelper/shared';
import { IPC_CHANNELS } from './channels.js';
import { beatNow, getClientAgentStatus } from './client-agent.js';
import { clearConfig, getConfig, getConfigPath, saveConfig } from './config.js';
import { logger } from './logger.js';
import { checkForUpdates, ignoreUpdateVersion } from './update.js';
import type { DesktopAppInfo, DesktopStoredConfig } from '../types/desktop.js';
// 通道名定义搬到了叶子模块 `channels.ts`(原因见那里的注释:preload 在沙箱里不能碰 node 内建模块);
@@ -65,21 +63,6 @@ export function registerIpcHandlers(): void {
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);
});
/** 开机自启:读的是系统登录项,不是配置文件里的值(两者可能被外部改过) */
ipcMain.handle(IPC_CHANNELS.getAutoLaunch, (): boolean => {
try {
+5 -1
View File
@@ -171,6 +171,7 @@ class IslandController {
private lessonTimer: ReturnType<typeof setInterval> | null = null;
private lessonTestTime: number | null = null;
private get lessonShowing(): boolean {
if (this.customLayout && this.lessonCue?.kind === 'ending') return false;
return Boolean(
this.lessonCue &&
!this.editingLayout &&
@@ -649,7 +650,10 @@ class IslandController {
return {
...this.state,
coursewareTransfer: this.coursewareShowing ? this.state.coursewareTransfer : null,
lessonReminder: this.lessonShowing ? this.lessonCue : null,
lessonReminder:
this.lessonShowing || (this.customLayout && this.lessonCue?.kind === 'ending')
? this.lessonCue
: null,
queued: [...this.state.queued],
};
}
@@ -527,7 +527,7 @@ export async function verifyResidentSmoke(
await pause(700);
return Math.abs(immediate - opacity) < 0.01 && Math.abs(after - opacity) < 0.01;
});
await check('两种布局均弹出ClassIsland课前/上下课提醒,倒计时与右侧时间正确且不写入通知队列', async () => {
await check('两种布局的上下课提醒、课程旁下课倒数与右侧时间正确且不写入通知队列', async () => {
const capture = process.env.ISLAND_MOTION_CAPTURE === '1' && process.env.ELECTRON_SMOKE_MODE === 'visual';
const recorded: Array<{ at: number; image: Electron.NativeImage }> = [];
const start = Date.now();
@@ -642,17 +642,33 @@ export async function verifyResidentSmoke(
throw new Error('自动倒计时未切到本节下课');
}
if (layout === 'custom') {
saveConfig({ islandLayout: { ...fixture, layout } });
const endingLayout = JSON.parse(JSON.stringify(fixture));
endingLayout.schemes[0].rows[0].nodes = [islandNode('schedule', 'lesson-ending-course')];
saveConfig({ islandLayout: endingLayout });
island.syncCustomLayout();
}
await setTime(9, 44);
await pause(700);
await pause(1100);
if (island.getState().lessonReminder?.kind !== 'ending')
throw new Error(layout + '下课倒数状态错误:' + JSON.stringify(island.getState().lessonReminder));
const ending = await win.webContents.executeJavaScript(
`document.querySelector('${layout === 'custom' ? '.resident-lesson-page' : '.ci-fixed-lesson'}')?.textContent.includes('距下课还剩')`,
`(() => {
const root=document.querySelector('${layout === 'custom' ? '.resident-compact' : '.ci-fixed-lesson'}');
const badge=root?.querySelector('.lesson-ending-badge');
const course=root?.querySelector('${layout === 'custom' ? '.lesson-line.current strong' : '.ci-lesson-course strong'}');
const rect=badge?.getBoundingClientRect(),name=course?.getBoundingClientRect();
return Boolean(badge?.textContent.trim()==='-60'&&rect&&name&&rect.left>=name.right&&Math.abs(rect.width-rect.height)<1&&!root?.querySelector('.ci-mask-active'));
})()`,
);
if (!ending) throw new Error(layout + '下课倒数未渲染');
await setTime(9, 44, 59);
await pause(1100);
if (
!(await win.webContents.executeJavaScript(
`document.querySelector('${layout === 'custom' ? '.resident-compact' : '.ci-fixed-lesson'} .lesson-ending-badge')?.textContent.trim()==='-1'`,
))
)
throw new Error(layout + '最后一秒徽标错误');
await shot('lesson-ending-' + layout);
await setTime(9, 45);
island.setClassState({ inClass: false });
-41
View File
@@ -17,7 +17,6 @@ import {
ISLAND_URGENT_SIZE,
} from './island.js';
import { destroyTray, getTrayState, isTrayReady } from './tray.js';
import { checkForUpdates, wasStartupCheckSkipped } from './update.js';
interface SmokeResult {
name: string;
@@ -4478,46 +4477,6 @@ export async function runSmokeTest(win: BrowserWindow): Promise<void> {
);
record('关于页渲染(应用信息/诊断信息/鸣谢)', Boolean(aboutPage?.ok), String(aboutPage?.detail ?? ''));
// 更新检查(新功能回归):主进程直连 GitHub 取最新 Release。
//
// **刻意不断言"一定有新版本"**:那会把冒烟绑死在外网可达上,而教室机器常常没有外网
// (`ok=false` 是设计内的降级结果,不是失败)。因此两种结果都算通过,验的是:
// 结构完整、失败时有可读原因、以及缓存真的生效。
const updateFirst = await checkForUpdates(true);
const isVersionLike = (value: unknown): boolean => typeof value === 'string' && /^\d/.test(value);
const updateShapeOk =
isVersionLike(updateFirst.currentVersion) &&
typeof updateFirst.ok === 'boolean' &&
typeof updateFirst.hasUpdate === 'boolean' &&
(updateFirst.ok
? isVersionLike(updateFirst.latestVersion) &&
Array.isArray(updateFirst.assets) &&
/^https:\/\//.test(updateFirst.releaseUrl) &&
updateFirst.error === null
: typeof updateFirst.error === 'string' && updateFirst.error.length > 0);
record(
'更新检查返回结构正确(无外网时降级为 ok=false 且带原因)',
updateShapeOk,
`ok=${updateFirst.ok} 本机=${updateFirst.currentVersion} 最新=${updateFirst.latestVersion ?? '-'} ` +
`有新版本=${updateFirst.hasUpdate} 附件=${updateFirst.assets.length}` +
`${updateFirst.error ? ` 原因=${updateFirst.error}` : ''}`,
);
// 缓存:紧接着再查一次(不传 force)应命中缓存 —— checkedAt 不变即说明没有二次请求
const updateSecond = await checkForUpdates();
record(
'更新检查结果带缓存(不重复请求 GitHub)',
updateSecond.checkedAt === updateFirst.checkedAt,
`两次 checkedAt 相同=${updateSecond.checkedAt === updateFirst.checkedAt}`,
);
// 启动自动检查在冒烟模式下必须被跳过,否则每次验证都会产生一次真实网络请求与提示条
record(
'冒烟模式下跳过启动自动检查(验证不依赖外网)',
wasStartupCheckSkipped(),
`skipped=${wasStartupCheckSkipped()}`,
);
// 未读红点必须挂在"通知"图标右上方(用户反馈:原来挂在文字后面,位置不对)
const readBadgeGeometry = async (): Promise<{
ok: boolean;
-216
View File
@@ -1,216 +0,0 @@
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 { UPDATE_AVAILABLE_CHANNEL } from './channels.js';
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` 结构一致。
*/
/** 主进程 → 渲染进程:发现新版本(渲染进程据此弹一次性提示);定义在叶子模块 `channels.ts` */
export { UPDATE_AVAILABLE_CHANNEL };
/** 启动后多久自动查一次:等窗口与登录流程就绪,也不跟首屏请求抢带宽 */
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;
}
+2 -11
View File
@@ -3,7 +3,7 @@ import type {
CoursewareTransfer,
} from '@classhelper/shared';
import { contextBridge, ipcRenderer } from 'electron';
import { IPC_CHANNELS, UPDATE_AVAILABLE_CHANNEL } from '../main/channels.js';
import { IPC_CHANNELS } from '../main/channels.js';
import type { ClientAgentStatus } from '../main/client-agent.js';
import type {
DesktopAppInfo,
@@ -12,7 +12,7 @@ import type {
IslandClassStatePayload,
IslandPushContext,
} from '../types/desktop.js';
import type { IslandNotification, UpdateInfo } from '@classhelper/shared';
import type { IslandNotification } from '@classhelper/shared';
/**
* 预加载脚本:在开启了 contextIsolation + sandbox 的前提下,
@@ -65,15 +65,6 @@ const bridge: DesktopBridge = {
getAppInfo: (): Promise<DesktopAppInfo> => ipcRenderer.invoke(IPC_CHANNELS.appInfo),
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 => {
ipcRenderer.send('island:push', payload);
},
+2 -53
View File
@@ -1,8 +1,6 @@
<script setup lang="ts">
import { h, onMounted, onUnmounted, ref } from 'vue';
import { onMounted, onUnmounted, ref } from 'vue';
import { useRouter } from 'vue-router';
import { ElButton, ElNotification } from 'element-plus';
import type { UpdateInfo } from '@classhelper/shared';
import {
replayMissedNotifications,
startIslandBridge,
@@ -28,56 +26,10 @@ const realtime = useRealtimeStore();
const booting = ref(true);
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 ?? '');
},
},
() => '忽略此版本',
),
]),
]),
});
}
/**
* 上线补弹「离线期间收到的消息」(需求 11)。
*
* **为什么订阅放在 App.vue**:与 `onUpdateAvailable` 同一条理由 —— App.vue 整个应用生命周期
* **为什么订阅放在 App.vue**:App.vue 整个应用生命周期
* 只挂载一次,而 `ClientLayout` 会随"登出 → 登录"反复挂载。而且恢复事件本身是"可达性由不可达
* 变为可达"的那一刻,一次会话里可能发生多次,处理器必须是**幂等**的(`replayMissedNotifications`
* 推完就清掉离线起点,重复触发时第二次读到空值、直接返回 0)。
@@ -118,9 +70,6 @@ onMounted(async () => {
// 离线期间收到的消息:可达性恢复的那一刻补弹到灵动岛(App.vue 常驻,所以每次恢复只跑一次)
appStore.onServerRecovered(handleServerRecovered);
// 启动自动检查发现新版本时由主进程推过来(订阅只挂一次,理由见 showUpdateAvailable)
window.desktop?.onUpdateAvailable?.(showUpdateAvailable);
if (auth.isAuthenticated) await router.replace('/schedule');
else await router.replace('/login');
@@ -61,7 +61,10 @@ http.interceptors.response.use(
const status = error.response.status;
const message = error.response.data?.message ?? `请求失败(${status})`;
if (status === 401) {
const loginAttempt =
error.config?.method?.toLowerCase() === 'post' &&
/\/auth\/(?:class-)?login\/?(?:\?|$)/.test(error.config?.url ?? '');
if (status === 401 && !loginAttempt) {
ElMessage.warning('登录状态已失效,请重新登录');
unauthorizedHandler();
} else {
+3 -9
View File
@@ -1168,18 +1168,12 @@ export async function aboutPageSelfTest(): Promise<SmokeCheckResult> {
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"]');
const hasUpdateCheck = Boolean(document.querySelector('[data-test="update-check"]'));
await router.push('/schedule');
return {
ok: hasThanks && hasDiagnostics && hasConfigPath && Boolean(updateBlock) && Boolean(updateButton),
detail:
`鸣谢=${hasThanks} 诊断=${hasDiagnostics} configPath=${hasConfigPath ? '有' : '无'} ` +
`检查更新块=${updateBlock ? '有' : '无'} 按钮=${updateButton ? '有' : '无'}`,
ok: hasThanks && hasDiagnostics && hasConfigPath && !hasUpdateCheck,
detail: `鸣谢=${hasThanks} 诊断=${hasDiagnostics} configPath=${hasConfigPath ? '有' : '无'}`,
};
} catch (error) {
return {
@@ -54,7 +54,7 @@ const container = computed(() => ['group', 'stack', 'slide', 'rolling'].includes
display: flex;
align-items: center;
flex-shrink: 0;
border-radius: 5px;
border-radius: var(--ch-radius-control);
}
.component-chip {
display: flex;
@@ -62,9 +62,9 @@ const container = computed(() => ['group', 'stack', 'slide', 'rolling'].includes
gap: 5px;
min-height: 36px;
padding: 5px 9px;
border: 1px solid transparent;
border-radius: 5px;
background: transparent;
border: 1px solid var(--ch-border);
border-radius: var(--ch-radius-control);
background: var(--ch-surface);
color: inherit;
font: inherit;
white-space: nowrap;
@@ -6,7 +6,7 @@
min-width: 0;
color: var(--ch-text);
padding: 12px 24px 16px;
background: var(--editor-background, var(--ch-bg));
background: var(--ch-bg);
}
:global(.main:has(> .island-editor-page)) {
display: flex;
@@ -16,11 +16,6 @@
.island-editor-page > * {
flex-shrink: 0;
}
:global(html.dark) .island-editor-page {
--editor-background: #262626;
--editor-divider: #3a3a3a;
--editor-card: #2c2c2c;
}
.editor-actions {
display: flex;
align-items: center;
@@ -77,7 +72,8 @@
}
.scheme-controls :deep(.el-select__wrapper) {
min-height: 38px;
background: var(--ch-card-subtle);
background: var(--ch-surface);
border-radius: var(--ch-radius-control);
}
.icon-button {
width: 34px;
@@ -139,7 +135,7 @@
display: flex;
align-items: center;
min-height: 54px;
border-radius: 6px;
border-radius: var(--ch-radius-control);
gap: 12px;
padding: 4px;
border: 1px solid transparent;
@@ -180,7 +176,7 @@
background: transparent;
color: var(--ch-text-tertiary);
padding: 10px 24px;
border-radius: 5px;
border-radius: var(--ch-radius-control);
font: inherit;
font-size: 12px;
cursor: pointer;
@@ -251,7 +247,7 @@
font-size: 12px;
}
.component-library {
border-top: 6px solid var(--editor-divider, var(--ch-divider));
border-top: 1px solid var(--ch-border);
margin: 0 -24px;
padding: 14px 24px 24px;
flex: 1 0 auto;
@@ -288,9 +284,9 @@
text-align: left;
min-height: 76px;
padding: 10px 8px;
border: 1px solid transparent;
border-radius: 6px;
background: transparent;
border: 1px solid var(--ch-border);
border-radius: var(--ch-radius-control);
background: var(--ch-surface);
color: inherit;
font: inherit;
cursor: grab;
@@ -332,51 +328,6 @@
font-size: calc(14px * var(--ch-font-scale));
line-height: 1.5;
}
.message-library-title {
color: var(--ch-text-tertiary);
font-size: 12px;
font-weight: 400;
margin: 20px 8px 4px;
}
.message-options .library-item {
min-height: 64px;
}
.message-options .library-item strong {
font-size: 15px;
}
.message-options .library-item > svg {
width: 26px;
height: 26px;
flex-basis: 26px;
}
.editor-tip {
display: flex;
align-items: center;
gap: 14px;
padding: 12px 16px;
min-height: 60px;
border: 1px solid var(--ch-border-strong);
border-radius: 5px;
background: var(--editor-card, var(--ch-card-subtle));
font-size: 14px;
}
.editor-tip > span {
flex: 1;
line-height: 1.6;
}
.tip-icon {
color: var(--ch-accent);
font-size: 22px;
}
.dismiss-tip {
border: 0;
color: var(--ch-text);
background: transparent;
font-size: 26px;
cursor: pointer;
margin-left: auto;
padding: 0 8px;
}
.drag-ghost {
position: fixed;
z-index: 10000;
@@ -392,6 +343,22 @@
.inspector-tabs {
margin-bottom: 20px;
}
:global(.island-inspector) {
color: var(--ch-text);
background: var(--ch-surface);
}
:global(.island-inspector .el-drawer__header) {
color: var(--ch-text);
}
:global(.island-inspector .el-input-number),
:global(.island-inspector .el-select) {
width: 100%;
}
:global(.island-inspector .el-input__wrapper),
:global(.island-inspector .el-select__wrapper) {
background: var(--ch-surface);
border-radius: var(--ch-radius-control);
}
.row-actions {
display: flex;
gap: 6px;
@@ -426,9 +393,6 @@
.scheme-tools {
flex: 1 1 100%;
}
.editor-tip {
flex-wrap: wrap;
}
.preview-toolbar .hint {
display: none;
}
@@ -1,14 +1,12 @@
<script setup lang="ts">
import UpdateProgress from '../../components/UpdateProgress.vue';
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();
@@ -17,10 +15,6 @@ 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';
@@ -38,40 +32,16 @@ async function openExternal(url: string): Promise<void> {
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">
<UpdateProgress />
<p class="text-muted">客户端更新由管理端统一下发。</p>
<div class="page-header">
<div>
<h2 class="page-title">关于</h2>
@@ -107,51 +77,6 @@ onMounted(async () => {
</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>
@@ -248,55 +173,4 @@ onMounted(async () => {
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>
@@ -2,7 +2,7 @@
import { confirmAction } from '../../composables/confirm.js';
import { computed, onMounted, ref } from 'vue';
import { ElMessage } from 'element-plus';
import { formatDate, relativeTime, type UpdateInfo } from '@classhelper/shared';
import { formatDate, relativeTime } from '@classhelper/shared';
import type { ClientAgentStatus, DesktopAppInfo } from '../../../types/desktop.js';
import { useAppStore } from '../../stores/app.js';
import { useUiStore } from '../../stores/ui.js';
@@ -42,7 +42,6 @@ async function loadAll(): Promise<void> {
try {
await loadAppInfo();
await refreshAgent();
await loadIgnoredVersion();
await appStore.refreshCacheStats();
} finally {
loading.value = false;
@@ -110,51 +109,6 @@ async function openLogDir(): Promise<void> {
if (!ok) ElMessage.warning('打开日志目录失败,请按上面的路径手动前往');
}
/* ------------------------------------------------------------ 更新 */
/**
* 更新检查。
*
* 「立即检查」走 `checkForUpdates(true)`:**强制绕过主进程那 30 分钟缓存**。
* 这是本页与「关于」页的区别 —— 那边用户点检查也可能是缓存结果(省流量),
* 这边维护者要的是"现在到底拿得到什么",所以按钮默认就是强制的。
*/
const checking = ref(false);
const updateInfo = ref<UpdateInfo | null>(null);
const ignoredUpdateVersion = ref('');
async function checkUpdate(force: boolean): Promise<void> {
if (!window.desktop?.checkForUpdates) return;
checking.value = true;
try {
updateInfo.value = await window.desktop.checkForUpdates(force);
} finally {
checking.value = false;
}
}
async function loadIgnoredVersion(): Promise<void> {
if (!window.desktop?.getConfig) return;
const stored = await window.desktop.getConfig().catch(() => null);
ignoredUpdateVersion.value = stored?.ignoredUpdateVersion ?? '';
}
async function ignoreVersion(): Promise<void> {
const version = updateInfo.value?.latestVersion;
if (!version || !window.desktop?.ignoreUpdateVersion) return;
await window.desktop.ignoreUpdateVersion(version);
ignoredUpdateVersion.value = version;
ElMessage.success(`已忽略 v${version}:启动时的自动检查不再提示它`);
}
/** 忽略是可逆的(排查线上"用户说不再提示"时经常要把它清掉),顺手给一个恢复入口 */
async function clearIgnoredVersion(): Promise<void> {
if (!window.desktop?.saveConfig) return;
const saved = await window.desktop.saveConfig({ ignoredUpdateVersion: '' });
ignoredUpdateVersion.value = saved.ignoredUpdateVersion;
ElMessage.success('已恢复该版本的更新提示');
}
/* ------------------------------------------------------------ 调试工具 */
const openingDevTools = ref(false);
@@ -211,8 +165,6 @@ async function clearCache(): Promise<void> {
onMounted(async () => {
await loadAll();
// 带出启动自动检查的结果(这次命中主进程缓存,不会真的再发一次请求)
void checkUpdate(false);
});
</script>
@@ -326,56 +278,6 @@ onMounted(async () => {
</div>
</el-card>
<!-- 更新 -->
<el-card shadow="never" class="mt-12">
<template #header><span>更新</span></template>
<div class="toolbar">
<el-button :loading="checking" data-test="dev-check-update" @click="checkUpdate(true)">
强制检查更新
</el-button>
<span class="text-muted">绕过主进程 30 分钟缓存,直接问 GitHub</span>
</div>
<el-descriptions :column="1" border size="small" class="mt-12">
<el-descriptions-item label="本次结果">
<template v-if="checking">正在检查…</template>
<template v-else-if="!updateInfo">尚未检查</template>
<template v-else-if="!updateInfo.ok">
<span class="text-muted">{{ updateInfo.error ?? '暂时无法检查更新' }}</span>
</template>
<template v-else-if="updateInfo.hasUpdate">
<el-tag size="small" type="success" effect="light">
有新版本 v{{ updateInfo.latestVersion }}
</el-tag>
<span class="text-muted">当前 v{{ updateInfo.currentVersion }}</span>
</template>
<template v-else>
<el-tag size="small" type="info" effect="plain">已是最新版本</el-tag>
<span class="text-muted">v{{ updateInfo.currentVersion }}</span>
</template>
</el-descriptions-item>
<el-descriptions-item label="检查时间">
{{ updateInfo?.checkedAt ? formatDate(updateInfo.checkedAt, true) : '—' }}
</el-descriptions-item>
<el-descriptions-item label="已忽略的版本">
<template v-if="ignoredUpdateVersion">
<span class="mono">v{{ ignoredUpdateVersion }}</span>
<el-button link type="primary" size="small" @click="clearIgnoredVersion">恢复提示</el-button>
</template>
<span v-else class="text-muted">无</span>
</el-descriptions-item>
</el-descriptions>
<div class="toolbar mt-12">
<el-button
:disabled="!updateInfo?.latestVersion"
data-test="dev-ignore-version"
@click="ignoreVersion"
>
不再提示该版本
</el-button>
<span class="text-muted">写入配置后,启动时的自动检查会跳过它</span>
</div>
</el-card>
<!-- 调试工具 -->
<el-card shadow="never" class="mt-12">
<template #header><span>调试工具</span></template>
@@ -37,7 +37,6 @@ const selectedId = ref(''),
rowId = ref(''),
inspectorOpen = ref(false),
editMode = ref(false),
showTip = ref(true),
zoom = ref(1),
importInput = ref<HTMLInputElement>();
const scheme = computed(() =>
@@ -69,11 +68,6 @@ const library: { kind: IslandComponentKind; description: string }[] = [
{ kind: 'group', description: '将多个组件组合到一个组件中显示。' },
{ kind: 'stack', description: '将多个容器堆叠显示。' },
];
const messageLibrary: { kind: IslandComponentKind; description: string }[] = [
{ kind: 'notification', description: '显示班级收到的通知。' },
{ kind: 'homework', description: '显示班级作业提醒。' },
{ kind: 'call', description: '显示教师的叫人提醒。' },
];
const containers: readonly string[] = ['group', 'stack', 'slide', 'rolling'];
function id() {
return crypto.randomUUID();
@@ -773,34 +767,7 @@ function dropPreview(event: PointerEvent) {
</span>
</button>
</div>
<h4 class="message-library-title">班级消息</h4>
<div class="component-options message-options">
<button
v-for="item in messageLibrary"
:key="item.kind"
class="library-item"
:data-library-kind="item.kind"
:aria-label="`添加${ISLAND_COMPONENT_LABELS[item.kind]}`"
@pointerdown="beginDrag($event, { kind: item.kind, label: ISLAND_COMPONENT_LABELS[item.kind] })"
@click="add(item.kind)"
>
<ComponentIcon :kind="item.kind" />
<span>
<strong>{{ ISLAND_COMPONENT_LABELS[item.kind] }}</strong>
<span class="component-description">{{ item.description }}</span>
</span>
</button>
</div>
</section>
<div v-if="showTip" class="editor-tip" role="note">
<el-icon class="tip-icon"><InfoFilled /></el-icon>
<span>
<strong>编辑提示:</strong>
现在可以使用「编辑模式」更加直观地编辑主界面上的组件!
</span>
<el-button @click="editMode = !editMode">{{ editMode ? '退出编辑模式' : '进入编辑模式' }}</el-button>
<button class="dismiss-tip" aria-label="关闭编辑提示" @click="showTip = false">×</button>
</div>
</template>
<el-skeleton v-else :rows="8" animated />
<input ref="importInput" type="file" accept="application/json,.json" hidden @change="importScheme" />
@@ -5,6 +5,7 @@ import { ElMessage } from 'element-plus';
import { useRouter } from 'vue-router';
import {
DEFAULT_ISLAND_APPEARANCE,
defaultIslandLayouts,
ISLAND_APPEARANCE_RANGES as RANGES,
ISLAND_POSITION_LABELS,
ISLAND_POSITIONS,
@@ -30,6 +31,13 @@ function editLayout() {
void router.push('/settings/island/editor');
}
const layoutMode = ref<'fixed' | 'custom'>('fixed');
const layoutSettings = ref(defaultIslandLayouts());
const activeScheme = computed(() =>
layoutSettings.value.schemes.find((s) => s.id === layoutSettings.value.activeSchemeId)!,
);
const currentRadius = computed(() =>
layoutMode.value === 'custom' ? activeScheme.value.radius : island.value.radius,
);
const residentEnabled = ref(false);
const pointerFadeEnabled = ref(true);
const pointerFadeReversed = ref(false);
@@ -65,6 +73,7 @@ async function changePointerFade(
}
async function loadLayout() {
const settings = (await window.desktop?.getConfig())?.islandLayout;
if (settings) layoutSettings.value = settings;
layoutMode.value = settings?.layout ?? 'fixed';
residentEnabled.value = settings?.residentEnabled ?? false;
pointerFadeEnabled.value = settings?.pointerFadeEnabled ?? true;
@@ -103,6 +112,12 @@ async function loadIslandAppearance(): Promise<void> {
/** 改动即生效:属性变化时先应用(实时预览),点"保存"再落盘 */
function applyIslandAppearance(patch: Partial<IslandAppearance> = {}): void {
island.value = { ...island.value, ...patch };
if (layoutMode.value === 'custom' && patch.radius !== undefined) {
activeScheme.value.radius = patch.radius;
void window.desktop
?.saveConfig({ islandLayout: JSON.parse(JSON.stringify(layoutSettings.value)) })
.catch(() => ElMessage.error('圆角保存失败,请重试'));
}
window.desktop?.islandSetAppearance({ ...island.value });
}
@@ -230,9 +245,9 @@ onMounted(async () => {
@input="(value: number) => applyIslandAppearance({ width: value })"
/>
</el-form-item>
<el-form-item :label="`圆角 ${island.radius}px`">
<el-form-item :label="`圆角 ${currentRadius}px`">
<el-slider
:model-value="island.radius"
:model-value="currentRadius"
:min="RANGES.radius.min"
:max="RANGES.radius.max"
:step="1"
@@ -55,7 +55,7 @@ onMounted(loadGradeQuery);
<el-card shadow="never" class="lesson-channel-settings">
<template #header>上下课提醒</template>
<p class="text-muted">
沿用 ClassIsland 的遮罩、课前倒计时、上下课提示及下节课预告;课中显示课程进度,临近下课显示倒数。
课前倒计时、上下课提示及下节课预告保留遮罩;课中显示课程进度,临近下课在课程名右侧显示蓝色圆形秒数倒计时。
</p>
<div
v-for="channel in [
+2 -22
View File
@@ -9,7 +9,7 @@ import type {
* 主进程与渲染进程之间的桥接契约(preload 通过 contextBridge 暴露)。
* 渲染进程只依赖这些最小 API,不接触 Node.js。
*/
import type { IslandAppearance, IslandNotification, IslandState, UpdateInfo } from '@classhelper/shared';
import type { IslandAppearance, IslandNotification, IslandState } from '@classhelper/shared';
import type { ClientAgentStatus } from '../main/client-agent.js';
import type { IslandBridge } from '../preload/island.js';
@@ -55,12 +55,7 @@ export interface DesktopStoredConfig {
theme: 'light' | 'dark';
/** 主侧边栏是否折叠成图标栏(可由顶栏汉堡按钮切换) */
sidebarCollapsed: boolean;
/**
* 用户点过「忽略此版本」的版本号(空串 = 没忽略过)。
*
* 启动时的自动检查会跳过这个版本,避免每次开客户端都弹一次同样的提示;
* 在「关于」页手动检查时仍会正常显示结果。
*/
/** 旧版主动更新检查的兼容字段,不再影响云端下发更新。 */
ignoredUpdateVersion: string;
/**
* 本机设备标识(UUID):这台机器在服务端的身份。
@@ -159,21 +154,6 @@ export interface DesktopBridge {
getAppInfo(): Promise<DesktopAppInfo>;
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;
/* 灵动岛 */
getIslandWeather(coordinates: { latitude: number; longitude: number }): Promise<IslandWeather>;
/** 把一条通知投递到灵动岛(payload 必须是纯数据,说明见 saveConfig) */
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@classhelper/server",
"version": "1.4.4",
"version": "1.4.5",
"private": true,
"description": "ClassHelper后端服务:REST API + Socket.IO 实时推送 + Prisma 数据访问",
"//": "yaml:课表 YAML 导入的解析器(yaml@2,自带类型、无子依赖);仓库只有传递依赖 js-yaml,不要直接引用",
+10 -1
View File
@@ -437,11 +437,20 @@ try {
coursewareCategory('a.7z') === 'archive',
);
await restoreSnapshot(prisma, 'sqlite', snapshot);
const restoredFolders = await prisma.coursewareFolder.findMany();
check(
'恢复数据库后保留课件共享和回执数据',
(await prisma.courseware.count()) === 3 &&
(await prisma.coursewareReceipt.count()) === 1 &&
(await prisma.coursewareFolder.count()) === 1,
restoredFolders.length === snapshot.data.CoursewareFolder.length &&
snapshot.data.CoursewareFolder.every((expected) =>
restoredFolders.some(
(actual) =>
actual.id === expected.id &&
actual.path === expected.path &&
actual.teacherId === expected.teacherId,
),
),
);
console.log(`=== 课件隔离验收:${count}/${count} 项通过 ===`);
} finally {
+44 -6
View File
@@ -3223,7 +3223,8 @@ async function main() {
// 教师名单表格导入:教师预览 403;管理员预览 + 提交(教师与班级无关,classId 可省略)
const teacherCsv =
'\ufeff工号,姓名,初始密码,角色\n' +
`imp_t_${Date.now().toString().slice(-8)},冒烟导入教师,import123456,教师\n`;
`imp_t_${Date.now().toString().slice(-8)},冒烟导入教师,import123456,教师\n` +
`imp_t_${Date.now().toString().slice(-8)}_b,冒烟导入教师乙,import123456,教师\n`;
const teacherCsvBase64 = Buffer.from(teacherCsv, 'utf8').toString('base64');
const importedTeacherUsername = teacherCsv.split('\n')[1]?.split(',')[0] ?? '';
@@ -3250,7 +3251,10 @@ async function main() {
});
const importedTeacherLogin = await api('/auth/login', {
method: 'POST',
body: { username: importedTeacherUsername, password: 'import123456' },
body: {
username: importedTeacherUsername,
password: adminTeacherCommit.payload?.data?.credentials?.[0]?.password ?? '',
},
});
record(
'教师名单表格导入(教师 403 / 管理员预览+导入成功,且导入账号可登录)',
@@ -3258,13 +3262,47 @@ async function main() {
adminTeacherPreview.status === 200 &&
Boolean(adminTeacherPreview.payload?.data?.suggestedMapping?.username) &&
adminTeacherCommit.status === 200 &&
adminTeacherCommit.payload?.data?.inserted === 1 &&
adminTeacherCommit.payload?.data?.inserted === 2 &&
adminTeacherCommit.payload?.data?.credentials?.[0]?.password !== 'import123456' &&
importedTeacherLogin.status === 200,
`教师预览=${teacherPreviewDenied.status} 管理员预览=${adminTeacherPreview.status} ` +
`建议映射=${JSON.stringify(adminTeacherPreview.payload?.data?.suggestedMapping ?? {})} ` +
`导入新增=${adminTeacherCommit.payload?.data?.inserted ?? '-'} 登录=${importedTeacherLogin.status}`,
);
const importedCredentials = adminTeacherCommit.payload?.data?.credentials ?? [];
const repeatedImport = await api('/imports/table/commit', {
method: 'POST',
token: adminToken,
body: {
kind: 'teachers',
fileName: 'teachers.csv',
contentBase64: teacherCsvBase64,
mapping: { username: '工号', name: '姓名', role: '角色' },
mode: 'upsert',
},
});
const repeatLogin = await api('/auth/login', {
method: 'POST',
body: { username: importedTeacherUsername, password: importedCredentials[0]?.password ?? '' },
});
const importAudits = await api('/permissions/audit?pageSize=100', { token: adminToken });
const teacherImportAudits = (importAudits.payload?.data?.items ?? []).filter(
(item) => item.action === 'import-commitTeachers',
);
record(
'教师导入逐人生成随机密码,重复导入不重置且审计不含凭据',
importedCredentials.length === 2 &&
new Set(importedCredentials.map((c) => c.password)).size === 2 &&
importedCredentials.every((c) => c.password.length >= 16 && c.password !== 'import123456') &&
repeatedImport.payload?.data?.updated === 2 &&
repeatedImport.payload?.data?.credentials?.length === 0 &&
repeatLogin.status === 200 &&
teacherImportAudits.length > 0 &&
teacherImportAudits.every((item) => !/password|credentials/.test(item.afterJson)),
`凭据=${importedCredentials.length} 重复更新=${repeatedImport.payload?.data?.updated ?? '-'} 登录=${repeatLogin.status}`,
);
// 删除护栏:还是班主任的账号不允许删除;没有班级职责的可以删
const deleteHeadTeacher = teacher1
? await api(`/teachers/${teacher1.id}`, { method: 'DELETE', token: adminToken })
@@ -3661,10 +3699,10 @@ async function main() {
await api(`/classes/${probeClassId}`, { method: 'DELETE', token: adminToken });
}
}
const importedTeacherRow = (await api('/teachers', { token: adminToken })).payload?.data?.find(
(item) => item.username === importedTeacherUsername,
const importedTeacherRows = (await api('/teachers', { token: adminToken })).payload?.data?.filter((item) =>
importedCredentials.some((credential) => credential.username === item.username),
);
if (importedTeacherRow) {
for (const importedTeacherRow of importedTeacherRows ?? []) {
await api(`/teachers/${importedTeacherRow.id}`, { method: 'DELETE', token: adminToken });
}
const isProbeAccount = (username) =>
+39 -14
View File
@@ -1,6 +1,6 @@
import type { RequestHandler } from 'express';
import helmet from 'helmet';
import { rateLimit } from 'express-rate-limit';
import { ipKeyGenerator, rateLimit } from 'express-rate-limit';
import { env } from '../config/env.js';
import { logger } from '../lib/logger.js';
@@ -78,25 +78,50 @@ export function apiRateLimiter(): RequestHandler {
return limiter;
}
/** 登录接口专用限流:防暴力破解 */
/** 两种登录入口共用来源 IP:连续五次密码错误,从第五次失败起封禁五分钟。 */
export function loginRateLimiter(): RequestHandler {
return rateLimit({
windowMs: 10 * 60 * 1000,
limit: env.isProduction ? 20 : 200,
standardHeaders: 'draft-7',
legacyHeaders: false,
skipSuccessfulRequests: true,
skip: () => !env.rateLimitEnabled,
handler: (req, res) => {
logger.warn(`登录尝试过于频繁:${req.ip ?? '-'}`);
const duration = 5 * 60 * 1000;
const attempts = new Map<string, { failures: number; expiresAt: number; blockedUntil: number }>();
let sweepAt = 0;
return (req, res, next) => {
if (!env.rateLimitEnabled) return next();
const now = Date.now();
if (now >= sweepAt) {
for (const [key, attempt] of attempts) {
if (attempt.expiresAt <= now) attempts.delete(key);
}
sweepAt = now + 60_000;
}
const key = ipKeyGenerator(req.ip ?? req.socket.remoteAddress ?? 'unknown');
let attempt = attempts.get(key);
if (attempt && attempt.expiresAt <= now) {
attempts.delete(key);
attempt = undefined;
}
if (attempt && attempt.blockedUntil > now) {
res.setHeader('Retry-After', Math.ceil((attempt.blockedUntil - now) / 1000));
res.status(429).json({
success: false,
data: null,
message: '登录尝试过于频繁,请 10 分钟后再试',
message: '连续五次密码错误,已封禁登录 5 分钟,请稍后再试',
code: 'TOO_MANY_REQUESTS',
});
},
});
return;
}
res.once('finish', () => {
if (res.statusCode >= 200 && res.statusCode < 300) {
attempts.delete(key);
} else if (res.statusCode === 401) {
const finishedAt = Date.now();
const previous = attempts.get(key);
const failures = (previous && previous.expiresAt > finishedAt ? previous.failures : 0) + 1;
const blockedUntil = failures >= 5 ? previous?.blockedUntil || finishedAt + duration : 0;
attempts.set(key, { failures, blockedUntil, expiresAt: blockedUntil || finishedAt + duration });
if (failures === 5) logger.warn(`连续五次登录失败,封禁五分钟:${req.ip ?? '-'}`);
}
});
next();
};
}
/**
@@ -1,3 +1,4 @@
import { randomBytes } from 'node:crypto';
import { refreshClassSubscriptions } from '../../realtime/bus.js';
import { assertAdmin, assertManage, assertContentWrite } from '../../lib/authz/index.js';
import { changeStudentLifecycle, notifyStudentClasses } from '../../lib/student-lifecycle.js';
@@ -7,7 +8,6 @@ import * as XLSX from 'xlsx';
import { formatClassName, normalizeStudentNo, type TableImportKind } from '@classhelper/shared';
import { activeStudentWhere, isActiveStudent } from '../../lib/students.js';
import { prisma } from '../../lib/db.js';
import { env } from '../../config/env.js';
import { ApiError } from '../../lib/http.js';
import type { TokenPayload } from '../../lib/jwt.js';
import { logger } from '../../lib/logger.js';
@@ -98,7 +98,6 @@ export const IMPORT_FIELDS: Record<ImportKind, ImportField[]> = {
},
{ key: 'name', label: '姓名', required: true, synonyms: ['姓名', 'name', '教师', '教师姓名'] },
{ key: 'phone', label: '手机号', required: false, synonyms: ['手机号', '电话', 'phone', '联系方式'] },
{ key: 'password', label: '初始密码', required: false, synonyms: ['密码', 'password', '初始密码'] },
{
key: 'role',
label: '角色',
@@ -226,7 +225,7 @@ function parseTable(buffer: Buffer, fileName: string): ParsedTable {
const TEMPLATE_SAMPLES: Record<ImportKind, (string | number)[]> = {
grades: ['202601', '王小明', '期中考试', 92, 100, '数学', 'A'],
students: ['202601', '王小明', '2026级1班', '男', '13800000000'],
teachers: ['T1001', '王老师', '13800000000', 'teacher123', '教师'],
teachers: ['T1001', '王老师', '13800000000', '教师'],
classTeachers: ['2026级1班', '数学', 'T1001', '王老师', '科任'],
};
@@ -311,6 +310,7 @@ export interface ImportResult {
failed: number;
errors: ImportRowError[];
warnings: string[];
credentials?: { username: string; name: string; password: string }[];
}
function cellValue(row: string[], columns: string[], mapping: Record<string, string>, key: string): string {
@@ -677,6 +677,7 @@ export async function commitTeachers(user: TokenPayload, input: TableCommitInput
const errors: ImportRowError[] = [];
const warnings: string[] = [];
const credentials: NonNullable<ImportResult['credentials']> = [];
let inserted = 0;
let updated = 0;
let skipped = 0;
@@ -686,7 +687,6 @@ export async function commitTeachers(user: TokenPayload, input: TableCommitInput
const username = cellValue(row, parsed.columns, input.mapping, 'username');
const name = cellValue(row, parsed.columns, input.mapping, 'name');
const phone = cellValue(row, parsed.columns, input.mapping, 'phone');
const password = cellValue(row, parsed.columns, input.mapping, 'password');
const roleCell = cellValue(row, parsed.columns, input.mapping, 'role');
if (!username || !name) {
@@ -715,7 +715,7 @@ export async function commitTeachers(user: TokenPayload, input: TableCommitInput
});
updated += 1;
} else {
const initialPassword = password || env.defaultTeacherPassword;
const initialPassword = `Ch!${randomBytes(12).toString('base64url')}`;
await tx.user.create({
data: {
username,
@@ -726,6 +726,7 @@ export async function commitTeachers(user: TokenPayload, input: TableCommitInput
},
});
inserted += 1;
credentials.push({ username, name, password: initialPassword });
}
}
@@ -753,7 +754,7 @@ export async function commitTeachers(user: TokenPayload, input: TableCommitInput
afterJson: JSON.stringify(result),
},
});
return result;
return { ...result, credentials };
},
{ timeout: 30000 },
);
@@ -788,6 +789,7 @@ export async function commitClassTeachers(
const errors: ImportRowError[] = [];
const warnings: string[] = [];
const credentials: NonNullable<ImportResult['credentials']> = [];
let inserted = 0;
let updated = 0;
let skipped = 0;
@@ -877,19 +879,25 @@ export async function commitClassTeachers(
}
await assertPermission(user, 'teacher:manage');
await assertPermission(user, 'import:teachers');
const initialPassword = `Ch!${randomBytes(12).toString('base64url')}`;
const created = await tx.user.create({
data: {
username: teacherNo,
name: teacherName || teacherNo,
role: 'TEACHER',
passwordHash: await hashPassword(env.defaultTeacherPassword),
passwordHash: await hashPassword(initialPassword),
},
select: { id: true },
});
teacherId = created.id;
inserted += 1;
credentials.push({
username: teacherNo,
name: teacherName || teacherNo,
password: initialPassword,
});
warnings.push(
`第 ${rowNumber} 行:工号 ${teacherNo} 没有对应账号,已新建教师「${teacherName || teacherNo}」(初始密码见部署配置)`,
`第 ${rowNumber} 行:工号 ${teacherNo} 没有对应账号,已新建教师「${teacherName || teacherNo}」,请保存本次生成的随机密码`,
);
}
createdTeachers.set(teacherNo.toLowerCase(), teacherId);
@@ -947,7 +955,7 @@ export async function commitClassTeachers(
afterJson: JSON.stringify(result),
},
});
return result;
return { ...result, credentials };
},
{ timeout: 30000 },
)
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@classhelper/shared",
"version": "1.4.4",
"version": "1.4.5",
"private": true,
"description": "ClassHelper - 三端共享的类型、常量与工具函数",
"type": "module",
+2
View File
@@ -1313,6 +1313,8 @@ export interface TableImportResult {
failed: number;
errors: TableImportRowError[];
warnings: string[];
/** 仅在新建教师的导入响应中返回,供管理员一次性分发;不写审计记录。 */
credentials?: { username: string; name: string; password: string }[];
}
/** ClassIsland 时间配置条目 */
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@classhelper/ui",
"version": "1.4.4",
"version": "1.4.5",
"private": true,
"type": "module",
"exports": {
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@classhelper/web-admin",
"version": "1.4.4",
"version": "1.4.5",
"private": true,
"description": "ClassHelper Web 管理端(Vue 3 + Vite + Element Plus)",
"type": "module",
+4 -1
View File
@@ -39,7 +39,10 @@ instance.interceptors.response.use(
const status = error.response?.status;
const message = error.response?.data?.message ?? error.message ?? '网络请求失败';
if (status === 401) {
const loginAttempt =
error.config?.method?.toLowerCase() === 'post' &&
/\/auth\/(?:class-)?login\/?(?:\?|$)/.test(error.config?.url ?? '');
if (status === 401 && !loginAttempt) {
clearCalendarCache();
localStorage.removeItem(STORAGE_KEYS.token);
localStorage.removeItem(STORAGE_KEYS.user);
@@ -55,7 +55,6 @@ const FIELDS: Record<Kind, FieldDef[]> = {
{ key: 'username', label: '工号', required: true },
{ key: 'name', label: '姓名', required: true },
{ key: 'phone', label: '手机号', required: false },
{ key: 'password', label: '初始密码', required: false },
{ key: 'role', label: '角色', required: false },
],
classTeachers: [
@@ -72,7 +71,8 @@ const KIND_HINTS: Record<Kind, string> = {
grades: '按**学号**匹配本班学生;同一学生 + 科目 + 考试重复导入会覆盖旧分数。',
students:
'按**学号**去重;只生成班级名单,**不创建任何账号**(学生没有密码、不能登录)。班级列可留空,用上一步选的班级。',
teachers: '按**工号**去重;工号就是登录名。',
teachers:
'按**工号**去重;工号就是登录名。新教师分别生成随机密码,导入后请保存密码清单;已有账号密码保持不变。',
classTeachers:
'导入「班级 + 科目 + 教师」的任课关系。角色填「班主任」或「科任」;' +
'同一位老师既是班主任又教某一科时,写两条记录即可 —— 系统只保留一个账号,权限自动合并。',
@@ -279,6 +279,26 @@ async function submit(): Promise<void> {
committing.value = false;
}
}
function downloadCredentials(): void {
if (!result.value?.credentials?.length) return;
const cell = (value: string) =>
`"${(/^[=+@\-\t\r]/.test(value) ? `'${value}` : value).replaceAll('"', '""')}"`;
const rows = [
['工号', '姓名', '初始密码'],
...result.value.credentials.map((c) => [c.username, c.name, c.password]),
];
const url = URL.createObjectURL(
new Blob(['\ufeff' + rows.map((row) => row.map(cell).join(',')).join('\r\n')], {
type: 'text/csv;charset=utf-8',
}),
);
const link = document.createElement('a');
link.href = url;
link.download = '教师初始密码.csv';
link.click();
setTimeout(() => URL.revokeObjectURL(url), 1000);
}
</script>
<template>
@@ -396,6 +416,20 @@ async function submit(): Promise<void> {
<span>跳过:{{ result.skipped }}</span>
<span class="bad">失败:{{ result.failed }}</span>
</div>
<template v-if="result.credentials?.length">
<el-alert
type="warning"
:closable="false"
class="mt-8"
title="随机密码仅在本次导入结果中显示,请在关闭前下载并分发给对应教师。"
/>
<el-button class="mt-8" @click="downloadCredentials">下载教师密码清单</el-button>
<el-table :data="result.credentials" size="small" max-height="240" class="mt-8">
<el-table-column prop="username" label="工号" />
<el-table-column prop="name" label="姓名" />
<el-table-column prop="password" label="初始密码" />
</el-table>
</template>
<el-table
v-if="result.errors.length"
:data="result.errors"