Compare commits

..
Author SHA1 Message Date
Morris 631a90e862 Linux 产物改为默认不构建(云端可显式开启)
- Linux 目标平台是 arm64,而官方 Flutter 引擎只有 x64 产物,x64 主机编出来的包
  在 arm 机器上跑不起来
- 默认跳过并打印一行提示;GC_BUILD_LINUX=1 ./build.sh build 可显式开启
  (云端 aarch64 runner 用这个开关,代码路径与打包逻辑都保留)
- 清单里的 linux-arm64 条目继续保留:没有产物就没有 sha256,下载端会跳过该平台

验证:./build.sh build 只产 GCL-1.0.10-win-{amd64,arm64}.zip,与开启前一致。
2026-11-18 20:41:35 +08:00
Morris 40af11f78a Merge pull request '1.0.10:启用 GCL 命名,Linux 构建改为 arm64' (#13) from release/1.0.10-gcl into main
Reviewed-on: Morris/GC#13
2026-11-18 12:39:50 +00:00
Morris 4bcffa782d 1.0.10:启用 GCL 命名,Linux 构建改为 arm64
命名
- 发布包统一 GCL-<版本>-<平台>:zip 名、包内启动器、清单 path/name/url 同步
- 旧 GC- 包仍识别(IsLauncherPackage / VersionUtil / SAVEDOG 主程序正则),
  装过 1.0.9 的机器不会把新包判成「不是启动器包」

Linux
- 构建目标由 linux-amd64 改为 linux-arm64,清单平台表同步
- Flutter Linux 引擎只有 x64 官方产物:aarch64 主机读
  build/linux/arm64/release/bundle;x64 主机明确跳过并说明原因,
  不产出装不上 arm 机器的 x64 包
- LabelOf 保留 linux-x64 -> linux-amd64 别名,读得懂历史产物

版本
- Directory.Build.props 1.0.9 -> 1.0.10,version.json / model/version.json 重签

验证
- ./build.sh build:GCL-1.0.10-win-amd64.zip 71MB、GCL-1.0.10-win-arm64.zip 69MB,
  均为单顶层目录 + 包内 safedog/ + Flutter 前端
- GC.Tests --update-test 全部通过
2026-11-18 20:38:29 +08:00
Morris 097bfd198e Merge pull request '发布包改为 GCL 单目录布局,.GC 增加 safedog 与中英双语日志' (#11) from feat/gcl-package-layout into main
Reviewed-on: Morris/GC#11
2026-11-18 12:27:27 +00:00
Morris 31b0c93b25 发布包改为 GCL 单目录布局,.GC 增加 safedog 与中英双语日志
包结构
- 压缩包内只有一个顶层目录 GCL-<版本>-<平台>/,解压后不再散落一屏 dll
- 启动器改名为 GCL-<版本>-<平台>(.exe),Flutter 前端与后端仍在同一目录
- 守护进程移入包内 safedog/,运行时复制到 .GC/safedog

运行目录
- .GC 新增 safedog/:实际运行守护进程,整目录替换永远不会覆盖正在运行的它
- .GC 新增 logs/:按天写 gc-YYYYMMDD.log(中文)与 gc-YYYYMMDD.en.log(英文)
- 启动器、后端、SAVEDOG 共用同一组日志文件,整条启动/更新链路可一起排查

更新链路
- 包名/目录统一 GCL- 前缀,同时兼容旧 GC- 包(可从旧版本升级)
- 更新包解压后展平单顶层目录,仍按整目录替换安装
- Linux 无扩展名启动器仍可识别,兼容脚本清理旧版时覆盖 GCL-*

验证
- ./build.sh build 通过,产物 GCL-1.0.9-{win-amd64,win-arm64,linux-amd64}.zip
- 实跑 Linux 包:.GC/safedog/GC-SAVEDOG 与 .GC/logs/gc-20261118[.en].log 均生成
- GC.Tests --update-test 全部通过
2026-11-18 20:27:06 +08:00
Morris 39dc23cb57 Merge pull request '修复审计问题:整目录更新、主题与轮询、移除 nightly' (#10) from fix/audit-cleanup into main
Reviewed-on: Morris/GC#10
2026-11-18 12:18:10 +00:00
Morris a361c889f8 修复审计发现的问题,默认构建即带 Flutter 前端
P0
- GC-SAVEDOG:更新改为整目录替换(旧文件备份到 .GC/update/backup,
  失败可完整回滚),不再只搬一个 exe;回滚会删掉新包独有文件
- GC-SAVEDOG:包名校验放宽为单文件名模式,Linux 启动器(无扩展名)可更新
- GC-DOWNLOAD:测速全失败时不再回退 GitCode,改为返回「不可用」并保留上次可用源
- GC-DOWNLOAD:识别并赋予 Linux 无扩展名启动器可执行位;兼容脚本清理旧版时
  也覆盖无扩展名产物
- CI:删除 nightly-prerelease(绕开 build.sh,产出无前端空壳);alpha 工作流
  去掉非法 cron,只保留手动触发

P1
- 前端:主题设置真正生效(深色/浅色/跟随系统 + 持久化),去掉死字段
- 前端:下载页轮询改为自适应单次链,页面不可见或任务结束后降频/停止
- 前端:下载完成 / 删除模型后首页列表自动刷新
- 前端:复用 http.Client,不再每次轮询新建连接
- 后端:/api/models 走缓存,不再每次全盘递归统计体积
- 设置页:外部改动能同步进表单,不再只同步一次

P2
- 错误响应统一为 ErrorDto,不再复用 LaunchResultDto
- 限流桶定期清理,避免无限增长
- 播放器窗口去重,避免同一模型重复开窗
- 封面按实际格式返回,去掉错误的 image/png 与 no-store
- 端口集中到 GcUiContract,前端可用 GC_UI_PORT 或 ui-backend.json 发现后端
- 构建:Windows 包改为散开发布,与后端共用运行时(体积约 109MB -> 72MB)
- 文档:更新仓库地址与更新流程说明

测试:dotnet build 全绿;GC.Tests 更新链路全通过;flutter analyze 无问题;
flutter test 11 项全通过。
2026-11-18 20:10:03 +08:00
Morris 461e79aa7f Merge pull request 'build: 默认编 Flutter 前端,补 Linux 目标并按主机选择产物' (#9) from feat/flutter-default into main
Reviewed-on: Morris/GC#9
2026-11-18 11:23:16 +00:00
Morris d7f6d8de9f build: 默认编 Flutter 前端,补 Linux 目标并按主机选择产物
此前 build.sh 在非 Windows 宿主上把前端当「可选项」:flutter 缺失只告警、
交叉编译失败只告警、macOS 前端在 Linux 上直接跳过。结果是包照出,用户拿到
的是 Avalonia 回退界面,而构建日志里一行红字很容易被忽略。

改为默认必需:
- build_flutter_ui / build_flutter_ui_cross 缺 flutter 或编译失败一律返回非 0,
  build.sh 立即中断并给出原因(交叉编译失败时带日志尾巴)
- 确实要出降级包时显式声明 ./build.sh build --allow-no-ui

目标平台按构建主机决定,每条产物都带 Flutter:
  macOS 主机 → mac-arm64(Xcode 原生)+ win-amd64/win-arm64(mingw 交叉)
  Linux 主机 → linux-amd64(原生)+ win-amd64/win-arm64(mingw 交叉)
  Windows 主机 → win-amd64/win-arm64(原生)

Linux 目标此前根本不存在,这次一并补上:
- GC-UI/frontend/linux/ 由 flutter create 生成,BINARY_NAME=GC-UI、
  APPLICATION_ID=com.xhmcl.GC、窗口标题 "Morris GC"
- build_flutter_ui 增加 linux 分支,bundle(GC-UI + lib/ + data/)铺进
  dist/linux-amd64/,pack_launcher 增加 Linux 整目录打包
- linux/CMakeLists.txt 强制 CMAKE_INSTALL_PREFIX 指向 build/.../bundle:
  某些环境下它会被初始化成 /usr/local,导致 flutter 报「构建成功」但
  bundle 是空的、产物装进了系统目录(本机实测踩到)

顺带修正两处:
- 生成 settings.json 的默认 updateRepository 还是 gitcode 地址,与只保留
  xhmcl 源的现状不符
- 进度条权重改为按实际目标动态计算,新平台不会再把总进度算过 100%

验证(Linux 主机,flutter 3.24.5):
- ./build.sh build 出 win-amd64 109 MB、win-arm64 105 MB、linux-amd64 65 MB,
  三份均含 Flutter 前端,清单签名 Verified
- Linux 包在 Xvfb + llvmpipe 下实跑:后端 /api/health 返回 ok,GC-UI 窗口
  正常渲染出模型库首页
- macOS 目标在 Linux 上不再产出 Avalonia 空壳包(要它得回 macOS 编)
2026-11-18 19:15:05 +08:00
Morris 7e34cb0467 Merge pull request 'fix(update): 换发清单签名密钥,补齐 1.0.9 已签名清单' (#8) from feat/manifest-signing into main
Reviewed-on: Morris/GC#8
2026-11-18 10:41:20 +00:00
Morris e327a56421 fix(update): 换发清单签名密钥,补齐 1.0.9 已签名清单
仓库里硬编码的公钥 gc-2026-11 没有对应的私钥(.signing/ 在 .gitignore 里,
私钥从来没入过库,也无法找回),导致 build.sh 每次签名都失败,version.json
始终是「未签名」。而客户端默认 RequireSignedManifest=true,未签名清单一律
拒绝更新 —— 自动更新实际上完全不可用。

改动:
- keygen 生成新密钥 gc-2026-12(指纹 ee6083be47a87907),公钥写进
  SignatureKeyring;旧 gc-2026-11 保留一个版本周期,标注为「私钥遗失、已停用」
- GC-SAVEDOG 的 DefaultKeyId 与 build_funcs.sh 的 GC_SIGNING_KEY_ID 默认值
  同步改为 gc-2026-12,避免 keyId 与私钥不匹配又签出 Invalid
- GC.Tests 构造可信清单时用的 keyId 改为 gc-2026-12(原来硬编码旧 keyId,
  换钥匙后会判成 Invalid)
- README 补上密钥轮换的实际步骤与「换钥匙老客户端就更新不了」的代价
- Directory.Build.props 版本 1.0.7 → 1.0.9(此前只靠 -version 传参,
  仓库里一直停在 1.0.7,与实际发布脱节)
- version.json / model/version.json 换成 1.0.9 且带 gc-2026-12 签名,
  两份字节一致

验证:
- GC.Tests --update-test 全通过,日志里是「清单验签通过(gc-2026-12)」,
  篡改清单被判 Invalid 并拒绝更新
- GC-SAVEDOG verify --manifest version.json → Verified
- 三平台重新出包:win-amd64 109 MB、win-arm64 105 MB、mac-arm64 57 MB

注意:1.0.8 及更早的客户端只认识旧公钥,这份清单在它们眼里是「签名无效」,
与之前的「未签名」等价 —— 都不会自动更新。要让自动更新真正生效,需要把
带新公钥的 1.0.9 发出去。
2026-11-18 18:20:32 +08:00
Morris 40e72957e3 Merge pull request 'build: 支持在 Linux/macOS 上交叉编译 Windows 前端' (#7) from feat/win-cross-compile into main
Reviewed-on: Morris/GC#7
2026-11-18 10:09:49 +00:00
Morris fdbf3160e8 fix(update): 更新清单指向 xhmcl 仓库,下载地址与 tag 对齐
VersionStamp 里硬编码的仓库地址还是 gitcode.com/Morris_1/GC,与启动器
AppSettings.UpdateRepository 的默认值(git.xhmcl.com/Morris/GC)不一致,
导致生成的 version.json 把客户端导到一个没有对应 Release 的仓库。

同时下载地址拼的是 /download/v{版本}/,而实际 tag 没有 v 前缀
(1.0.7、1.0.8),两者对不上会 404。

改为读同一仓库地址并去掉 v 前缀,同时把当前 1.0.8 的清单同步过来
(sha256 沿用本次构建产物,未重算)。
2026-11-18 13:54:15 +08:00
Morris 2cc862a8da Merge pull request '启动器接入 Flutter 前端 · 公司信息统一 Morris · 模型版本 +1' (#6) from feat/flutter-ui into main
Reviewed-on: Morris/GC#6
2026-11-18 05:47:39 +00:00
Morris 2c0c566c81 build: 支持在 Linux/macOS 上交叉编译 Windows 前端
此前 Windows 包内不含 Flutter 界面,只能回退到内置 Avalonia 界面,
原因是 Flutter 官方不支持在非 Windows 主机上执行 flutter build windows。

实际上 Windows 嵌入层(windows/runner + cpp_client_wrapper)是纯 Win32
加标准 C++,只通过 C ABI 调用 flutter_windows.dll,因此用 mingw-w64 即可
编译。整条链路上唯一必须执行的 Windows 二进制是 AOT 快照生成器
gen_snapshot.exe,交给 wine 运行即可。全流程不需要 Windows 机器或 MSVC。

实现:
- buildsh/cross/toolchain-mingw.cmake  CMake 交叉工具链,posix 线程模型,
  静态链接 libstdc++/libgcc,产物只依赖系统 DLL 和 flutter_windows.dll
- buildsh/cross/CMakeLists.txt         只编 C++ 外壳,绕开 tool_backend.bat
  与 MSVC 专用编译参数
- buildsh/cross/build-ui-win-cross.sh  拉取引擎产物、为 gen_snapshot 装 wine
  包装、生成 AOT 快照、组装出与官方 toolchain 一致的目录结构
- build_flutter_ui_cross / build.sh    非 Windows 主机走交叉编译分支,
  x64 产物同时放进 win-amd64 与 win-arm64 两个包

顺带修掉 shell.dart 的常量求值错误:强调色改为跟随设置的动态 getter 后,
const Text 里引用 GcColors.accent 会让编译器报错。

已在 Linux 上用 wine 验证产物:Flutter 引擎正常初始化,Dart AOT 快照加载
并执行到业务代码,后端 /api/health 正常返回。
2026-11-18 13:29:53 +08:00
Morris 926a568dc0 Merge branch 'main' into feat/flutter-ui 2026-11-18 04:37:15 +00:00
Morris cd44c7ecff feat(ui): 启动器接入 Flutter 前端 · 公司名统一 Morris · 模型版本 +1
- GC-BOOT 新增 FlutterShell:随包带 GC.UI.Server 与 GC-UI 时,拉起「本地后端 + Flutter 窗口」,界面退出后一起收尾;缺任一产物则回退内置 Avalonia 界面
- 构建脚本新增 publish_backend(三平台发布 UI 后端)与 build_flutter_ui(宿主平台构建 Flutter 桌面产物)
- Windows 打包由「单文件 exe」改为整目录,包含启动器、GC-SAVEDOG、UI 后端与可选 Flutter 产物
- Flutter 工程:Windows BINARY_NAME 与 macOS PRODUCT_NAME 改为 GC-UI,窗口标题 Morris GC
- 公司信息:Windows CompanyName/LegalCopyright、macOS PRODUCT_COPYRIGHT 统一为 Morris
- 模型版本末位 +1:contour-map 1.1 / earth-geography 1.9 / earth-revolution 1.7 / earth-rotation 1.7 / scale-calculator 1.6,并重算清单哈希
2026-11-18 12:36:21 +08:00
Morris aeab68d421 Merge pull request 'chore: 彻底移除 NeoRF 标识(命名空间 / 作者 / Bundle ID)' (#5) from chore/remove-neorf into main
Reviewed-on: Morris/GC#5
2026-11-17 22:55:44 +00:00
Morris 0b2f263dea chore: 彻底移除 NeoRF 标识,统一为 GC / Morris
- 命名空间 NeoRF.EarthModels / NeoRF.ContourMap / NeoRF.ScaleCalculator
  改为 GC.EarthModels / GC.ContourMap / GC.ScaleCalculator
- 模型清单 type 字段同步更新,五个模型 DLL 全部重新编译并替换
- 程序集 Company 由 NeoRF 改为 Morris
- 模型作者 author 统一为 Morris(原 NeoRF / Morris GC)
- macOS 包标识 cn.neorf.GC 改为 com.xhmcl.GC
- 重算 version.json 与 model/version.json 的 build / manifestSha256 / filesSha256
2026-11-18 06:55:10 +08:00
Morris a18d0ea1a8 Merge pull request '关于页开发者改为读取仓库真实提交者(身份归并 + 排除自动化账号)' (#4) from fix/about-contributors into main
Reviewed-on: Morris/GC#4
2026-11-17 22:52:38 +00:00
Morris 06eb4875a1 fix(about): 开发者改为读取仓库真实提交者
- ContributorsService 改用 /commits 分页统计,不再依赖需要登录的 /collaborators
- 同一人的多个 git 身份按别名归并(Morris_1 / 2509_92447106 / 两个邮箱)
- 自动化提交(agent@teamily.ai)不计入开发者,避免出现在关于页
- 关于页「开发者」标题标注数据来源,贡献数为真实提交数
- 结果缓存 10 分钟;接口失败时静默降级为空列表,不影响关于页其它内容
2026-11-18 00:23:48 +08:00
Morris 2b4ffc7ce5 Merge pull request 'ci(GC-UI): 夜间 alpha 构建工作流(Windows/macOS,21:00 定时,prerelease)' (#2) from gc-ui into main
Reviewed-on: Morris/GC#2
2026-11-17 16:10:36 +00:00
Morris d379902a7a ci: artifact 上传降为 v3,兼容 Gitea Actions 2026-11-17 23:55:21 +08:00
Morris 056d64a3bc Merge pull request 'UI 体验与启动优化 · 主题色 · Gitea CI/夜间预发布 · 后端安全加固' (#3) from feat/ui-perf-ci-security into main
Reviewed-on: Morris/GC#3
2026-11-17 15:53:19 +00:00
Morris ae73eca2c4 UI 体验与启动优化 · 主题色 · Gitea CI/夜间预发布 · 后端安全加固
- 启动:健康检查与设置并行请求,页面按需构建并 Offstage 保活,封面按展示尺寸解码
- UI:模型卡片增加悬停动效、封面渐变遮罩、版本/作者/标签胶囊,空简介占位
- 主题:设置页新增主色调选择(预设 + 自定义 #RRGGBB),前后端持久化并实时生效
- CI:新增 PR 审核流水线(后端编译/自检、Flutter 分析测试、漏洞与密钥扫描、汇总门禁)
- CI:新增每晚 21:00(UTC 13:00)预发布流水线,prerelease 且不设为 Latest,先删旧再建新
- 安全:后端新增安全响应头、Host/Origin 校验、写入限流、请求体上限、ID 与设置白名单、错误信息脱敏
- 源:暂时只启用 Xhmcl;GitCode 实现保留但不再调用,旧配置自动迁移
2026-11-17 23:50:54 +08:00
Morris 3480cbaa5f Merge pull request 'GC-UI:前后端分离,前端改用 Flutter(Windows/macOS)' (#1) from gc-ui into main
Reviewed-on: Morris/GC#1
2026-11-17 14:18:07 +00:00
112 changed files with 3897 additions and 735 deletions

No files matched your search

+10 -14
View File
@@ -1,9 +1,9 @@
# GC-UI 夜间 alpha 构建(Gitea Actions) # GC-UI alpha 构建(Gitea Actions)
# #
# 触发:每天 21:00(Asia/Shanghai)自动跑一次,产出 Windows 与 macOS 的 Flutter 前端产物, # 触发:**仅手动**。定时任务已取消(不再每天自动构建),需要时在 Actions 页面点
# 发布为一个「预览版(prerelease)」Release —— 不占用 latest。 # Run workflow,或从命令行调
# 手动:Actions 页面点 Run workflow(Gitea 的 workflow_dispatch),用于验证 runner 是否就绪; # POST /api/v1/repos/{owner}/{repo}/actions/workflows/{file}/dispatches。
# 也可以从命令行调 POST /api/v1/repos/{owner}/{repo}/actions/workflows/{file}/dispatches。 # 产物:Windows 与 macOS 的 Flutter 前端,发布为一个「预览版(prerelease)」Release —— 不占用 latest。
# #
# 为什么是 .gitea/workflows/:本仓库是自建 Gitea,不是 GitHub。Gitea Actions 语法与 # 为什么是 .gitea/workflows/:本仓库是自建 Gitea,不是 GitHub。Gitea Actions 语法与
# GitHub Actions 基本一致,但工作流目录是 .gitea/workflows/,API 前缀是 /api/v1, # GitHub Actions 基本一致,但工作流目录是 .gitea/workflows/,API 前缀是 /api/v1,
@@ -16,12 +16,8 @@
name: GC-UI Alpha name: GC-UI Alpha
on: on:
schedule: # 定时触发已取消:夜间构建会绕开 build.sh,产出不含后端/前端的空壳包,
# 每天晚上 21:00,北京时间。 # 且 cron 的 TZ= 前缀在部分 Gitea 版本上非法。需要时手动 dispatch。
# Gitea 1.23 起 Actions 的 cron 默认按 UTC 解释,这里显式带 TZ= 前缀(robfig/cron 支持的
# 时区前缀语法),这样不依赖服务器自身时区设置。
# 如果所在实例不认 TZ= 前缀,改用等效的 UTC 写法 '0 13 * * *'。
- cron: 'TZ=Asia/Shanghai 0 21 * * *'
workflow_dispatch: workflow_dispatch:
inputs: inputs:
note: note:
@@ -67,7 +63,7 @@ jobs:
exit 1 exit 1
fi fi
# 北京时间当天日期,让产物名和 tag 与「每晚 9 点」对得上 # 北京时间当天日期,让同一天的多次手动构建落在同一个日期前缀下
DATE=$(TZ=Asia/Shanghai date +%Y%m%d) DATE=$(TZ=Asia/Shanghai date +%Y%m%d)
# 同一天重跑时用 run_number 区分,tag 不重复 # 同一天重跑时用 run_number 区分,tag 不重复
VERSION="${BASE}-alpha.${DATE}.${{ github.run_number }}" VERSION="${BASE}-alpha.${DATE}.${{ github.run_number }}"
@@ -122,11 +118,11 @@ jobs:
tag, version, sha, server = sys.argv[1:5] tag, version, sha, server = sys.argv[1:5]
short = sha[:7] short = sha[:7]
body = ( body = (
"GC-UI 夜间 alpha 构建(自动生成,**预览版 / prerelease**)。\n\n" "GC-UI alpha 构建(手动触发,**预览版 / prerelease**)。\n\n"
"- 版本:`%s`\n" "- 版本:`%s`\n"
"- 提交:`%s`\n" "- 提交:`%s`\n"
"- 构建来源:%s/commit/%s\n" "- 构建来源:%s/commit/%s\n"
"- 通道:alpha —— 每晚 21:00(Asia/Shanghai)自动构建\n\n" "- 通道:alpha —— 手动触发(定时任务已取消)\n\n"
"产物说明:\n\n" "产物说明:\n\n"
"| 文件 | 平台 | 内容 |\n" "| 文件 | 平台 | 内容 |\n"
"|---|---|---|\n" "|---|---|---|\n"
+140
View File
@@ -0,0 +1,140 @@
# ---------------------------------------------------------------------------
# PR 审核流水线(Gitea Actions)
#
# 触发:向 main / gc-ui 提 PR(新建、追加提交、重新打开、取消草稿)时执行。
# 覆盖:后端编译、后端自检、前端静态分析 / 测试、依赖漏洞与硬编码密钥扫描,
# 最后用 review-gate 汇总,任意一项失败则整条流水线失败(阻止合并)。
# ---------------------------------------------------------------------------
name: PR 审核
on:
pull_request:
branches: [main, gc-ui]
types: [opened, synchronize, reopened, ready_for_review]
concurrency:
group: pr-check-${{ github.event.pull_request.number }}
cancel-in-progress: true
env:
# Avalonia 遥测任务在 CI 只读目录会写日志失败并中断编译(MSB4018)
AVALONIA_TELEMETRY_OPTOUT: '1'
DOTNET_NOLOGO: '1'
DOTNET_CLI_TELEMETRY_OPTOUT: '1'
jobs:
backend-build:
name: 后端编译
runs-on: ubuntu-latest
steps:
- name: 检出代码
uses: actions/checkout@v4
- name: 安装 .NET 8
uses: actions/setup-dotnet@v4
with:
dotnet-version: '8.0.x'
- name: 还原依赖
run: dotnet restore GC.sln
- name: 编译整个解决方案(Release)
run: dotnet build GC.sln -c Release --no-restore
- name: 编译 GC-UI 后端(前后端契约变更时单独验证)
run: dotnet build GC-UI/backend/GC.UI.Server/GC.UI.Server.csproj -c Release --no-restore
backend-test:
name: 后端自检
runs-on: ubuntu-latest
needs: backend-build
steps:
- name: 检出代码
uses: actions/checkout@v4
- name: 安装 .NET 8
uses: actions/setup-dotnet@v4
with:
dotnet-version: '8.0.x'
- name: 运行 GC.Tests(含离屏渲染 / 清单校验)
run: dotnet run --project GC/src/test/dotnet/GC.Tests/GC.Tests.csproj -c Release
frontend:
name: 前端检查(Flutter)
runs-on: ubuntu-latest
steps:
- name: 检出代码
uses: actions/checkout@v4
- name: 安装 Flutter
uses: subosito/flutter-action@v2
with:
channel: stable
cache: true
- name: 拉取依赖
working-directory: GC-UI/frontend
run: flutter pub get
- name: 静态分析
working-directory: GC-UI/frontend
run: flutter analyze --no-fatal-infos --no-fatal-warnings
- name: 单元 / 组件测试
working-directory: GC-UI/frontend
run: flutter test
security:
name: 安全扫描
runs-on: ubuntu-latest
steps:
- name: 检出代码
uses: actions/checkout@v4
- name: 安装 .NET 8
uses: actions/setup-dotnet@v4
with:
dotnet-version: '8.0.x'
- name: 依赖漏洞扫描(含传递依赖)
run: |
dotnet restore GC.sln
dotnet list GC.sln package --vulnerable --include-transitive
- name: 硬编码密钥 / 口令扫描
run: |
set +e
echo "扫描源码中的疑似明文口令 / 令牌…"
MATCHES=$(grep -rInE \
--include='*.cs' --include='*.dart' --include='*.yml' --include='*.yaml' \
--include='*.sh' --include='*.ps1' --include='*.json' \
'(password|passwd|secret|api[_-]?key|access[_-]?token)[[:space:]]*[:=][[:space:]]*["'\''][^"'\''[:space:]]{6,}' \
. 2>/dev/null | grep -vE 'example|placeholder|dummy|CHANGEME|YOUR_|\$\{\{')
if [ -n "$MATCHES" ]; then
echo "$MATCHES"
echo "::error::发现疑似硬编码凭据,请改用 Secrets 或环境变量"
exit 1
fi
echo "未发现硬编码凭据"
review-gate:
name: 审核汇总
runs-on: ubuntu-latest
needs: [backend-build, backend-test, frontend, security]
if: always()
steps:
- name: 检查各阶段结果
run: |
echo "后端编译: ${{ needs.backend-build.result }}"
echo "后端自检: ${{ needs.backend-test.result }}"
echo "前端检查: ${{ needs.frontend.result }}"
echo "安全扫描: ${{ needs.security.result }}"
if [ "${{ needs.backend-build.result }}" != "success" ] || \
[ "${{ needs.backend-test.result }}" != "success" ] || \
[ "${{ needs.frontend.result }}" != "success" ] || \
[ "${{ needs.security.result }}" != "success" ]; then
echo "::error::审核未通过:存在失败阶段,请修复后重新提交"
exit 1
fi
echo "审核通过:可以合并"
+3
View File
@@ -51,3 +51,6 @@ GC-UI/frontend/**/DebugProfile.entitlements.bak
GC-UI/frontend/**/*.iml GC-UI/frontend/**/*.iml
GC-UI/frontend/test/shots/ GC-UI/frontend/test/shots/
# GC.Tests 离屏渲染输出(dotnet run ... GC.Tests 默认写到仓库根 screenshots/)
screenshots/
+2 -2
View File
@@ -22,8 +22,8 @@
--> -->
<AvaloniaVersion>11.3.9</AvaloniaVersion> <AvaloniaVersion>11.3.9</AvaloniaVersion>
<MvvmVersion>8.2.2</MvvmVersion> <MvvmVersion>8.2.2</MvvmVersion>
<Version>1.0.7</Version> <Version>1.0.10</Version>
<Company>NeoRF</Company> <Company>Morris</Company>
<Product>GC</Product> <Product>GC</Product>
<NeutralLanguage>zh-Hans</NeutralLanguage> <NeutralLanguage>zh-Hans</NeutralLanguage>
</PropertyGroup> </PropertyGroup>
+197
View File
@@ -0,0 +1,197 @@
using System;
using System.Diagnostics;
using System.IO;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
namespace GC;
/// <summary>
/// 新界面启动壳。
///
/// 发布包同时带 <c>GC.UI.Server</c>(本地 HTTP 后端 + 模型窗口宿主)和
/// <c>GC-UI</c>(Flutter 前端)时,启动器只做三件事:
/// 1. 拉起后端并等 <c>/api/health</c> 就绪;
/// 2. 拉起 Flutter 窗口;
/// 3. 界面退出后关掉后端。
///
/// 两个产物缺任意一个就返回 <c>false</c>,由调用方回退到内置 Avalonia 界面——
/// 这样 `dotnet run`、只编了启动器的开发场景、以及交叉编译缺前端产物的包都能正常打开。
/// </summary>
internal static class FlutterShell
{
/// <summary>与前端、后端共用的默认端口(定义在 GC.Services.GcUiContract)。</summary>
private const int Port = Services.GcUiContract.DefaultPort;
private static readonly HttpClient Http = new() { Timeout = TimeSpan.FromSeconds(1.5) };
private static Process? _backend;
public static bool TryRun(string[] args)
{
var dir = AppContext.BaseDirectory;
var backendPath = FindBackend(dir);
var uiPath = FindUi(dir);
if (backendPath == null || uiPath == null) return false;
// 用户可能重复启动:已有后端在跑就直接复用,退出时也不要关掉别人的进程。
var port = Port;
if (!IsHealthy(port))
{
// 端口可能被别的程序占用:17890 起向后试几个,选第一个能起来且健康的。
var start = Environment.GetEnvironmentVariable(Services.GcUiContract.PortEnvVar) is { Length: > 0 }
? Services.GcUiContract.PortFromEnvironment()
: Port;
for (var candidate = start; candidate < start + Services.GcUiContract.PortScanRange; candidate++)
{
var process = Start(backendPath, $"--port {candidate}", dir);
if (process == null) continue;
if (WaitHealthy(candidate, process, TimeSpan.FromSeconds(25)))
{
port = candidate;
_backend = process;
break;
}
Stop(process);
}
if (_backend == null) return false;
}
AppDomain.CurrentDomain.ProcessExit += (_, _) => Stop(_backend);
var ui = Start(uiPath, null, dir, port);
if (ui == null)
{
Stop(_backend);
_backend = null;
return false;
}
ui.WaitForExit();
Stop(_backend);
_backend = null;
return true;
}
// ---------------------------------------------------------------- 产物定位
private static string? FindBackend(string dir)
{
foreach (var name in OperatingSystem.IsWindows()
? new[] { "GC.UI.Server.exe", "GC.UI.Server" }
: new[] { "GC.UI.Server", "GC.UI.Server.exe" })
{
var path = Path.Combine(dir, name);
if (File.Exists(path)) return path;
}
return null;
}
/// <summary>
/// Flutter 桌面产物。
/// macOS 是 <c>GC-UI.app/Contents/MacOS/GC-UI</c>;Windows 是 <c>GC-UI.exe</c>;
/// Linux 是 <c>GC-UI</c>。
/// </summary>
private static string? FindUi(string dir)
{
if (OperatingSystem.IsMacOS())
{
var exe = Path.Combine(dir, "GC-UI.app", "Contents", "MacOS", "GC-UI");
if (File.Exists(exe)) return exe;
}
foreach (var name in OperatingSystem.IsWindows() ? new[] { "GC-UI.exe" } : new[] { "GC-UI" })
{
var path = Path.Combine(dir, name);
if (File.Exists(path)) return path;
}
return null;
}
// ---------------------------------------------------------------- 进程管理
private static Process? Start(string fileName, string? arguments, string workingDirectory, int port = 0)
{
try
{
var info = new ProcessStartInfo(fileName)
{
WorkingDirectory = workingDirectory,
UseShellExecute = false,
CreateNoWindow = true,
};
if (!string.IsNullOrEmpty(arguments)) info.Arguments = arguments;
// 把实际端口传给子进程:后端读它监听,前端读它拼 baseUrl。
// 这样换端口不需要重新编译前端。
if (port > 0)
info.Environment[Services.GcUiContract.PortEnvVar] = port.ToString();
// macOS .app 内的二进制也需要可执行位;发布包由 zip 解开时可能丢失。
if (!OperatingSystem.IsWindows())
{
try { File.SetUnixFileMode(fileName, UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute); }
catch { /* 权限不足时交给系统判断 */ }
}
return Process.Start(info);
}
catch (Exception ex)
{
Console.Error.WriteLine($"[shell] 启动失败 {fileName}: {ex.Message}");
return null;
}
}
private static void Stop(Process? process)
{
if (process == null) return;
try
{
if (!process.HasExited) process.Kill(entireProcessTree: true);
}
catch (Exception ex)
{
Console.Error.WriteLine($"[shell] 关闭后端失败: {ex.Message}");
}
finally
{
process.Dispose();
}
}
// ---------------------------------------------------------------- 健康检查
private static bool IsHealthy(int port)
{
try
{
using var response = Http.GetAsync($"http://127.0.0.1:{port}/api/health")
.GetAwaiter().GetResult();
return response.IsSuccessStatusCode;
}
catch
{
return false;
}
}
private static bool WaitHealthy(int port, Process backend, TimeSpan timeout)
{
var deadline = DateTime.UtcNow + timeout;
while (DateTime.UtcNow < deadline)
{
// 后端进程已经退出就没必要再等:端口被占、依赖缺失都会走这里。
if (backend.HasExited) return false;
if (IsHealthy(port)) return true;
Thread.Sleep(250);
}
return false;
}
}
+6
View File
@@ -15,9 +15,15 @@ internal static class Program
var paths = AppPaths.Discover(); var paths = AppPaths.Discover();
paths.EnsureCreated(); paths.EnsureCreated();
// 目录约定 + 双语日志 + 把包里的守护进程落到 .GC/safedog
RuntimeLayout.Ensure(paths);
// 上次下载的启动器新版,到这次启动才应用 // 上次下载的启动器新版,到这次启动才应用
if (DownloadModuleHost.Factory.TryApplyPending(paths)) return; if (DownloadModuleHost.Factory.TryApplyPending(paths)) return;
// 发布包带 Flutter 前端时,界面交给它;没带则回退到内置 Avalonia 界面。
if (FlutterShell.TryRun(args)) return;
BuildAvaloniaApp().StartWithClassicDesktopLifetime(args); BuildAvaloniaApp().StartWithClassicDesktopLifetime(args);
} }
+8 -4
View File
@@ -29,7 +29,8 @@ public static class LauncherArtifacts
"win-arm64" => "win-arm64", "win-arm64" => "win-arm64",
"osx-arm64" => "mac-arm64", "osx-arm64" => "mac-arm64",
"osx-x64" => "mac-x64", "osx-x64" => "mac-x64",
"linux-x64" => "linux-amd64", "linux-x64" => "linux-amd64", // 旧产物目录名,仍能读
"linux-arm64" => "linux-arm64",
_ => rid _ => rid
}; };
@@ -46,9 +47,9 @@ public static class LauncherArtifacts
return new[] { label, rid }; return new[] { label, rid };
} }
/// <summary>启动器包应有的文件名,如 <c>GC-1.0.7-mac-arm64.zip</c>。</summary> /// <summary>启动器包应有的文件名,如 <c>GCL-1.0.10-mac-arm64.zip</c>。</summary>
public static string PackageFileName(string version, string rid) public static string PackageFileName(string version, string rid)
=> $"GC-{version.Trim().TrimStart('v', 'V')}-{LabelOf(rid)}.zip"; => $"GCL-{version.Trim().TrimStart('v', 'V')}-{LabelOf(rid)}.zip";
/// <summary> /// <summary>
/// 判断某个 zip 名是不是「这个版本 + 这个平台」的启动器包。 /// 判断某个 zip 名是不是「这个版本 + 这个平台」的启动器包。
@@ -57,7 +58,10 @@ public static class LauncherArtifacts
public static bool LooksLikePackage(string fileName, string version, string rid) public static bool LooksLikePackage(string fileName, string version, string rid)
{ {
if (!fileName.EndsWith(".zip", StringComparison.OrdinalIgnoreCase)) return false; if (!fileName.EndsWith(".zip", StringComparison.OrdinalIgnoreCase)) return false;
if (!fileName.StartsWith("GC-", StringComparison.OrdinalIgnoreCase)) return false; // 1.0.10 起发布包统一叫 GCL-<版本>-<平台>.zip;GC- 是老命名,
// 一并认,装过 1.0.9 及更早版本的机器才不会把新包当成「不是启动器包」。
if (!fileName.StartsWith("GCL-", StringComparison.OrdinalIgnoreCase) &&
!fileName.StartsWith("GC-", StringComparison.OrdinalIgnoreCase)) return false;
var v = version.Trim().TrimStart('v', 'V'); var v = version.Trim().TrimStart('v', 'V');
if (v.Length > 0 && fileName.IndexOf(v, StringComparison.OrdinalIgnoreCase) < 0) return false; if (v.Length > 0 && fileName.IndexOf(v, StringComparison.OrdinalIgnoreCase) < 0) return false;
+45 -4
View File
@@ -367,8 +367,12 @@ public static class LauncherUpdater
else if (File.Exists(manifestCopy)) else if (File.Exists(manifestCopy))
File.Delete(manifestCopy); File.Delete(manifestCopy);
// 包名:GC-<版本>-<平台标签>.app/.exe(SAVEDOG 找不到时会自行扫描包内顶层) // 包名:GCL-<版本>-<平台标签>.app/.exe(SAVEDOG 找不到时会自行扫描包内顶层)。
var packageName = $"GC-{latest}-{PlatformLabel}" + (OperatingSystem.IsMacOS() ? ".app" : ".exe"); // Linux 的启动器没有扩展名,别硬加 .exe —— 那会让按包名查找永远落空。
var packageName = $"GCL-{latest}-{PlatformLabel}" +
(OperatingSystem.IsMacOS() ? ".app"
: OperatingSystem.IsWindows() ? ".exe"
: "");
var request = new SavedogRequest var request = new SavedogRequest
{ {
@@ -447,7 +451,8 @@ public static class LauncherUpdater
/// 找不到 SAVEDOG 时退回旧脚本流程(只用于从老版本升级的过渡)。 /// 找不到 SAVEDOG 时退回旧脚本流程(只用于从老版本升级的过渡)。
/// 返回 true 表示调用方应立即退出进程。 /// 返回 true 表示调用方应立即退出进程。
/// </summary> /// </summary>
public static bool ScheduleApply(AppPaths paths, string packageName) /// <param name="execute">只写脚本不执行(测试用,避免真的搬动文件)。</param>
public static bool ScheduleApply(AppPaths paths, string packageName, bool execute = true)
{ {
// 安全阀:绝不在源码目录执行替换(防止误删源码) // 安全阀:绝不在源码目录执行替换(防止误删源码)
if (File.Exists(Path.Combine(paths.InstallDirectory, "GC.sln"))) if (File.Exists(Path.Combine(paths.InstallDirectory, "GC.sln")))
@@ -484,6 +489,8 @@ public static class LauncherUpdater
catch { } catch { }
} }
if (!execute) return true;
var psi = isWin var psi = isWin
? new System.Diagnostics.ProcessStartInfo("cmd.exe") ? new System.Diagnostics.ProcessStartInfo("cmd.exe")
{ UseShellExecute = false, CreateNoWindow = true } { UseShellExecute = false, CreateNoWindow = true }
@@ -576,7 +583,10 @@ public static class LauncherUpdater
s.AppendLine(); s.AppendLine();
s.AppendLine("# delete old GC-* files: SAME platform only, version != latest"); s.AppendLine("# delete old GC-* files: SAME platform only, version != latest");
s.AppendLine("# files of OTHER platforms are NEVER touched"); s.AppendLine("# files of OTHER platforms are NEVER touched");
s.AppendLine("for item in \"$DST\"/GC-*.app \"$DST\"/GC-*.exe; do"); // Linux 的启动器没有扩展名(GC-1.0.9-linux-amd64),只匹配 *.app/*.exe 会漏掉,
// 结果是每次更新都在安装目录里多留一个旧版本。这里统一按 GC- 前缀扫,
// 再用「版本号-平台」的形态兜底,避免误删同目录的其它文件。
s.AppendLine("for item in \"$DST\"/GC-*; do");
s.AppendLine(" [ -e \"$item\" ] || continue"); s.AppendLine(" [ -e \"$item\" ] || continue");
s.AppendLine(" [ \"$item\" = \"$NEW\" ] && continue"); s.AppendLine(" [ \"$item\" = \"$NEW\" ] && continue");
s.AppendLine(" base=$(basename \"$item\")"); s.AppendLine(" base=$(basename \"$item\")");
@@ -584,6 +594,10 @@ public static class LauncherUpdater
s.AppendLine(" case \"$base\" in"); s.AppendLine(" case \"$base\" in");
s.AppendLine(" *.app) stem=${stem%.app} ;;"); s.AppendLine(" *.app) stem=${stem%.app} ;;");
s.AppendLine(" *.exe) stem=${stem%.exe} ;;"); s.AppendLine(" *.exe) stem=${stem%.exe} ;;");
s.AppendLine(" esac");
s.AppendLine(" # 只认 <版本>-<系统>-<架构>,其它名字一律不动");
s.AppendLine(" case \"$stem\" in");
s.AppendLine(" [0-9]*-*-*) ;;");
s.AppendLine(" *) continue ;;"); s.AppendLine(" *) continue ;;");
s.AppendLine(" esac"); s.AppendLine(" esac");
s.AppendLine(" ver=${stem%%-*}"); s.AppendLine(" ver=${stem%%-*}");
@@ -711,6 +725,17 @@ public static class LauncherUpdater
return name; return name;
} }
if (name.EndsWith(".exe", StringComparison.OrdinalIgnoreCase)) return name; if (name.EndsWith(".exe", StringComparison.OrdinalIgnoreCase)) return name;
// Linux 的启动器没有扩展名(GC-1.0.9-linux-amd64),以前只认 .app/.exe,
// 结果解压完判定「没找到新版启动器」,Linux 更新永远失败。
// 注意不能用 Path.HasExtension:版本号 9.9.9 里的点会让它误判成有扩展名。
if ((name.StartsWith("GC-", StringComparison.OrdinalIgnoreCase) ||
name.StartsWith("GCL-", StringComparison.OrdinalIgnoreCase)) &&
name.EndsWith("-" + PlatformLabel, StringComparison.OrdinalIgnoreCase))
{
TryMarkExecutable(dest);
return name;
}
} }
} }
catch (Exception ex) catch (Exception ex)
@@ -720,6 +745,22 @@ public static class LauncherUpdater
return null; return null;
} }
/// <summary>给 Linux/macOS 上的可执行文件补上执行位(zip 不保留权限)。</summary>
private static void TryMarkExecutable(string path)
{
if (OperatingSystem.IsWindows() || !File.Exists(path)) return;
try
{
var mode = File.GetUnixFileMode(path);
File.SetUnixFileMode(path, mode | UnixFileMode.UserExecute |
UnixFileMode.GroupExecute | UnixFileMode.OtherExecute);
}
catch
{
// 权限设置失败不影响后续流程,用户可手动 chmod
}
}
private static string? ReadMarker(string file, string key) private static string? ReadMarker(string file, string key)
{ {
try try
+8
View File
@@ -20,9 +20,17 @@ public static class SavedogLauncher
var name = SavedogFiles.ExecutableName; var name = SavedogFiles.ExecutableName;
var install = paths.InstallDirectory; var install = paths.InstallDirectory;
// 首选 .GC/safedog:更新时整目录替换不会碰这里,正在运行的守护进程也安全。
var home = Path.Combine(paths.SafedogRoot, name);
if (File.Exists(home)) return home;
var direct = Path.Combine(install, name); var direct = Path.Combine(install, name);
if (File.Exists(direct)) return direct; if (File.Exists(direct)) return direct;
// 新包把守护进程放在 safedog/ 子目录
var packaged = Path.Combine(install, "safedog", name);
if (File.Exists(packaged)) return packaged;
// macOS:可能放在 .app 内部 // macOS:可能放在 .app 内部
try try
{ {
+12 -3
View File
@@ -40,7 +40,8 @@ public sealed class SourceSelector : ISourceSelector
/// <summary> /// <summary>
/// 探测两个源并返回最快的。force=true 时忽略缓存。 /// 探测两个源并返回最快的。force=true 时忽略缓存。
/// 两个都失败时返回 GitCode(默认源)。 /// 两个都失败时退回主源(Xhmcl):GitCode 镜像已停更,用它兜底只会拿到过期的
/// version.json —— 反而让人以为「没有更新」。
/// </summary> /// </summary>
public async Task<SourcePreset> PickFastestAsync(bool force = false, CancellationToken ct = default) public async Task<SourcePreset> PickFastestAsync(bool force = false, CancellationToken ct = default)
{ {
@@ -64,12 +65,20 @@ public sealed class SourceSelector : ISourceSelector
LastLatency = latencies; LastLatency = latencies;
var usable = results.Where(r => r.Ok).OrderBy(r => r.Ms).ToList(); var usable = results.Where(r => r.Ok).OrderBy(r => r.Ms).ToList();
var chosen = usable.Count > 0 ? usable[0].Preset : SourcePreset.GitCode; // 全部探测失败时退回主源(SourcePreset.All 的第一项 = Xhmcl),
// 不要退回已停更的 GitCode 镜像。
var fallback = SourcePreset.All.Length > 0 ? SourcePreset.All[0] : SourcePreset.Xhmcl;
var chosen = usable.Count > 0 ? usable[0].Preset : fallback;
if (usable.Count == 0)
Console.WriteLine($"[selector] 所有源探测失败,退回主源 {chosen.Name}(稍后由实际请求再判定)");
lock (_lock) lock (_lock)
{ {
_cached = chosen; _cached = chosen;
_cachedAt = DateTime.UtcNow; // 全部探测失败的结果不缓存:网络刚恢复时应该立刻重新测速,
// 而不是被一次失败的探测锁住 3 分钟。
_cachedAt = usable.Count > 0 ? DateTime.UtcNow : DateTime.MinValue;
} }
Console.WriteLine("[selector] 测速:" + string.Join(" ", Console.WriteLine("[selector] 测速:" + string.Join(" ",
+4 -3
View File
@@ -4,7 +4,7 @@ using System.Globalization;
namespace GC.Services; namespace GC.Services;
/// <summary> /// <summary>
/// 版本号工具:Release tag 有 v1.0.6 / GC-1.0.6 / 1.0.6 等写法, /// 版本号工具:Release tag 有 v1.0.6 / GCL-1.0.6 / GC-1.0.6 / 1.0.6 等写法,
/// 统一成可比较的 Version 再排序,挑**版本号最高**的那个。 /// 统一成可比较的 Version 再排序,挑**版本号最高**的那个。
/// </summary> /// </summary>
public static class VersionUtil public static class VersionUtil
@@ -15,8 +15,9 @@ public static class VersionUtil
if (string.IsNullOrWhiteSpace(tag)) return ""; if (string.IsNullOrWhiteSpace(tag)) return "";
var s = tag!.Trim(); var s = tag!.Trim();
// 去掉前缀:v / V / GC- / release- // 去掉前缀:v / V / GC- / GCL- / release-
if (s.StartsWith("GC-", StringComparison.OrdinalIgnoreCase)) s = s[3..]; if (s.StartsWith("GCL-", StringComparison.OrdinalIgnoreCase)) s = s[4..];
else if (s.StartsWith("GC-", StringComparison.OrdinalIgnoreCase)) s = s[3..];
else if (s.StartsWith("release-", StringComparison.OrdinalIgnoreCase)) s = s[8..]; else if (s.StartsWith("release-", StringComparison.OrdinalIgnoreCase)) s = s[8..];
s = s.TrimStart('v', 'V'); s = s.TrimStart('v', 'V');
+335 -112
View File
@@ -26,13 +26,14 @@ internal sealed class ApplyOptions
/// </summary> /// </summary>
internal sealed class Applier internal sealed class Applier
{ {
private static readonly Regex ArtifactPattern = new(
@"^GC-(?<ver>.+?)-(?<plat>[^\-]+-[^\-]+)\.(app|exe)$",
RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
private readonly ApplyOptions _options; private readonly ApplyOptions _options;
private readonly Log _log; private readonly Log _log;
/// <summary>发布包里的启动器文件名:GC-1.0.9-win-amd64.exe。</summary>
private static readonly Regex VersionedExePattern = new(
@"^(?:GC|GCL)-\d+(?:\.\d+)+-[A-Za-z0-9]+-[A-Za-z0-9]+\.exe$",
RegexOptions.IgnoreCase | RegexOptions.CultureInvariant | RegexOptions.Compiled);
public Applier(ApplyOptions options, Log log) public Applier(ApplyOptions options, Log log)
{ {
_options = options; _options = options;
@@ -45,20 +46,24 @@ internal sealed class Applier
var requestPath = Path.Combine(updateDir, SavedogFiles.ApplyRequest); var requestPath = Path.Combine(updateDir, SavedogFiles.ApplyRequest);
if (!File.Exists(requestPath)) if (!File.Exists(requestPath))
return Fail(updateDir, "找不到更新申请 " + SavedogFiles.ApplyRequest, 3); return Fail(updateDir, "找不到更新申请 " + SavedogFiles.ApplyRequest, 3,
"Update request not found: " + SavedogFiles.ApplyRequest);
var request = Json.Read<SavedogRequest>(requestPath); var request = Json.Read<SavedogRequest>(requestPath);
if (request == null || string.IsNullOrWhiteSpace(request.Version)) if (request == null || string.IsNullOrWhiteSpace(request.Version))
return Fail(updateDir, "更新申请内容不完整", 3); return Fail(updateDir, "更新申请内容不完整", 3, "The update request is incomplete");
if (!ValidName(request.PackageName)) if (!ValidName(request.PackageName))
return Fail(updateDir, "更新包名不合法: " + request.PackageName, 3); return Fail(updateDir, "更新包名不合法: " + request.PackageName, 3,
"Invalid package name: " + request.PackageName);
_log.Info($"开始应用 v{request.Version}({request.Rid},{request.PackageName})"); _log.Info($"开始应用 v{request.Version}({request.Rid},{request.PackageName})",
$"Starting apply of v{request.Version} ({request.Rid}, {request.PackageName})");
// 1. 等旧进程退出(否则 Windows 上文件还被占用) // 1. 等旧进程退出(否则 Windows 上文件还被占用)
if (_options.WaitPid > 0 && !WaitForExit(_options.WaitPid, TimeSpan.FromSeconds(60))) if (_options.WaitPid > 0 && !WaitForExit(_options.WaitPid, TimeSpan.FromSeconds(60)))
_log.Warn($"等待进程 {_options.WaitPid} 退出超时,继续尝试"); _log.Warn($"等待进程 {_options.WaitPid} 退出超时,继续尝试",
$"Timed out waiting for process {_options.WaitPid} to exit; continuing anyway");
// 2. 安装目录定位与安全检查 // 2. 安装目录定位与安全检查
var installDir = string.IsNullOrWhiteSpace(_options.InstallDir) var installDir = string.IsNullOrWhiteSpace(_options.InstallDir)
@@ -66,10 +71,12 @@ internal sealed class Applier
: Path.GetFullPath(_options.InstallDir!); : Path.GetFullPath(_options.InstallDir!);
if (!Directory.Exists(installDir)) if (!Directory.Exists(installDir))
return Fail(updateDir, "安装目录不存在: " + installDir, 4); return Fail(updateDir, "安装目录不存在: " + installDir, 4,
"Install directory does not exist: " + installDir);
if (!_options.Force && File.Exists(Path.Combine(installDir, "GC.sln"))) if (!_options.Force && File.Exists(Path.Combine(installDir, "GC.sln")))
return Fail(updateDir, "检测到源码目录,拒绝在源码树里替换程序", 4); return Fail(updateDir, "检测到源码目录,拒绝在源码树里替换程序", 4,
"Source tree detected; refusing to replace files inside it");
// 3. 二次验签:不信任「启动器说它验过了」 // 3. 二次验签:不信任「启动器说它验过了」
var require = request.RequireSignature && SignatureKeyring.Enforced; var require = request.RequireSignature && SignatureKeyring.Enforced;
@@ -79,40 +86,50 @@ internal sealed class Applier
if (verification.IsRejected) if (verification.IsRejected)
{ {
_log.Error($"清单验签失败({verification.Trust}):{verification.Error}"); _log.Error($"清单验签失败({verification.Trust}):{verification.Error}",
$"Manifest signature check failed ({verification.Trust}): {verification.Error}");
return Refuse(updateDir, request, verification); return Refuse(updateDir, request, verification);
} }
_log.Info($"清单可信度:{verification.Trust}" + _log.Info($"清单可信度:{verification.Trust}" +
(verification.KeyId != null ? $"({verification.KeyId})" : "")); (verification.KeyId != null ? $"({verification.KeyId})" : ""),
$"Manifest trust: {verification.Trust}" +
(verification.KeyId != null ? $" ({verification.KeyId})" : ""));
// 4. 校验更新包 // 4. 校验更新包
var zipPath = Path.Combine(updateDir, request.PackageZip); var zipPath = Path.Combine(updateDir, request.PackageZip);
if (!File.Exists(zipPath)) if (!File.Exists(zipPath))
return Fail(updateDir, "更新包不存在: " + request.PackageZip, 5); return Fail(updateDir, "更新包不存在: " + request.PackageZip, 5,
"Package not found: " + request.PackageZip);
var zipInfo = new FileInfo(zipPath); var zipInfo = new FileInfo(zipPath);
if (request.PackageSize > 0 && zipInfo.Length != request.PackageSize) if (request.PackageSize > 0 && zipInfo.Length != request.PackageSize)
return Fail(updateDir, $"更新包体积不符(期望 {request.PackageSize},实际 {zipInfo.Length})", 5); return Fail(updateDir, $"更新包体积不符(期望 {request.PackageSize},实际 {zipInfo.Length})", 5,
$"Package size mismatch (expected {request.PackageSize}, got {zipInfo.Length})");
var actualSha = ContentHash.Sha256File(zipPath); var actualSha = ContentHash.Sha256File(zipPath);
if (!string.IsNullOrWhiteSpace(request.PackageSha256) && if (!string.IsNullOrWhiteSpace(request.PackageSha256) &&
!string.Equals(actualSha, request.PackageSha256, StringComparison.OrdinalIgnoreCase)) !string.Equals(actualSha, request.PackageSha256, StringComparison.OrdinalIgnoreCase))
{ {
return Fail(updateDir, "更新包 sha256 与清单不符,已丢弃", 5); return Fail(updateDir, "更新包 sha256 与清单不符,已丢弃", 5,
"Package sha256 does not match the manifest; discarded");
} }
if (string.IsNullOrWhiteSpace(request.PackageSha256)) if (string.IsNullOrWhiteSpace(request.PackageSha256))
_log.Warn("清单没有提供 sha256,仅依赖签名与解压校验"); _log.Warn("清单没有提供 sha256,仅依赖签名与解压校验",
"Manifest has no sha256; relying on the signature and extraction checks only");
SafeArchive.Inspection inspection; SafeArchive.Inspection inspection;
try try
{ {
inspection = SafeArchive.Inspect(zipPath); inspection = SafeArchive.Inspect(zipPath);
_log.Info($"更新包检查通过:{inspection.Entries} 个条目," + _log.Info($"更新包检查通过:{inspection.Entries} 个条目," +
$"{inspection.UncompressedBytes / 1024 / 1024} MB,压缩比 {inspection.Ratio:0.0}:1"); $"{inspection.UncompressedBytes / 1024 / 1024} MB,压缩比 {inspection.Ratio:0.0}:1",
$"Package inspection passed: {inspection.Entries} entries, " +
$"{inspection.UncompressedBytes / 1024 / 1024} MB, ratio {inspection.Ratio:0.0}:1");
} }
catch (Exception ex) catch (Exception ex)
{ {
return Fail(updateDir, "更新包安全性检查失败: " + ex.Message, 5); return Fail(updateDir, "更新包安全性检查失败: " + ex.Message, 5,
"Package safety check failed: " + ex.Message);
} }
// 5. 解压到暂存区(与安装目录同卷,后续 rename 才是原子的) // 5. 解压到暂存区(与安装目录同卷,后续 rename 才是原子的)
@@ -126,30 +143,39 @@ internal sealed class Applier
catch (Exception ex) catch (Exception ex)
{ {
ClearDirectory(stage); ClearDirectory(stage);
return Fail(updateDir, "解压失败: " + ex.Message, 6); return Fail(updateDir, "解压失败: " + ex.Message, 6, "Extraction failed: " + ex.Message);
} }
var artifact = FindArtifact(stage, request.PackageName); var artifact = FindArtifact(stage, request.PackageName);
if (artifact == null) if (artifact == null)
{ {
ClearDirectory(stage); ClearDirectory(stage);
return Fail(updateDir, "更新包里没有找到新版程序(" + request.PackageName + ")", 6); return Fail(updateDir, "更新包里没有找到新版程序(" + request.PackageName + ")", 6,
"No new launcher found in the package (" + request.PackageName + ")");
} }
var target = Path.Combine(installDir, Path.GetFileName(artifact)); // 主程序:优先用清单里的包名,否则按已知名字挑一个(发布包是整目录,
var alreadyInstalled = File.Exists(target) || Directory.Exists(target); // 里面同时有 GC-UI.exe / GC.UI.Server.exe / GC-SAVEDOG.exe,不能瞎猜第一个)。
var mainName = Path.GetFileName(artifact);
var mainTarget = Path.Combine(installDir, mainName);
if (_options.DryRun) if (_options.DryRun)
{ {
_log.Info($"[dry-run] 校验全部通过,将安装到 {target}"); _log.Info($"[dry-run] 校验全部通过,将整目录安装到 {installDir}" +
$"({Directory.GetFileSystemEntries(stage).Length} 个顶层条目)",
$"[dry-run] All checks passed; would install the whole directory to {installDir} " +
$"({Directory.GetFileSystemEntries(stage).Length} top-level entries)");
ClearDirectory(stage); ClearDirectory(stage);
return 0; return 0;
} }
if (alreadyInstalled) var previous = ReadLastGood(updateDir);
if (previous != null && SameVersion(previous.Version, request.Version) &&
(File.Exists(mainTarget) || Directory.Exists(mainTarget)))
{ {
// 同一版本重复下发:当成已安装,避免反复覆盖正在运行的文件 // 同一版本重复下发:当成已安装,避免反复覆盖正在运行的文件
_log.Info("目标版本已存在,视为已安装"); _log.Info($"v{request.Version} 已安装且上次启动正常,视为已安装",
$"v{request.Version} is already installed and started fine last time; treating as installed");
ClearDirectory(stage); ClearDirectory(stage);
TryDelete(zipPath); TryDelete(zipPath);
TryDelete(requestPath); TryDelete(requestPath);
@@ -157,40 +183,38 @@ internal sealed class Applier
{ {
Status = "applied", Status = "applied",
Version = request.Version, Version = request.Version,
PackageName = Path.GetFileName(artifact), PackageName = mainName,
Verified = true, Verified = true,
Message = "目标版本已存在,无需替换" Message = "目标版本已存在,无需替换"
}); });
return 0; return 0;
} }
// 6. 移入安装目录(不覆盖任何已有文件) // 6. 整目录替换:旧内容先搬到 backup,新内容就位;失败可原样还原。
try // 只动程序文件,.GC(模型库 / 设置 / 更新目录)永远不碰。
{ var replaced = new List<(string Name, string? BackupPath)>();
Directory.CreateDirectory(installDir); if (!ReplaceInstallDirectory(stage, installDir, updateDir, replaced, out var replaceError))
if (Directory.Exists(artifact)) Directory.Move(artifact, target);
else File.Move(artifact, target);
_log.Info("新版已就位: " + Path.GetFileName(target));
}
catch (Exception ex)
{ {
RestoreFromBackup(installDir, replaced);
ClearDirectory(stage); ClearDirectory(stage);
return Fail(updateDir, "移动到安装目录失败: " + ex.Message, 7); return Fail(updateDir, "安装失败: " + replaceError, 7, "Installation failed: " + replaceError);
} }
_log.Info($"新版已就位:{mainName}(替换 {replaced.Count} 个条目)",
$"New version in place: {mainName} (replaced {replaced.Count} entries)");
// 7. 启动并看护 // 7. 启动并看护
var previous = ReadLastGood(updateDir);
StartupHealth.Clear(updateDir); StartupHealth.Clear(updateDir);
Process? child; Process? child;
try try
{ {
child = Launch(target); child = Launch(mainTarget);
} }
catch (Exception ex) catch (Exception ex)
{ {
child = null; child = null;
_log.Error("启动新版失败: " + ex.Message); _log.Error("启动新版失败: " + ex.Message,
"Failed to start the new version: " + ex.Message);
} }
var healthy = child != null && WaitForHealth(updateDir, request.Version, child, var healthy = child != null && WaitForHealth(updateDir, request.Version, child,
@@ -198,15 +222,16 @@ internal sealed class Applier
if (healthy) if (healthy)
{ {
_log.Info($"v{request.Version} 启动正常,更新完成"); _log.Info($"v{request.Version} 启动正常,更新完成",
CleanupOldVersions(installDir, Path.GetFileName(target), request.PlatformLabel); $"v{request.Version} started successfully; update complete");
WriteLastGood(updateDir, request.Version, Path.GetFileName(target)); CleanupBackup(updateDir);
WriteLastGood(updateDir, request.Version, mainName);
WriteState(updateDir, new SavedogState WriteState(updateDir, new SavedogState
{ {
Status = "applied", Status = "applied",
Version = request.Version, Version = request.Version,
PreviousVersion = previous?.Version, PreviousVersion = previous?.Version,
PackageName = Path.GetFileName(target), PackageName = mainName,
Verified = true, Verified = true,
Message = "更新已应用" Message = "更新已应用"
}); });
@@ -216,21 +241,23 @@ internal sealed class Applier
return 0; return 0;
} }
// 8. 回滚 // 8. 回滚:撤掉新装的文件,把备份原样搬回
_log.Error($"v{request.Version} 启动后未通过健康检查({_options.TimeoutSeconds}s),开始回滚"); _log.Error($"v{request.Version} 启动后未通过健康检查({_options.TimeoutSeconds}s),开始回滚",
$"v{request.Version} did not pass the health check after {_options.TimeoutSeconds}s; rolling back");
TryKill(child); TryKill(child);
var removed = RemoveNewVersion(target); var restored = RestoreFromBackup(installDir, replaced);
_log.Info(removed ? "已移除未通过检查的新版" : "新版文件被占用,未能完全移除"); _log.Info(restored ? "已还原为更新前的文件" : "部分文件未能还原,请手动重新安装",
restored ? "Restored the pre-update files" : "Some files could not be restored; please reinstall manually");
var restored = TryLaunchPrevious(installDir, updateDir, previous, request.PlatformLabel); var relaunched = restored && TryLaunchPrevious(installDir, updateDir, previous, request.PlatformLabel);
WriteState(updateDir, new SavedogState WriteState(updateDir, new SavedogState
{ {
Status = "rolledback", Status = "rolledback",
Version = request.Version, Version = request.Version,
PreviousVersion = previous?.Version, PreviousVersion = previous?.Version,
PackageName = Path.GetFileName(target), PackageName = mainName,
Verified = true, Verified = true,
Message = restored Message = relaunched
? "新版本未通过启动检查,已回滚到上一个版本" ? "新版本未通过启动检查,已回滚到上一个版本"
: "新版本未通过启动检查,已移除;未找到可回滚的旧版本,请手动重新安装" : "新版本未通过启动检查,已移除;未找到可回滚的旧版本,请手动重新安装"
}); });
@@ -243,11 +270,18 @@ internal sealed class Applier
// ------------------------------------------------------------------ 校验辅助 // ------------------------------------------------------------------ 校验辅助
/// <summary>
/// 包名合法性:只允许「一个文件名」,杜绝 `../` 之类的路径穿越。
///
/// 不能只认 .app / .exe —— Linux 的启动器没有扩展名
/// (GC-1.0.9-linux-amd64),按旧规则会被直接判成非法包名、更新永远失败。
/// </summary>
private static bool ValidName(string name) private static bool ValidName(string name)
=> name.Length > 0 && name.Length < 200 && => SafeNamePattern.IsMatch(name);
name.IndexOfAny(new[] { '/', '\\', ':', '\0' }) < 0 &&
(name.EndsWith(".app", StringComparison.OrdinalIgnoreCase) || private static readonly Regex SafeNamePattern = new(
name.EndsWith(".exe", StringComparison.OrdinalIgnoreCase)); @"^[A-Za-z0-9][A-Za-z0-9._-]{0,198}$",
RegexOptions.CultureInvariant | RegexOptions.Compiled);
private static bool WaitForExit(int pid, TimeSpan timeout) private static bool WaitForExit(int pid, TimeSpan timeout)
{ {
@@ -280,22 +314,64 @@ internal sealed class Applier
Directory.Move(temp, stage); Directory.Move(temp, stage);
} }
/// <summary>
/// 在解压结果里找主程序。
///
/// 发布包是「整目录」结构(exe + dll + data/),同一层可能有好几个 exe
/// (GC-UI / GC.UI.Server / GC-SAVEDOG / createdump),必须按固定优先级挑,
/// 不能取第一个 —— 否则会把守护进程或调试辅助程序当成启动器拉起来。
/// </summary>
private static string? FindArtifact(string stage, string packageName) private static string? FindArtifact(string stage, string packageName)
{ {
var direct = Path.Combine(stage, packageName); if (!string.IsNullOrWhiteSpace(packageName))
if (File.Exists(direct) || Directory.Exists(direct)) return direct;
foreach (var entry in Directory.GetFileSystemEntries(stage))
{ {
var name = Path.GetFileName(entry); var named = Path.Combine(stage, packageName);
if (name.EndsWith(".app", StringComparison.OrdinalIgnoreCase) && Directory.Exists(entry)) if (File.Exists(named) || Directory.Exists(named)) return named;
return entry; }
if (name.EndsWith(".exe", StringComparison.OrdinalIgnoreCase) && File.Exists(entry))
var entries = Directory.GetFileSystemEntries(stage);
var byName = entries
.Where(e => File.Exists(e))
.OrderByDescending(e => MainExecutablePriority(Path.GetFileName(e)))
.ThenBy(e => Path.GetFileName(e), StringComparer.OrdinalIgnoreCase)
.ToList();
var best = byName.FirstOrDefault(e => MainExecutablePriority(Path.GetFileName(e)) > 0);
if (best != null) return best;
// macOS:.app 目录本身就是「可执行单元」
foreach (var entry in entries)
{
if (Directory.Exists(entry) &&
Path.GetFileName(entry).EndsWith(".app", StringComparison.OrdinalIgnoreCase))
return entry; return entry;
} }
return null; return null;
} }
/// <summary>主程序优先级:数字越大越优先,0 表示不是主程序。</summary>
private static int MainExecutablePriority(string fileName)
{
if (!fileName.EndsWith(".exe", StringComparison.OrdinalIgnoreCase)) return 0;
// 发布包把启动器改名成 GCL-<版本>-<系统>-<架构>.exe(旧包是 GC-),先按这个模式认出来。
if (VersionedExePattern.IsMatch(fileName)) return 110;
var name = Path.GetFileNameWithoutExtension(fileName);
return name switch
{
"GC-UI" => 100,
"GC" => 90,
"GC.UI.Server" => 80,
// 守护进程 / 调试辅助 / 运行时工具:永远不当主程序
"GC-SAVEDOG" => 0,
"createdump" => 0,
"singlefilehost" => 0,
_ => 10
};
}
// ------------------------------------------------------------------ 启动与看护 // ------------------------------------------------------------------ 启动与看护
private Process? Launch(string target) private Process? Launch(string target)
@@ -362,13 +438,14 @@ internal sealed class Applier
var health = StartupHealth.Read(updateDir); var health = StartupHealth.Read(updateDir);
if (health != null && health.Ok && SameVersion(health.Version, version)) if (health != null && health.Ok && SameVersion(health.Version, version))
{ {
_log.Info($"收到健康标记(pid {health.Pid})"); _log.Info($"收到健康标记(pid {health.Pid})", $"Health marker received (pid {health.Pid})");
return true; return true;
} }
if (child.HasExited) if (child.HasExited)
{ {
_log.Error($"新版进程已退出(退出码 {child.ExitCode})"); _log.Error($"新版进程已退出(退出码 {child.ExitCode})",
$"The new process exited (code {child.ExitCode})");
return false; return false;
} }
Thread.Sleep(250); Thread.Sleep(250);
@@ -377,7 +454,8 @@ internal sealed class Applier
// 超时但进程还活着:可能是尚未写入健康标记的旧构建,谨慎放行 // 超时但进程还活着:可能是尚未写入健康标记的旧构建,谨慎放行
if (!child.HasExited) if (!child.HasExited)
{ {
_log.Warn("未收到健康标记,但进程仍在运行,按成功处理"); _log.Warn("未收到健康标记,但进程仍在运行,按成功处理",
"No health marker, but the process is still running; treating as success");
return true; return true;
} }
return false; return false;
@@ -410,57 +488,200 @@ internal sealed class Applier
catch { } catch { }
} }
// ------------------------------------------------------------------ 清理 / 回滚 // ------------------------------------------------------------------ 整目录安装 / 回滚
private void CleanupOldVersions(string installDir, string keepName, string platformLabel) /// <summary>
/// 把 <paramref name="stage"/> 的内容替换进 <paramref name="installDir"/>。
///
/// 发布包是「整目录」(启动器 + 后端运行时 + Flutter 前端资源),只搬一个 exe 会留下
/// 旧后端 / 旧界面,所以这里按目录整体替换:
/// 1. 安装目录里「新版没有」的条目 → 移到 backup(旧版本残留,如上一版的旧文件名);
/// 2. 与新版同名的条目 → 先移到 backup,再把新版放进来(覆盖正在被占用的文件会失败,
/// 这种情况直接报错并还原,绝不留下半新半旧的目录);
/// 3. `.GC`、更新目录自身、正在运行的 GC-SAVEDOG.exe 一律跳过。
///
/// 返回 false 时调用方应调用 <see cref="RestoreFromBackup"/> 还原。
/// </summary>
private bool ReplaceInstallDirectory(string stage, string installDir, string updateDir,
List<(string Name, string? BackupPath)> replaced, out string? error)
{ {
foreach (var entry in Directory.GetFileSystemEntries(installDir)) error = null;
{ var backupDir = Path.Combine(updateDir, "backup");
var name = Path.GetFileName(entry);
if (string.Equals(name, keepName, StringComparison.OrdinalIgnoreCase)) continue;
var match = ArtifactPattern.Match(name);
if (!match.Success) continue;
var platform = match.Groups["plat"].Value;
if (!string.Equals(platform, platformLabel, StringComparison.OrdinalIgnoreCase))
{
_log.Info($"保留其它平台版本: {name}");
continue;
}
try
{
if (Directory.Exists(entry)) Directory.Delete(entry, true);
else File.Delete(entry);
_log.Info("清理旧版本: " + name);
}
catch (Exception ex)
{
_log.Warn($"清理旧版本失败 {name}: {ex.Message}");
}
}
}
private bool RemoveNewVersion(string target)
{
try try
{ {
if (Directory.Exists(target)) Directory.Delete(target, true); Directory.CreateDirectory(installDir);
else if (File.Exists(target)) File.Delete(target); ClearDirectory(backupDir);
Directory.CreateDirectory(backupDir);
var incoming = new List<string>();
foreach (var entry in Directory.GetFileSystemEntries(stage))
{
var name = Path.GetFileName(entry);
if (IsProtected(name))
{
// 例如 GC-SAVEDOG.exe:本进程正在运行,Windows 上无法替换。
// 保留旧版守护进程即可,它下次启动会随包里的新版本一起被更新。
_log.Warn($"跳过受保护文件,保留旧版本:{name}",
$"Skipping protected file, keeping the old one: {name}");
continue;
}
incoming.Add(entry);
}
var incomingNames = new HashSet<string>(
incoming.Select(e => Path.GetFileName(e)), StringComparer.OrdinalIgnoreCase);
// 1. 旧版独有的条目先清走(保留在 backup 里以便回滚)
foreach (var entry in Directory.GetFileSystemEntries(installDir))
{
var name = Path.GetFileName(entry);
if (incomingNames.Contains(name)) continue;
if (IsProtected(name)) continue;
if (IsSameOrInside(entry, updateDir)) continue;
var target = Path.Combine(backupDir, name);
MoveEntry(entry, target);
replaced.Add((name, target));
_log.Info("旧版残留已备份: " + name, "Old leftover backed up: " + name);
}
// 2. 同名条目:旧 → backup,新 → 安装目录
foreach (var entry in incoming)
{
var name = Path.GetFileName(entry);
var target = Path.Combine(installDir, name);
var backup = Path.Combine(backupDir, name);
if (File.Exists(target) || Directory.Exists(target))
{
MoveEntry(target, backup);
replaced.Add((name, backup));
}
else
{
// 纯新增:回滚时直接删掉,没有备份可还原
replaced.Add((name, null));
}
MoveEntry(entry, target);
}
return true; return true;
} }
catch (Exception ex) catch (Exception ex)
{ {
_log.Warn("移除新版失败: " + ex.Message); error = ex.Message;
return false; return false;
} }
} }
/// <summary>
/// 把备份里的条目原样搬回安装目录,撤掉新装的内容。
/// <paramref name="BackupPath"/> 为 null 表示这一项是新包里独有的(没有旧版本),
/// 回滚时只需要删掉。
/// </summary>
private bool RestoreFromBackup(string installDir, List<(string Name, string? BackupPath)> replaced)
{
var ok = true;
foreach (var (name, backup) in replaced)
{
var target = Path.Combine(installDir, name);
try
{
// 先撤掉新版(新包里独有的文件也要删干净,否则回滚后目录里新旧混杂)
DeleteEntry(target);
if (string.IsNullOrWhiteSpace(backup) ||
(!File.Exists(backup) && !Directory.Exists(backup)))
continue;
MoveEntry(backup, target);
_log.Info("已还原: " + name, "Restored: " + name);
}
catch (Exception ex)
{
ok = false;
_log.Warn($"还原 {name} 失败: {ex.Message}", $"Failed to restore {name}: {ex.Message}");
}
}
return ok;
}
/// <summary>更新成功:删掉整份备份,不再占用磁盘。</summary>
private void CleanupBackup(string updateDir)
{
var backupDir = Path.Combine(updateDir, "backup");
try
{
if (Directory.Exists(backupDir)) Directory.Delete(backupDir, true);
}
catch (Exception ex)
{
_log.Warn("清理备份失败: " + ex.Message, "Failed to clean up the backup: " + ex.Message);
}
}
/// <summary>
/// 安装目录里不该被更新碰的东西:
/// · .GC —— 模型库、设置、日志、更新目录本身都在这里;
/// · GC-SAVEDOG.exe —— 本进程正在运行,Windows 上无法替换。
/// </summary>
private static bool IsProtected(string name)
{
if (string.Equals(name, ".GC", StringComparison.OrdinalIgnoreCase)) return true;
var self = Environment.ProcessPath;
if (!string.IsNullOrWhiteSpace(self) &&
string.Equals(name, Path.GetFileName(self!), StringComparison.OrdinalIgnoreCase))
return true;
return string.Equals(name, "backup", StringComparison.OrdinalIgnoreCase);
}
private static bool IsSameOrInside(string path, string root)
{
try
{
var full = Path.GetFullPath(path).TrimEnd(Path.DirectorySeparatorChar);
var rootFull = Path.GetFullPath(root).TrimEnd(Path.DirectorySeparatorChar);
return full.Equals(rootFull, StringComparison.OrdinalIgnoreCase) ||
full.StartsWith(rootFull + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase);
}
catch { return false; }
}
/// <summary>移动条目;跨卷或目标占用时退回「复制 + 删除」。</summary>
private static void MoveEntry(string from, string to)
{
var parent = Path.GetDirectoryName(to);
if (!string.IsNullOrWhiteSpace(parent)) Directory.CreateDirectory(parent);
if (Directory.Exists(from))
{
Directory.Move(from, to);
return;
}
try
{
File.Move(from, to, overwrite: true);
}
catch (IOException)
{
File.Copy(from, to, overwrite: true);
File.Delete(from);
}
}
/// <summary>删除文件或目录,失败时抛出(由调用方决定是否回滚)。</summary>
private static void DeleteEntry(string path)
{
if (Directory.Exists(path)) Directory.Delete(path, true);
else if (File.Exists(path)) File.Delete(path);
}
private bool TryLaunchPrevious(string installDir, string updateDir, LastGoodVersion? lastGood, private bool TryLaunchPrevious(string installDir, string updateDir, LastGoodVersion? lastGood,
string platformLabel) string platformLabel)
{ {
// 优先用上次成功的版本;否则挑一个同平台的其它版本 // 优先用上次成功启动的主程序;否则按优先级在安装目录里找
var candidates = new List<string>(); var candidates = new List<string>();
if (lastGood != null && !string.IsNullOrWhiteSpace(lastGood.PackageName)) if (lastGood != null && !string.IsNullOrWhiteSpace(lastGood.PackageName))
candidates.Add(Path.Combine(installDir, lastGood.PackageName)); candidates.Add(Path.Combine(installDir, lastGood.PackageName));
@@ -468,25 +689,27 @@ internal sealed class Applier
foreach (var entry in Directory.GetFileSystemEntries(installDir)) foreach (var entry in Directory.GetFileSystemEntries(installDir))
{ {
var name = Path.GetFileName(entry); var name = Path.GetFileName(entry);
var match = ArtifactPattern.Match(name); if (IsProtected(name)) continue;
if (!match.Success) continue; if (MainExecutablePriority(name) > 0) candidates.Add(entry);
if (!string.Equals(match.Groups["plat"].Value, platformLabel, StringComparison.OrdinalIgnoreCase)) else if (Directory.Exists(entry) &&
continue; name.EndsWith(".app", StringComparison.OrdinalIgnoreCase))
candidates.Add(entry); candidates.Add(entry);
} }
foreach (var candidate in candidates) foreach (var candidate in candidates.Distinct(StringComparer.OrdinalIgnoreCase))
{ {
if (!File.Exists(candidate) && !Directory.Exists(candidate)) continue; if (!File.Exists(candidate) && !Directory.Exists(candidate)) continue;
try try
{ {
Launch(candidate); Launch(candidate);
_log.Info("已回滚启动: " + Path.GetFileName(candidate)); _log.Info("已回滚启动: " + Path.GetFileName(candidate),
"Rolled back and started: " + Path.GetFileName(candidate));
return true; return true;
} }
catch (Exception ex) catch (Exception ex)
{ {
_log.Warn($"回滚启动失败 {Path.GetFileName(candidate)}: {ex.Message}"); _log.Warn($"回滚启动失败 {Path.GetFileName(candidate)}: {ex.Message}",
$"Failed to start rollback candidate {Path.GetFileName(candidate)}: {ex.Message}");
} }
} }
return false; return false;
@@ -497,12 +720,12 @@ internal sealed class Applier
private void WriteState(string updateDir, SavedogState state) private void WriteState(string updateDir, SavedogState state)
{ {
try { Json.Write(Path.Combine(updateDir, SavedogFiles.State), state); } try { Json.Write(Path.Combine(updateDir, SavedogFiles.State), state); }
catch (Exception ex) { _log.Warn("写状态失败: " + ex.Message); } catch (Exception ex) { _log.Warn("写状态失败: " + ex.Message, "Failed to write state: " + ex.Message); }
} }
private int Fail(string updateDir, string message, int code) private int Fail(string updateDir, string message, int code, string? messageEn = null)
{ {
_log.Error(message); _log.Error(message, messageEn ?? message);
WriteState(updateDir, new SavedogState { Status = "failed", Message = message }); WriteState(updateDir, new SavedogState { Status = "failed", Message = message });
return code; return code;
} }
+2
View File
@@ -42,6 +42,8 @@
ManifestLoader 依赖启动器的 RepoVersion 模型,守护进程不需要,排除。 --> ManifestLoader 依赖启动器的 RepoVersion 模型,守护进程不需要,排除。 -->
<Compile Include="..\GC\src\Security\**\*.cs" Exclude="..\GC\src\Security\ManifestLoader.cs" LinkBase="Security" /> <Compile Include="..\GC\src\Security\**\*.cs" Exclude="..\GC\src\Security\ManifestLoader.cs" LinkBase="Security" />
<Compile Include="..\GC\src\Services\Json.cs" Link="Shared\Json.cs" /> <Compile Include="..\GC\src\Services\Json.cs" Link="Shared\Json.cs" />
<!-- 与启动器共用同一份双语日志实现,保证 .GC/logs 里格式一致 -->
<Compile Include="..\GC\src\Services\GcLog.cs" Link="Shared\GcLog.cs" />
</ItemGroup> </ItemGroup>
</Project> </Project>
+13 -25
View File
@@ -1,34 +1,22 @@
using System; using System;
using System.IO; using GC.Services;
namespace GC.Savedog; namespace GC.Savedog;
/// <summary>同时写 stdout 与 .GC/update/savedog.log,便于用户离线排查。</summary> /// <summary>
/// 守护进程的日志入口,实际写入 <see cref="GcLog"/>:控制台 + <c>.GC/logs</c> 下的
/// <c>gc-YYYYMMDD.log</c>(中文)与 <c>gc-YYYYMMDD.en.log</c>(英文)。
///
/// 每条日志都必须同时给中英两份文案 —— 用户反馈问题时直接发对应语言的文件。
/// </summary>
internal sealed class Log internal sealed class Log
{ {
private readonly string? _path; public Log(string? dir)
private readonly object _gate = new();
public Log(string? path) => _path = path;
public void Info(string message) => Write("INFO ", message);
public void Warn(string message) => Write("WARN ", message);
public void Error(string message) => Write("ERROR", message);
private void Write(string level, string message)
{ {
var line = $"{DateTime.Now:yyyy-MM-dd HH:mm:ss} [{level}] {message}"; if (!string.IsNullOrWhiteSpace(dir)) GcLog.Init(dir);
Console.WriteLine(line);
if (string.IsNullOrWhiteSpace(_path)) return;
try
{
lock (_gate)
{
var dir = Path.GetDirectoryName(_path!);
if (!string.IsNullOrEmpty(dir)) Directory.CreateDirectory(dir);
File.AppendAllText(_path!, line + "\n");
}
}
catch { /* 日志失败不能影响更新 */ }
} }
public void Info(string zh, string en) => GcLog.Info(zh, en);
public void Warn(string zh, string en) => GcLog.Warn(zh, en);
public void Error(string zh, string en) => GcLog.Error(zh, en);
} }
+5 -2
View File
@@ -23,7 +23,7 @@ namespace GC.Savedog;
/// </summary> /// </summary>
internal static class Program internal static class Program
{ {
private const string DefaultKeyId = "gc-2026-11"; private const string DefaultKeyId = "gc-2026-12";
private const string DefaultKeyPath = ".signing/gc-signing.pem"; private const string DefaultKeyPath = ".signing/gc-signing.pem";
private static int Main(string[] args) private static int Main(string[] args)
@@ -67,7 +67,10 @@ internal static class Program
return 3; return 3;
} }
var log = new Log(Path.Combine(Path.GetFullPath(updateDir), SavedogFiles.Log)); // 日志统一放 .GC/logs(update 目录的上一层),不再塞在 update/ 里
var updateRoot = Path.GetFullPath(updateDir);
var home = Path.GetDirectoryName(updateRoot) ?? updateRoot;
var log = new Log(Path.Combine(home, "logs"));
var applyOptions = new ApplyOptions var applyOptions = new ApplyOptions
{ {
UpdateDir = updateDir, UpdateDir = updateDir,
+73 -3
View File
@@ -1,6 +1,9 @@
# GC-UI 持续集成 # GC-UI 持续集成
夜间 alpha 构建的工作流在 [`.gitea/workflows/gc-ui-alpha.yml`](../.gitea/workflows/gc-ui-alpha.yml)。 alpha 构建的工作流在 [`.gitea/workflows/gc-ui-alpha.yml`](../.gitea/workflows/gc-ui-alpha.yml),
**只支持手动触发**(定时任务已取消:它绕开 build.sh,产出的包没有后端、没有前端,跑起来只是个空壳;
另外 `cron` 里的 `TZ=` 前缀在部分 Gitea 版本上是非法表达式)。
PR 审核流水线在 [`.gitea/workflows/pr-check.yml`](../.gitea/workflows/pr-check.yml)。
本仓库是自建 Gitea(不是 GitHub),所以目录是 `.gitea/workflows/`,语法与 GitHub Actions 基本一致, 本仓库是自建 Gitea(不是 GitHub),所以目录是 `.gitea/workflows/`,语法与 GitHub Actions 基本一致,
差异集中在 **runner 标签** 和 **API 前缀** 两处。 差异集中在 **runner 标签** 和 **API 前缀** 两处。
@@ -64,9 +67,76 @@ Windows 还需要 **VS Build Tools 的「使用 C++ 的桌面开发」工作负
## 本地构建(不经 CI) ## 本地构建(不经 CI)
```bash ```bash
# macOS # 按构建主机自动选目标,每条产物都带 Flutter 前端:
# macOS 主机 → mac-arm64(原生)+ win-amd64 / win-arm64(mingw 交叉)
# Linux 主机 → win-amd64 / win-arm64(mingw 交叉)
# Linux 产物默认不出:需 aarch64 主机 + GC_BUILD_LINUX=1
# Windows 主机 → win-amd64 / win-arm64(原生)
./build.sh build
# 前端是必需项:flutter 缺失或编译失败会直接中断,
# 确需降级成只有 Avalonia 回退界面的包时才用:
./build.sh build --allow-no-ui
# 只编 macOS 前端
./GC-UI/build-ui.sh macos ./GC-UI/build-ui.sh macos
# Windows # Windows 主机原生构建
GC-UI\build-ui.cmd GC-UI\build-ui.cmd
``` ```
### Linux 前端(原生)
Flutter 的 Linux 桌面端只能在 Linux 上编,需要 GTK3 开发库与 C++ 工具链:
```bash
sudo apt install clang cmake ninja-build pkg-config libgtk-3-dev libstdc++-14-dev
```
`libstdc++-14-dev` 容易漏:clang 18 会去 `/usr/lib/gcc/x86_64-linux-gnu/14/` 找
`-lstdc++`,系统只装了 gcc-13 的开发包时链接会失败,报 `cannot find -lstdc++`。
产物布局:`GC-UI` + `lib/libflutter_linux_gtk.so` + `data/`,与官方 `flutter build
linux` 的 bundle 一致,直接铺进 `dist/linux-arm64/`。
### Windows 前端交叉编译
Flutter 官方不支持在非 Windows 主机上 `flutter build windows`,但 Windows 嵌入层
(`windows/runner/*.cpp` + `cpp_client_wrapper`)是纯 Win32 + 标准 C++,只通过 C ABI
调用 `flutter_windows.dll`,所以 mingw-w64 就能编译。整条链路上唯一必须执行的
Windows 二进制是 AOT 快照生成器 `gen_snapshot.exe`,交给 wine 跑即可。
```bash
# 依赖
sudo apt install mingw-w64 cmake ninja-build wine # Linux
brew install mingw-w64 cmake ninja # macOS
brew install --cask wine-stable # macOS 的 wine
# 单独构建(默认输出到 GC-UI/frontend/build/windows/x64/runner/Release)
./buildsh/cross/build-ui-win-cross.sh [输出目录]
```
产物与官方 toolchain 完全一致,可直接拷到 Windows 运行:
```
GC-UI.exe flutter_windows.dll data/{icudtl.dat, app.so, flutter_assets/}
```
实现分三层:
| 文件 | 职责 |
|---|---|
| `buildsh/cross/toolchain-mingw.cmake` | CMake 交叉工具链(posix 线程模型,静态链接 libstdc++,产物只依赖系统 DLL) |
| `buildsh/cross/CMakeLists.txt` | 只编 C++ 外壳;绕开 `tool_backend.bat` 与 MSVC 专用参数 |
| `buildsh/cross/build-ui-win-cross.sh` | 拉引擎产物、装 `gen_snapshot` 的 wine 包装、生成 AOT 快照、组装 |
两个容易踩的坑,脚本里已处理:
- `flutter_tools` 会 exec 路径为 `.../windows-x64-release/gen_snapshot`(**没有 `.exe`**)
的文件,所以脚本在原 `.exe` 旁边放一个同名 shell 脚本转调 wine。
- `Runner.rc` 在 windres 下有两处不兼容:图标用反斜杠相对路径、`VERSION_AS_STRING`
依赖命令行传 `-D` 的转义字符串。脚本生成一份路径与宏都已规整的 rc 副本再编译。
`.gitea/workflows` 里的 `windows` 任务仍然跑在 `windows-latest` 上;若手头只有 macOS/Linux
构建机,可以把该任务的 `runs-on` 换成对应标签,直接复用这套交叉编译脚本,
不再需要 VS Build Tools。
+5 -1
View File
@@ -65,7 +65,11 @@ dotnet run --project GC-UI/backend/GC.UI.Server -- --port 17890
GC_UI_PORT=17890 dotnet run --project GC-UI/backend/GC.UI.Server GC_UI_PORT=17890 dotnet run --project GC-UI/backend/GC.UI.Server
``` ```
启动后会在 `~/.GC/ui-backend.json` 写入 `{ port, pid, url, version, platform }`,前端可据此发现端口。 端口约定集中在 `GC.Services.GcUiContract`(`DefaultPort` / `PortEnvVar`):
正式启动时由 GC-BOOT 选端口(17890 被占用就往后试 9 个),再通过 `GC_UI_PORT`
环境变量同时传给后端和前端,所以**不需要为了换端口重新编译前端**。
启动后后端会在 `~/.GC/ui-backend.json` 写入 `{ port, pid, url, version, platform }`,
排查问题时可以据此确认实际端口。
### 2. 启动前端 ### 2. 启动前端
+11
View File
@@ -74,6 +74,7 @@ public sealed record LanguageDto(string Code, string Label);
public sealed record SettingsDto( public sealed record SettingsDto(
string Language, string Language,
string Theme, string Theme,
string AccentColor,
int RenderFps, int RenderFps,
int MemoryMb, int MemoryMb,
bool MemoryAuto, bool MemoryAuto,
@@ -96,6 +97,7 @@ public sealed record SettingsDto(
public sealed record SettingsPatch( public sealed record SettingsPatch(
string? Language, string? Language,
string? Theme, string? Theme,
string? AccentColor,
int? RenderFps, int? RenderFps,
int? MemoryMb, int? MemoryMb,
bool? MemoryAuto, bool? MemoryAuto,
@@ -131,6 +133,15 @@ public sealed record AboutDto(
public sealed record LaunchResultDto(bool Ok, string Message); public sealed record LaunchResultDto(bool Ok, string Message);
/// <summary>
/// 通用错误响应。限流 / 参数校验这类与具体业务无关的失败用它,
/// 不要复用 <see cref="LaunchResultDto"/> —— 那会让前端误以为「启动模型」有结果。
/// </summary>
public sealed record ErrorDto(bool Ok, string Message)
{
public static ErrorDto Of(string message) => new(false, message);
}
public sealed record DownloadRequest(string SourceId, string ModelId); public sealed record DownloadRequest(string SourceId, string ModelId);
public sealed record PathRequest(string Path); public sealed record PathRequest(string Path);
+29 -3
View File
@@ -28,7 +28,7 @@ public sealed class AvaloniaHost
{ {
private readonly AppServices _services; private readonly AppServices _services;
private readonly object _gate = new(); private readonly object _gate = new();
private readonly List<PlayerWindow> _windows = new(); private readonly Dictionary<string, PlayerWindow> _windows = new(StringComparer.OrdinalIgnoreCase);
private Task<bool>? _startTask; private Task<bool>? _startTask;
public AvaloniaHost(AppServices services) => _services = services; public AvaloniaHost(AppServices services) => _services = services;
@@ -98,6 +98,27 @@ public sealed class AvaloniaHost
return await Dispatcher.UIThread.InvokeAsync<string>(async () => return await Dispatcher.UIThread.InvokeAsync<string>(async () =>
{ {
// 同一个模型已经在运行:把已有窗口提到前台,不再加载第二份实例
// (连点「启动模型」会各占一份内存与显存,低配机器直接卡死)。
lock (_gate)
{
if (_windows.TryGetValue(package.Id, out var existing))
{
try
{
if (existing.WindowState == WindowState.Minimized)
existing.WindowState = WindowState.Normal;
existing.Activate();
return $"模型 {package.Id} 已在运行";
}
catch
{
// 窗口已失效:清掉记录,按新窗口重新打开
_windows.Remove(package.Id);
}
}
}
PlayerWindow? window = null; PlayerWindow? window = null;
LoadedModel? loaded = null; LoadedModel? loaded = null;
try try
@@ -111,13 +132,18 @@ public sealed class AvaloniaHost
window = new PlayerWindow(package, loaded); window = new PlayerWindow(package, loaded);
var captured = loaded; var captured = loaded;
var id = package.Id;
window.Closed += (_, _) => window.Closed += (_, _) =>
{ {
try { captured.Dispose(); } catch { /* 释放失败不影响退出 */ } try { captured.Dispose(); } catch { /* 释放失败不影响退出 */ }
lock (_gate) _windows.Remove(window!); lock (_gate)
{
if (_windows.TryGetValue(id, out var current) && ReferenceEquals(current, window))
_windows.Remove(id);
}
}; };
lock (_gate) _windows.Add(window); lock (_gate) _windows[id] = window;
window.Show(); window.Show();
return $"已启动模型 {package.Id}"; return $"已启动模型 {package.Id}";
} }
+183 -21
View File
@@ -53,18 +53,113 @@ var builder = WebApplication.CreateBuilder(new WebApplicationOptions { Args = ar
builder.Logging.ClearProviders(); builder.Logging.ClearProviders();
builder.WebHost.UseUrls($"http://127.0.0.1:{port}"); builder.WebHost.UseUrls($"http://127.0.0.1:{port}");
// 本地伴随进程:限制请求体大小、关闭 Server 头、收紧超时,减少被本地恶意页面
// 或异常客户端拖垮的攻击面。
builder.WebHost.ConfigureKestrel(options =>
{
options.AddServerHeader = false;
options.Limits.MaxRequestBodySize = 2 * 1024 * 1024;
options.Limits.RequestHeadersTimeout = TimeSpan.FromSeconds(15);
options.Limits.KeepAliveTimeout = TimeSpan.FromMinutes(2);
options.Limits.MaxConcurrentConnections = 64;
});
// 桌面端(Windows/macOS)走原生 HTTP,不需要 CORS; // 桌面端(Windows/macOS)走原生 HTTP,不需要 CORS;
// 这里放开本机回环来源,方便用 `flutter run -d chrome` 调试界面。 // 这里放开本机回环来源,方便用 `flutter run -d chrome` 调试界面。
builder.Services.AddCors(options => options.AddDefaultPolicy(policy => policy builder.Services.AddCors(options => options.AddDefaultPolicy(policy => policy
.SetIsOriginAllowed(origin => .SetIsOriginAllowed(origin =>
Uri.TryCreate(origin, UriKind.Absolute, out var uri) && Uri.TryCreate(origin, UriKind.Absolute, out var uri) &&
(uri.Host == "127.0.0.1" || uri.Host == "localhost")) (uri.Host == "127.0.0.1" || uri.Host == "localhost" || uri.Host == "::1"))
.AllowAnyHeader() .AllowAnyHeader()
.AllowAnyMethod())); .AllowAnyMethod()));
var app = builder.Build(); var app = builder.Build();
app.UseCors(); app.UseCors();
// 日志与启动器共用 .GC/logs,整条启动链路(启动器 → 后端 → 守护进程)都在同一组文件里。
var logPaths = AppPaths.Discover();
GcLog.Init(logPaths.LogsRoot);
GcLog.Info($"GC-UI 后端启动,监听 127.0.0.1:{port}",
$"GC-UI backend started on 127.0.0.1:{port}");
// 设置白名单 / 标识校验用到的规则(只在本进程内使用)。
var allowedLanguages = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
{ "auto", "zh-CN", "en" };
var allowedThemes = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
{ "light", "dark", "system" };
var accentHexRegex = new System.Text.RegularExpressions.Regex(
"^#(?:[0-9A-Fa-f]{6})$", System.Text.RegularExpressions.RegexOptions.Compiled);
var safeIdRegex = new System.Text.RegularExpressions.Regex(
"^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$", System.Text.RegularExpressions.RegexOptions.Compiled);
// 安全响应头 + Host/Origin 校验(抵御 DNS rebinding 与跨站调用)。
app.Use(async (context, next) =>
{
var headers = context.Response.Headers;
headers["X-Content-Type-Options"] = "nosniff";
headers["X-Frame-Options"] = "DENY";
headers["Referrer-Policy"] = "no-referrer";
headers["Content-Security-Policy"] = "default-src 'none'; frame-ancestors 'none'";
headers["Cache-Control"] = "no-store";
var host = context.Request.Host.Host;
if (!string.Equals(host, "127.0.0.1", StringComparison.OrdinalIgnoreCase) &&
!string.Equals(host, "localhost", StringComparison.OrdinalIgnoreCase) &&
!string.Equals(host, "::1", StringComparison.OrdinalIgnoreCase))
{
context.Response.StatusCode = StatusCodes.Status403Forbidden;
return;
}
var origin = context.Request.Headers.Origin.ToString();
if (!string.IsNullOrEmpty(origin) &&
!(Uri.TryCreate(origin, UriKind.Absolute, out var parsed) &&
(parsed.Host == "127.0.0.1" || parsed.Host == "localhost" || parsed.Host == "::1")))
{
context.Response.StatusCode = StatusCodes.Status403Forbidden;
return;
}
await next();
});
// 写入类接口做简单限流:单 IP 每秒最多 40 次,防止本地脚本刷爆下载/更新。
var writeBuckets =
new System.Collections.Concurrent.ConcurrentDictionary<string, (long Window, int Count)>();
app.Use(async (context, next) =>
{
if (HttpMethods.IsPost(context.Request.Method) ||
HttpMethods.IsDelete(context.Request.Method))
{
var key = context.Connection.RemoteIpAddress?.ToString() ?? "local";
var now = Environment.TickCount64;
// 定期丢弃过期窗口:本机连接数不多,但长时间运行后桶只增不减会缓慢泄漏。
if (writeBuckets.Count > 256)
{
foreach (var entry in writeBuckets)
{
if (now - entry.Value.Window > 60_000)
writeBuckets.TryRemove(entry.Key, out _);
}
}
var bucket = writeBuckets.AddOrUpdate(
key,
_ => (now, 1),
(_, old) => now - old.Window > 1000 ? (now, 1) : (old.Window, old.Count + 1));
if (bucket.Count > 40)
{
context.Response.StatusCode = StatusCodes.Status429TooManyRequests;
await context.Response.WriteAsJsonAsync(ErrorDto.Of("请求过于频繁,请稍后再试"));
return;
}
}
await next();
});
// ---- 健康检查 ------------------------------------------------------------- // ---- 健康检查 -------------------------------------------------------------
app.MapGet("/api/health", () => Results.Ok(new HealthDto( app.MapGet("/api/health", () => Results.Ok(new HealthDto(
@@ -79,15 +174,21 @@ app.MapGet("/api/health", () => Results.Ok(new HealthDto(
app.MapGet("/api/models", () => app.MapGet("/api/models", () =>
Results.Ok(services.Models.Scan().Select(ToModelDto).ToList())); Results.Ok(services.Models.Scan().Select(ToModelDto).ToList()));
app.MapGet("/api/models/{id}/preview", (string id) => app.MapGet("/api/models/{id}/preview", (string id, HttpResponse response) =>
{ {
if (!IsSafeId(id)) return Results.BadRequest(ErrorDto.Of("模型标识无效"));
var package = services.Models.Find(id); var package = services.Models.Find(id);
if (package == null || !File.Exists(package.PreviewPath)) return Results.NotFound(); if (package == null || !File.Exists(package.PreviewPath)) return Results.NotFound();
return Results.File(package.PreviewPath, "image/png");
// 封面是静态图,允许前端缓存:默认全局中间件写的 no-store 会让每次滚动都重新请求。
// 按扩展名给准确的 MIME —— 统一写 image/png 时,WebP / JPEG 封面在部分平台显示不出来。
response.Headers.CacheControl = "private, max-age=300";
return Results.File(package.PreviewPath, GuessImageContentType(package.PreviewPath));
}); });
app.MapPost("/api/models/{id}/launch", async (string id) => app.MapPost("/api/models/{id}/launch", async (string id) =>
{ {
if (!IsSafeId(id)) return Results.BadRequest(new LaunchResultDto(false, "模型标识无效"));
var package = services.Models.Find(id); var package = services.Models.Find(id);
if (package == null) return Results.NotFound(new LaunchResultDto(false, $"没有找到模型 {id}")); if (package == null) return Results.NotFound(new LaunchResultDto(false, $"没有找到模型 {id}"));
@@ -99,17 +200,20 @@ app.MapPost("/api/models/{id}/launch", async (string id) =>
} }
catch (Exception ex) catch (Exception ex)
{ {
return Results.Json(new LaunchResultDto(false, ex.Message), statusCode: 503); // 细节只写日志,不回显给调用方,避免泄漏本机路径等内部信息。
Console.Error.WriteLine($"[launch] 启动模型 {id} 失败: {ex}");
return Results.Json(new LaunchResultDto(false, "模型启动失败,请查看后端日志"), statusCode: 503);
} }
}); });
app.MapDelete("/api/models/{id}", (string id) => app.MapDelete("/api/models/{id}", (string id) =>
{ {
if (!IsSafeId(id)) return Results.BadRequest(ErrorDto.Of("模型标识无效"));
var ok = services.Models.Delete(id); var ok = services.Models.Delete(id);
if (ok) services.Models.NotifyChanged(); if (ok) services.Models.NotifyChanged();
return ok return ok
? Results.Ok(new LaunchResultDto(true, $"已删除模型 {id}")) ? Results.Ok(new LaunchResultDto(true, $"已删除模型 {id}"))
: Results.NotFound(new LaunchResultDto(false, $"没有找到模型 {id}")); : Results.NotFound(ErrorDto.Of($"没有找到模型 {id}"));
}); });
// ---- 设置 ----------------------------------------------------------------- // ---- 设置 -----------------------------------------------------------------
@@ -118,12 +222,23 @@ app.MapGet("/api/settings", () => Results.Ok(ToSettingsDto()));
app.MapPost("/api/settings", (SettingsPatch? patch) => app.MapPost("/api/settings", (SettingsPatch? patch) =>
{ {
if (patch == null) return Results.BadRequest(new LaunchResultDto(false, "缺少设置内容")); if (patch == null) return Results.BadRequest(ErrorDto.Of("缺少设置内容"));
// 白名单校验:设置项会写进磁盘并被前端直接使用,不接受任意字符串。
if (patch.Language != null && !allowedLanguages.Contains(patch.Language))
return Results.BadRequest(ErrorDto.Of("不支持的界面语言"));
if (patch.Theme != null && !allowedThemes.Contains(patch.Theme))
return Results.BadRequest(ErrorDto.Of("不支持的主题"));
if (patch.AccentColor != null && !accentHexRegex.IsMatch(patch.AccentColor))
return Results.BadRequest(ErrorDto.Of("主题色需为 #RRGGBB"));
if (patch.UpdateRepository != null && !IsAllowedRepository(patch.UpdateRepository))
return Results.BadRequest(ErrorDto.Of("更新仓库地址不受信任"));
services.Settings.Apply(s => services.Settings.Apply(s =>
{ {
if (patch.Language != null) s.Language = patch.Language; if (patch.Language != null) s.Language = patch.Language;
if (patch.Theme != null) s.Theme = patch.Theme; if (patch.Theme != null) s.Theme = patch.Theme;
if (patch.AccentColor != null) s.AccentColor = patch.AccentColor.ToUpperInvariant();
if (patch.RenderFps.HasValue) s.RenderFps = Math.Clamp(patch.RenderFps.Value, 12, 120); if (patch.RenderFps.HasValue) s.RenderFps = Math.Clamp(patch.RenderFps.Value, 12, 120);
if (patch.MemoryMb.HasValue) s.MemoryMb = Math.Clamp(patch.MemoryMb.Value, 256, 16384); if (patch.MemoryMb.HasValue) s.MemoryMb = Math.Clamp(patch.MemoryMb.Value, 256, 16384);
if (patch.MemoryAuto.HasValue) s.MemoryAuto = patch.MemoryAuto.Value; if (patch.MemoryAuto.HasValue) s.MemoryAuto = patch.MemoryAuto.Value;
@@ -159,14 +274,15 @@ app.MapPost("/api/sources/select", async (ForceRequest? request) =>
} }
catch (Exception ex) catch (Exception ex)
{ {
return Results.Json(new LaunchResultDto(false, ex.Message), statusCode: 503); Console.Error.WriteLine($"[sources] 切换模型源失败: {ex}");
return Results.Json(ErrorDto.Of("模型源切换失败"), statusCode: 503);
} }
}); });
app.MapGet("/api/remote/models", async (string? sourceId, bool force) => app.MapGet("/api/remote/models", async (string? sourceId, bool force) =>
{ {
var source = ResolveSource(sourceId); var source = ResolveSource(sourceId);
if (source == null) return Results.NotFound(new LaunchResultDto(false, "没有可用的模型源")); if (source == null) return Results.NotFound(ErrorDto.Of("没有可用的模型源"));
var index = await services.Sources.FetchAsync(source, force, null, CancellationToken.None); var index = await services.Sources.FetchAsync(source, force, null, CancellationToken.None);
var installed = services.Models.Scan() var installed = services.Models.Scan()
@@ -195,16 +311,16 @@ app.MapGet("/api/remote/models", async (string? sourceId, bool force) =>
app.MapPost("/api/download", async (DownloadRequest? request) => app.MapPost("/api/download", async (DownloadRequest? request) =>
{ {
if (request == null || string.IsNullOrWhiteSpace(request.ModelId)) if (request == null || string.IsNullOrWhiteSpace(request.ModelId))
return Results.BadRequest(new LaunchResultDto(false, "缺少 modelId")); return Results.BadRequest(ErrorDto.Of("缺少 modelId"));
var source = ResolveSource(request.SourceId); var source = ResolveSource(request.SourceId);
if (source == null) return Results.NotFound(new LaunchResultDto(false, "没有可用的模型源")); if (source == null) return Results.NotFound(ErrorDto.Of("没有可用的模型源"));
var index = await services.Sources.FetchAsync(source, false, null, CancellationToken.None); var index = await services.Sources.FetchAsync(source, false, null, CancellationToken.None);
var model = index.Models.FirstOrDefault(m => var model = index.Models.FirstOrDefault(m =>
m.Id.Equals(request.ModelId, StringComparison.OrdinalIgnoreCase)); m.Id.Equals(request.ModelId, StringComparison.OrdinalIgnoreCase));
if (model == null) if (model == null)
return Results.NotFound(new LaunchResultDto(false, $"源里没有模型 {request.ModelId}")); return Results.NotFound(ErrorDto.Of($"源里没有模型 {request.ModelId}"));
var job = services.Downloads.Enqueue(model); var job = services.Downloads.Enqueue(model);
return Results.Ok(ToJobDto(job)); return Results.Ok(ToJobDto(job));
@@ -313,11 +429,11 @@ app.MapPost("/api/shell/open-folder", (PathRequest? request) =>
{ {
var path = request?.Path; var path = request?.Path;
if (string.IsNullOrWhiteSpace(path)) if (string.IsNullOrWhiteSpace(path))
return Results.BadRequest(new LaunchResultDto(false, "缺少 path")); return Results.BadRequest(ErrorDto.Of("缺少 path"));
// 只允许打开启动器自己的目录,避免前端被当成任意路径执行器 // 只允许打开启动器自己的目录,避免前端被当成任意路径执行器
if (!IsInsideKnownRoot(path!)) if (!IsInsideKnownRoot(path!))
return Results.BadRequest(new LaunchResultDto(false, "只允许打开启动器自己的目录")); return Results.BadRequest(ErrorDto.Of("只允许打开启动器自己的目录"));
Shell.OpenFolder(path!); Shell.OpenFolder(path!);
return Results.Ok(new LaunchResultDto(true, "已打开目录")); return Results.Ok(new LaunchResultDto(true, "已打开目录"));
@@ -326,11 +442,15 @@ app.MapPost("/api/shell/open-folder", (PathRequest? request) =>
app.MapPost("/api/shell/open-url", (UrlRequest? request) => app.MapPost("/api/shell/open-url", (UrlRequest? request) =>
{ {
var url = request?.Url; var url = request?.Url;
if (string.IsNullOrWhiteSpace(url) || !Uri.TryCreate(url, UriKind.Absolute, out var uri)) if (string.IsNullOrWhiteSpace(url) || url.Length > 2048 ||
return Results.BadRequest(new LaunchResultDto(false, "URL 无效")); !Uri.TryCreate(url, UriKind.Absolute, out var uri))
return Results.BadRequest(ErrorDto.Of("URL 无效"));
if (uri.Scheme != Uri.UriSchemeHttp && uri.Scheme != Uri.UriSchemeHttps) if (uri.Scheme != Uri.UriSchemeHttp && uri.Scheme != Uri.UriSchemeHttps)
return Results.BadRequest(new LaunchResultDto(false, "只允许 http/https 链接")); return Results.BadRequest(ErrorDto.Of("只允许 http/https 链接"));
if (!string.IsNullOrEmpty(uri.UserInfo))
return Results.BadRequest(ErrorDto.Of("URL 不允许携带账号密码"));
Shell.OpenUrl(url!); Shell.OpenUrl(url!);
return Results.Ok(new LaunchResultDto(true, "已打开链接")); return Results.Ok(new LaunchResultDto(true, "已打开链接"));
@@ -350,7 +470,8 @@ app.Run();
static int ResolvePort(string[] args) static int ResolvePort(string[] args)
{ {
var env = Environment.GetEnvironmentVariable("GC_UI_PORT"); // 优先用启动器传来的端口(GC_UI_PORT),保证前端拼出来的 baseUrl 和这里一致。
var env = Environment.GetEnvironmentVariable(GcUiContract.PortEnvVar);
if (int.TryParse(env, out var fromEnv) && fromEnv > 0 && fromEnv < 65536) return fromEnv; if (int.TryParse(env, out var fromEnv) && fromEnv > 0 && fromEnv < 65536) return fromEnv;
for (var i = 0; i < args.Length; i++) for (var i = 0; i < args.Length; i++)
@@ -365,7 +486,7 @@ static int ResolvePort(string[] args)
return inline; return inline;
} }
return 17890; return GcUiContract.DefaultPort;
} }
static void WriteEndpointFile(AppServices services, int port) static void WriteEndpointFile(AppServices services, int port)
@@ -391,8 +512,18 @@ static void WriteEndpointFile(AppServices services, int port)
} }
} }
ModelDto ToModelDto(ModelPackage package) => new( /// <summary>按扩展名推断图片 MIME;模型封面允许 png / jpg / webp / gif。</summary>
package.Id, static string GuessImageContentType(string path) => Path.GetExtension(path).ToLowerInvariant() switch
{
".jpg" or ".jpeg" => "image/jpeg",
".webp" => "image/webp",
".gif" => "image/gif",
".bmp" => "image/bmp",
".svg" => "image/svg+xml",
_ => "image/png"
};
ModelDto ToModelDto(ModelPackage package) => new( package.Id,
package.LocalizedName, package.LocalizedName,
package.LocalizedDescription, package.LocalizedDescription,
package.Manifest.Version, package.Manifest.Version,
@@ -416,6 +547,7 @@ SourceDto ToSourceDto(ModelSource source) => new(
SettingsDto ToSettingsDto() => new( SettingsDto ToSettingsDto() => new(
services.Settings.Current.Language, services.Settings.Current.Language,
services.Settings.Current.Theme, services.Settings.Current.Theme,
services.Settings.Current.AccentColor,
services.Settings.Current.RenderFps, services.Settings.Current.RenderFps,
services.Settings.Current.MemoryMb, services.Settings.Current.MemoryMb,
services.Settings.Current.MemoryAuto, services.Settings.Current.MemoryAuto,
@@ -464,9 +596,10 @@ ModelSource? ResolveSource(string? sourceId)
IResult ActOnJob(string id, Action<IDownloadJob> action) IResult ActOnJob(string id, Action<IDownloadJob> action)
{ {
if (!IsSafeId(id)) return Results.BadRequest(ErrorDto.Of("任务标识无效"));
var job = services.Downloads.Jobs.FirstOrDefault(j => var job = services.Downloads.Jobs.FirstOrDefault(j =>
j.Id.Equals(id, StringComparison.OrdinalIgnoreCase)); j.Id.Equals(id, StringComparison.OrdinalIgnoreCase));
if (job == null) return Results.NotFound(new LaunchResultDto(false, $"没有找到任务 {id}")); if (job == null) return Results.NotFound(ErrorDto.Of($"没有找到任务 {id}"));
action(job); action(job);
return Results.Ok(ToJobDto(job)); return Results.Ok(ToJobDto(job));
@@ -501,3 +634,32 @@ bool IsInsideKnownRoot(string path)
return false; return false;
} }
// 路由标识:只允许字母数字开头,后接字母数字/点/下划线/短横线,长度上限 64。
// 用于模型 id、任务 id,杜绝 `../` 之类的路径穿越尝试。
bool IsSafeId(string? id) => !string.IsNullOrEmpty(id) && safeIdRegex.IsMatch(id);
// 更新仓库地址:必须是 https、不带账号密码、不是回环/内网 IP。
// 防止把本地后端当成 SSRF 跳板去访问内网服务。
bool IsAllowedRepository(string value)
{
if (string.IsNullOrWhiteSpace(value)) return false;
if (!Uri.TryCreate(value, UriKind.Absolute, out var uri)) return false;
if (uri.Scheme != Uri.UriSchemeHttps) return false;
if (!string.IsNullOrEmpty(uri.UserInfo)) return false;
if (string.Equals(uri.Host, "localhost", StringComparison.OrdinalIgnoreCase)) return false;
if (System.Net.IPAddress.TryParse(uri.Host, out var ip) &&
(System.Net.IPAddress.IsLoopback(ip) || IsPrivateAddress(ip)))
return false;
return true;
}
static bool IsPrivateAddress(System.Net.IPAddress ip)
{
var bytes = ip.GetAddressBytes();
if (bytes.Length != 4) return false;
return bytes[0] == 10
|| (bytes[0] == 172 && bytes[1] >= 16 && bytes[1] <= 31)
|| (bytes[0] == 192 && bytes[1] == 168)
|| (bytes[0] == 169 && bytes[1] == 254);
}
+3
View File
@@ -15,6 +15,9 @@ migration:
- platform: root - platform: root
create_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668 create_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668
base_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668 base_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668
- platform: linux
create_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668
base_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668
- platform: macos - platform: macos
create_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668 create_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668
base_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668 base_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668
+64 -9
View File
@@ -1,4 +1,5 @@
import 'dart:convert'; import 'dart:convert';
import 'dart:io';
import 'package:http/http.dart' as http; import 'package:http/http.dart' as http;
@@ -152,6 +153,7 @@ class SettingsInfo {
SettingsInfo.fromJson(Map<String, dynamic> json) SettingsInfo.fromJson(Map<String, dynamic> json)
: language = json['language'] as String? ?? 'auto', : language = json['language'] as String? ?? 'auto',
theme = json['theme'] as String? ?? 'light', theme = json['theme'] as String? ?? 'light',
accentColor = json['accentColor'] as String? ?? '#8FB6FF',
renderFps = (json['renderFps'] as num?)?.toInt() ?? 120, renderFps = (json['renderFps'] as num?)?.toInt() ?? 120,
memoryMb = (json['memoryMb'] as num?)?.toInt() ?? 2048, memoryMb = (json['memoryMb'] as num?)?.toInt() ?? 2048,
memoryAuto = json['memoryAuto'] as bool? ?? true, memoryAuto = json['memoryAuto'] as bool? ?? true,
@@ -176,6 +178,7 @@ class SettingsInfo {
final String language; final String language;
final String theme; final String theme;
final String accentColor;
final int renderFps; final int renderFps;
final int memoryMb; final int memoryMb;
final bool memoryAuto; final bool memoryAuto;
@@ -200,6 +203,7 @@ class SettingsPatch {
const SettingsPatch({ const SettingsPatch({
this.language, this.language,
this.theme, this.theme,
this.accentColor,
this.renderFps, this.renderFps,
this.memoryMb, this.memoryMb,
this.memoryAuto, this.memoryAuto,
@@ -212,6 +216,7 @@ class SettingsPatch {
final String? language; final String? language;
final String? theme; final String? theme;
final String? accentColor;
final int? renderFps; final int? renderFps;
final int? memoryMb; final int? memoryMb;
final bool? memoryAuto; final bool? memoryAuto;
@@ -225,6 +230,7 @@ class SettingsPatch {
final map = <String, dynamic>{}; final map = <String, dynamic>{};
if (language != null) map['language'] = language; if (language != null) map['language'] = language;
if (theme != null) map['theme'] = theme; if (theme != null) map['theme'] = theme;
if (accentColor != null) map['accentColor'] = accentColor;
if (renderFps != null) map['renderFps'] = renderFps; if (renderFps != null) map['renderFps'] = renderFps;
if (memoryMb != null) map['memoryMb'] = memoryMb; if (memoryMb != null) map['memoryMb'] = memoryMb;
if (memoryAuto != null) map['memoryAuto'] = memoryAuto; if (memoryAuto != null) map['memoryAuto'] = memoryAuto;
@@ -329,16 +335,65 @@ List<String> _stringList(dynamic value) =>
/// GC-UI 后端客户端。 /// GC-UI 后端客户端。
/// ///
/// 后端是本地伴随进程,默认监听 127.0.0.1:17890;端口可用 /// 后端是本地伴随进程,端口由启动器(GC-BOOT)选定后通过 `GC_UI_PORT`
/// `--dart-define=GC_UI_BASE_URL=http://127.0.0.1:12345` 覆盖。 /// 环境变量传进来 —— 这样端口被占用时换端口不用重新编译前端。
/// 也可用 `--dart-define=GC_UI_BASE_URL=http://127.0.0.1:12345` 强制指定。
class GcApi { class GcApi {
GcApi({String? baseUrl}) GcApi({String? baseUrl})
: baseUrl = baseUrl ?? defaultBaseUrl; : baseUrl = baseUrl ?? defaultBaseUrl;
static const String defaultBaseUrl = String.fromEnvironment( /// 复用同一个 HTTP 连接:轮询(下载任务每秒一次)时每次都新建连接
'GC_UI_BASE_URL', /// 会不断握手,桌面端也能明显看到延迟抖动。
defaultValue: 'http://127.0.0.1:17890', static final http.Client _client = http.Client();
);
/// 兜底默认端口,与后端 GC.Services.GcUiContract.DefaultPort 保持一致。
static const int fallbackPort = 17890;
static String get defaultBaseUrl {
const fromDefine = String.fromEnvironment('GC_UI_BASE_URL');
if (fromDefine.isNotEmpty) return fromDefine;
final fromEnvUrl = Platform.environment['GC_UI_BASE_URL'];
if (fromEnvUrl != null && fromEnvUrl.isNotEmpty) return fromEnvUrl;
// 启动器通过 GC_UI_PORT 传端口(主路径)。
final port = int.tryParse(Platform.environment['GC_UI_PORT'] ?? '');
if (port != null) return 'http://127.0.0.1:$port';
// 手动起后端 / 前端调试时没有环境变量:读后端写的 .GC/ui-backend.json。
final discovered = _endpointFileUrl();
if (discovered != null) return discovered;
return 'http://127.0.0.1:$fallbackPort';
}
/// 从运行目录下的 `.GC/ui-backend.json` 发现后端地址。
///
/// 后端每次启动都会写这个文件(port / pid / url)。只认 24 小时内的记录:
/// 更早的多半是上次遗留的,连过去只会得到一个「无法连接」。
static String? _endpointFileUrl() {
try {
final file = File('${Directory.current.path}/.GC/ui-backend.json');
if (!file.existsSync()) return null;
final age = DateTime.now().difference(file.lastModifiedSync());
if (age.inHours >= 24) return null;
final decoded = jsonDecode(file.readAsStringSync());
if (decoded is! Map<String, dynamic>) return null;
final url = decoded['url'];
if (url is String && url.startsWith('http://127.0.0.1:')) return url;
final port = (decoded['port'] as num?)?.toInt();
if (port != null && port > 0 && port < 65536) {
return 'http://127.0.0.1:$port';
}
} catch (_) {
// 文件损坏 / 无权限:退回默认端口即可
}
return null;
}
final String baseUrl; final String baseUrl;
@@ -352,17 +407,17 @@ class GcApi {
try { try {
switch (method) { switch (method) {
case 'GET': case 'GET':
response = await http.get(uri).timeout(const Duration(seconds: 30)); response = await _client.get(uri).timeout(const Duration(seconds: 30));
break; break;
case 'POST': case 'POST':
response = await http response = await _client
.post(uri, .post(uri,
headers: const {'Content-Type': 'application/json'}, headers: const {'Content-Type': 'application/json'},
body: body == null ? null : jsonEncode(body)) body: body == null ? null : jsonEncode(body))
.timeout(const Duration(seconds: 120)); .timeout(const Duration(seconds: 120));
break; break;
case 'DELETE': case 'DELETE':
response = await http.delete(uri).timeout(const Duration(seconds: 30)); response = await _client.delete(uri).timeout(const Duration(seconds: 30));
break; break;
default: default:
throw ApiException('不支持的方法 $method'); throw ApiException('不支持的方法 $method');
+82 -9
View File
@@ -1,7 +1,10 @@
import 'dart:async';
import 'package:flutter/foundation.dart'; import 'package:flutter/foundation.dart';
import 'api_client.dart'; import 'api_client.dart';
import 'i18n.dart'; import 'i18n.dart';
import 'theme.dart';
/// 外壳状态:后端客户端 + 设置 + 健康状态 + 更新状态条。 /// 外壳状态:后端客户端 + 设置 + 健康状态 + 更新状态条。
/// ///
@@ -23,31 +26,94 @@ class ShellController extends ChangeNotifier {
String updateDetail = ''; String updateDetail = '';
String launcherNotice = ''; String launcherNotice = '';
/// 模型库版本号:安装 / 删除 / 下载完成后自增,首页据此重新拉列表。
///
/// 首页被 `Offstage` 保活,切走再切回不会重建;没有这个信号时,
/// 下载完模型回到首页仍然显示旧的空列表。
int modelsRevision = 0;
Timer? _retryTimer;
int _retryAttempt = 0;
bool get backendReady => settings != null; bool get backendReady => settings != null;
Future<void> bootstrap() async { Future<void> bootstrap() async {
try { _retryTimer?.cancel();
health = await api.health();
settings = await api.settings(); HealthInfo? healthResult;
loadError = null; SettingsInfo? settingsResult;
I18n.setLanguage(settings!.language); Object? firstError;
} catch (error) {
loadError = error.toString(); // 两个请求互不依赖,并行发;各自捕获异常,避免一方失败时
// 另一个的 Future 抛成未处理异常(Flutter 会在控制台打出恶性警告)。
await Future.wait<void>(<Future<void>>[
() async {
try {
healthResult = await api.health();
} catch (error) {
firstError ??= error;
}
}(),
() async {
try {
settingsResult = await api.settings();
} catch (error) {
firstError ??= error;
}
}(),
]);
if (healthResult != null) health = healthResult;
if (settingsResult != null) {
settings = settingsResult;
_applySettings(settingsResult!);
} }
if (firstError != null && settingsResult == null) {
loadError = firstError.toString();
_scheduleRetry();
} else {
loadError = null;
_retryAttempt = 0;
}
notifyListeners(); notifyListeners();
} }
/// 后端没起来时自动重试(2s、4s、8s…最多 5 次),不必让用户手动点。
void _scheduleRetry() {
if (_retryAttempt >= 5) return;
final seconds = 1 << _retryAttempt; // 1,2,4,8,16
_retryAttempt++;
_retryTimer?.cancel();
_retryTimer = Timer(Duration(seconds: seconds), () {
if (settings == null) bootstrap();
});
}
void _applySettings(SettingsInfo value) {
I18n.setLanguage(value.language);
GcPalette.apply(value.accentColor);
GcPalette.applyTheme(value.theme);
}
void goTo(int value) { void goTo(int value) {
if (index == value) return; if (index == value) return;
index = value; index = value;
notifyListeners(); notifyListeners();
} }
/// 模型库有变化(安装 / 删除 / 下载完成):通知首页刷新。
void modelsChanged() {
modelsRevision++;
notifyListeners();
}
Future<void> reloadSettings() async { Future<void> reloadSettings() async {
try { try {
settings = await api.settings(); settings = await api.settings();
loadError = null; loadError = null;
I18n.setLanguage(settings!.language); _applySettings(settings!);
} catch (error) { } catch (error) {
loadError = error.toString(); loadError = error.toString();
} }
@@ -58,7 +124,7 @@ class ShellController extends ChangeNotifier {
try { try {
settings = await api.saveSettings(patch); settings = await api.saveSettings(patch);
loadError = null; loadError = null;
I18n.setLanguage(settings!.language); _applySettings(settings!);
} catch (error) { } catch (error) {
loadError = error.toString(); loadError = error.toString();
} }
@@ -103,6 +169,7 @@ class ShellController extends ChangeNotifier {
detail: result.error ?? '', detail: result.error ?? '',
notice: result.launcherMessage ?? '', notice: result.launcherMessage ?? '',
); );
if (result.updatedModels > 0) modelsChanged();
} catch (error) { } catch (error) {
setUpdateStatus( setUpdateStatus(
busy: false, busy: false,
@@ -111,4 +178,10 @@ class ShellController extends ChangeNotifier {
); );
} }
} }
@override
void dispose() {
_retryTimer?.cancel();
super.dispose();
}
} }
+26
View File
@@ -23,6 +23,7 @@ class I18n {
'home.settings': '设置', 'home.settings': '设置',
'home.installed': '已安装模型', 'home.installed': '已安装模型',
'home.count': '{0} 个模型', 'home.count': '{0} 个模型',
'home.noDescription': '暂无简介',
'home.empty': '模型库还是空的', 'home.empty': '模型库还是空的',
'home.emptyHint': '启动时会自动检查并下载模型。若当前断网:可把模型文件夹放进 .GC/model/ 后重新打开,或联网后在「下载」页点重试。', 'home.emptyHint': '启动时会自动检查并下载模型。若当前断网:可把模型文件夹放进 .GC/model/ 后重新打开,或联网后在「下载」页点重试。',
'home.emptyAction': '去下载模型', 'home.emptyAction': '去下载模型',
@@ -62,6 +63,17 @@ class I18n {
'set.title': '设置', 'set.title': '设置',
'set.subtitle': '模型源、启动时内存分配与本地存储。', 'set.subtitle': '模型源、启动时内存分配与本地存储。',
'set.general': '通用', 'set.general': '通用',
'set.appearance': '外观',
'set.theme': '主题模式',
'set.theme.desc': '深色、浅色,或跟随系统设置。',
'set.theme.dark': '深色',
'set.theme.light': '浅色',
'set.theme.system': '跟随系统',
'set.accent': '主题颜色',
'set.accent.desc': '选择启动器的主色调,按钮、滑块与高亮会同步换色。',
'set.accent.custom': '自定义颜色',
'set.accent.hexHint': '格式 #RRGGBB,例如 #8FB6FF',
'set.accent.invalid': '颜色格式无效,请使用 #RRGGBB',
'set.language': '界面语言', 'set.language': '界面语言',
'set.language.auto': '跟随系统', 'set.language.auto': '跟随系统',
'set.fps': '渲染帧率', 'set.fps': '渲染帧率',
@@ -117,6 +129,7 @@ class I18n {
'common.error': '出错了', 'common.error': '出错了',
'common.refresh': '刷新', 'common.refresh': '刷新',
'about.developers': '开发者', 'about.developers': '开发者',
'about.contributorsHint': '来自仓库提交记录',
'about.repository': '仓库', 'about.repository': '仓库',
'about.openRepository': '打开仓库', 'about.openRepository': '打开仓库',
'about.contributions': '{0} 次提交', 'about.contributions': '{0} 次提交',
@@ -140,6 +153,7 @@ class I18n {
'home.settings': 'Settings', 'home.settings': 'Settings',
'home.installed': 'Installed models', 'home.installed': 'Installed models',
'home.count': '{0} models', 'home.count': '{0} models',
'home.noDescription': 'No description',
'home.empty': 'No models yet', 'home.empty': 'No models yet',
'home.emptyHint': 'Models are checked and downloaded on startup. Offline: drop model folders into .GC/model/ and reopen, or retry from the Download page once online.', 'home.emptyHint': 'Models are checked and downloaded on startup. Offline: drop model folders into .GC/model/ and reopen, or retry from the Download page once online.',
'home.emptyAction': 'Get models', 'home.emptyAction': 'Get models',
@@ -179,6 +193,17 @@ class I18n {
'set.title': 'Settings', 'set.title': 'Settings',
'set.subtitle': 'Model sources, startup memory allocation and local storage.', 'set.subtitle': 'Model sources, startup memory allocation and local storage.',
'set.general': 'General', 'set.general': 'General',
'set.appearance': 'Appearance',
'set.theme': 'Theme mode',
'set.theme.desc': 'Dark, light, or follow the system setting.',
'set.theme.dark': 'Dark',
'set.theme.light': 'Light',
'set.theme.system': 'System',
'set.accent': 'Theme color',
'set.accent.desc': 'Pick the launcher accent color; buttons, sliders and highlights follow it.',
'set.accent.custom': 'Custom color',
'set.accent.hexHint': 'Format #RRGGBB, e.g. #8FB6FF',
'set.accent.invalid': 'Invalid color, use #RRGGBB',
'set.language': 'Language', 'set.language': 'Language',
'set.language.auto': 'System', 'set.language.auto': 'System',
'set.fps': 'Render frame rate', 'set.fps': 'Render frame rate',
@@ -234,6 +259,7 @@ class I18n {
'common.error': 'Something went wrong', 'common.error': 'Something went wrong',
'common.refresh': 'Refresh', 'common.refresh': 'Refresh',
'about.developers': 'Developers', 'about.developers': 'Developers',
'about.contributorsHint': 'From repository commits',
'about.repository': 'Repository', 'about.repository': 'Repository',
'about.openRepository': 'Open repository', 'about.openRepository': 'Open repository',
'about.contributions': '{0} commits', 'about.contributions': '{0} commits',
+33 -6
View File
@@ -6,10 +6,13 @@ import 'shell.dart';
import 'theme.dart'; import 'theme.dart';
void main() { void main() {
// 桌面端无需异步初始化外部插件:尽早绑定并直接渲染首帧,
// 让窗口在引擎就绪后立刻出现,后端探测在外壳里异步进行。
WidgetsFlutterBinding.ensureInitialized();
runApp(const GcUiApp()); runApp(const GcUiApp());
} }
/// GC-UI 前端:Flutter 桌面应用(Windows / macOS)。 /// GC-UI 前端:Flutter 桌面应用(Windows / macOS / Linux)。
/// ///
/// 界面全部在这里;模型扫描、下载、更新、设置、模型窗口宿主都在后端 /// 界面全部在这里;模型扫描、下载、更新、设置、模型窗口宿主都在后端
/// (GC-UI/backend/GC.UI.Server,本地 HTTP 服务)。 /// (GC-UI/backend/GC.UI.Server,本地 HTTP 服务)。
@@ -25,14 +28,38 @@ class _GcUiAppState extends State<GcUiApp> {
@override @override
Widget build(BuildContext context) { Widget build(BuildContext context) {
// 语言、强调色、主题模式都会触发重建:只重建 MaterialApp 的主题层,
// 不触碰页面状态(页面由 ShellPage 自己持有)。
return ValueListenableBuilder<String>( return ValueListenableBuilder<String>(
valueListenable: I18n.language, valueListenable: I18n.language,
builder: (context, language, _) { builder: (context, language, _) {
return MaterialApp( return ValueListenableBuilder<Color>(
title: 'Morris GC', valueListenable: GcPalette.accent,
debugShowCheckedModeBanner: false, builder: (context, accent, _) {
theme: buildGcTheme(), return ValueListenableBuilder<ThemeMode>(
home: ShellPage(controller: _controller), valueListenable: GcPalette.mode,
builder: (context, mode, _) {
return MaterialApp(
title: 'Morris GC',
debugShowCheckedModeBanner: false,
theme: buildGcTheme(Brightness.light),
darkTheme: buildGcTheme(Brightness.dark),
themeMode: mode,
// GcColors 是静态取值,必须按当前实际亮度(含跟随系统)绑定,
// 再用 key 强制子树重建,否则切主题后颜色仍是上一套。
builder: (context, child) {
final brightness = Theme.of(context).brightness;
GcColors.bind(brightness);
return KeyedSubtree(
key: ValueKey<bool>(brightness == Brightness.dark),
child: child ?? const SizedBox.shrink(),
);
},
home: ShellPage(controller: _controller),
);
},
);
},
); );
}, },
); );
+531 -134
View File
@@ -28,10 +28,14 @@ class _HomePageViewState extends State<HomePageView> {
bool _loading = true; bool _loading = true;
String? _error; String? _error;
String? _notice; String? _notice;
int _lastRevision = 0;
@override @override
void initState() { void initState() {
super.initState(); super.initState();
widget.controller.addListener(_onControllerChanged);
_lastRevision = widget.controller.modelsRevision;
final preset = widget.initialModels; final preset = widget.initialModels;
if (preset != null) { if (preset != null) {
_models = preset; _models = preset;
@@ -41,6 +45,22 @@ class _HomePageViewState extends State<HomePageView> {
} }
} }
@override
void dispose() {
widget.controller.removeListener(_onControllerChanged);
super.dispose();
}
/// 下载完成 / 删除模型后重新拉列表:页面被 Offstage 保活,不会自己重建。
void _onControllerChanged() {
if (!mounted) return;
final revision = widget.controller.modelsRevision;
if (revision == _lastRevision) return;
_lastRevision = revision;
if (widget.initialModels != null) return; // 截图 / 测试用的预置数据
_load();
}
Future<void> _load() async { Future<void> _load() async {
setState(() { setState(() {
_loading = true; _loading = true;
@@ -128,7 +148,7 @@ class _HomePageViewState extends State<HomePageView> {
Expanded( Expanded(
child: Text( child: Text(
T('home.installed'), T('home.installed'),
style: const TextStyle( style: TextStyle(
fontSize: 15, fontSize: 15,
fontWeight: FontWeight.w600, fontWeight: FontWeight.w600,
color: GcColors.ink, color: GcColors.ink,
@@ -151,7 +171,7 @@ class _HomePageViewState extends State<HomePageView> {
padding: const EdgeInsets.all(12), padding: const EdgeInsets.all(12),
child: Text( child: Text(
_notice!, _notice!,
style: const TextStyle(fontSize: 12, color: GcColors.warn), style: TextStyle(fontSize: 12, color: GcColors.warn),
), ),
), ),
], ],
@@ -167,7 +187,7 @@ class _HomePageViewState extends State<HomePageView> {
crossAxisAlignment: CrossAxisAlignment.start, crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[ children: <Widget>[
Text(T('common.error'), Text(T('common.error'),
style: const TextStyle(color: GcColors.danger)), style: TextStyle(color: GcColors.danger)),
const SizedBox(height: 8), const SizedBox(height: 8),
GcHint(_error!), GcHint(_error!),
], ],
@@ -314,7 +334,7 @@ class _HomePageViewState extends State<HomePageView> {
children: <Widget>[ children: <Widget>[
Text( Text(
T('home.empty'), T('home.empty'),
style: const TextStyle( style: TextStyle(
fontSize: 15, fontSize: 15,
fontWeight: FontWeight.w600, fontWeight: FontWeight.w600,
color: GcColors.ink, color: GcColors.ink,
@@ -326,7 +346,7 @@ class _HomePageViewState extends State<HomePageView> {
child: Text( child: Text(
T('home.emptyHint'), T('home.emptyHint'),
textAlign: TextAlign.center, textAlign: TextAlign.center,
style: const TextStyle( style: TextStyle(
fontSize: 12, fontSize: 12,
color: GcColors.faint, color: GcColors.faint,
height: 1.5, height: 1.5,
@@ -344,7 +364,7 @@ class _HomePageViewState extends State<HomePageView> {
} }
} }
class _ModelCard extends StatelessWidget { class _ModelCard extends StatefulWidget {
const _ModelCard({ const _ModelCard({
required this.model, required this.model,
required this.previewUrl, required this.previewUrl,
@@ -359,110 +379,249 @@ class _ModelCard extends StatelessWidget {
final VoidCallback onOpenFolder; final VoidCallback onOpenFolder;
final VoidCallback onDelete; final VoidCallback onDelete;
@override
State<_ModelCard> createState() => _ModelCardState();
}
class _ModelCardState extends State<_ModelCard> {
bool _hover = false;
@override @override
Widget build(BuildContext context) { Widget build(BuildContext context) {
return SizedBox( final model = widget.model;
width: 336, return MouseRegion(
child: GcCard( onEnter: (_) => setState(() => _hover = true),
padding: EdgeInsets.zero, onExit: (_) => setState(() => _hover = false),
child: Column( cursor: SystemMouseCursors.click,
crossAxisAlignment: CrossAxisAlignment.start, child: AnimatedContainer(
children: <Widget>[ duration: const Duration(milliseconds: 160),
ClipRRect( curve: Curves.easeOut,
borderRadius: const BorderRadius.vertical(top: Radius.circular(13)), width: 336,
child: SizedBox( transform: Matrix4.translationValues(0, _hover ? -3 : 0, 0),
height: 138, decoration: BoxDecoration(
width: double.infinity, borderRadius: BorderRadius.circular(16),
child: Container( boxShadow: <BoxShadow>[
color: const Color(0xFF0B1226), BoxShadow(
child: model.hasPreview color: Colors.black.withOpacity(_hover ? 0.42 : 0.22),
? Image.network( blurRadius: _hover ? 26 : 14,
previewUrl, offset: Offset(0, _hover ? 10 : 6),
fit: BoxFit.cover,
errorBuilder: (context, error, stack) =>
const _PreviewFallback(),
)
: const _PreviewFallback(),
),
),
), ),
Padding( ],
padding: const EdgeInsets.fromLTRB(16, 13, 16, 15), ),
child: Column( child: GcCard(
crossAxisAlignment: CrossAxisAlignment.start, padding: EdgeInsets.zero,
children: <Widget>[ child: Column(
Row( crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
// 封面:图片 + 底部渐变遮罩 + 播放提示 + 版本徽章。
ClipRRect(
borderRadius:
const BorderRadius.vertical(top: Radius.circular(13)),
child: SizedBox(
height: 152,
width: double.infinity,
child: Stack(
fit: StackFit.expand,
children: <Widget>[ children: <Widget>[
Expanded( Container(
child: Text( color: const Color(0xFF0B1226),
model.name, child: model.hasPreview
overflow: TextOverflow.ellipsis, ? Image.network(
style: const TextStyle( widget.previewUrl,
fontSize: 14, fit: BoxFit.cover,
fontWeight: FontWeight.w600, // 只按展示尺寸解码,避免大图占用内存、拖慢首帧。
color: GcColors.ink, cacheWidth: 672,
errorBuilder: (context, error, stack) =>
const _PreviewFallback(),
)
: const _PreviewFallback(),
),
const DecoratedBox(
decoration: BoxDecoration(
gradient: LinearGradient(
begin: Alignment.topCenter,
end: Alignment.bottomCenter,
colors: <Color>[
Color(0x00000000),
Color(0x22000000),
Color(0xE60A1226),
],
stops: <double>[0.45, 0.72, 1.0],
), ),
), ),
), ),
const SizedBox(width: 8), Positioned(
Text( left: 14,
model.metaText, right: 14,
style: const TextStyle( bottom: 11,
fontSize: 10.5, child: Row(
color: GcColors.faint, children: <Widget>[
if (model.version.isNotEmpty)
_CoverPill(
text: 'v${model.version}',
color: GcColors.accent,
),
if (model.author.isNotEmpty) ...<Widget>[
const SizedBox(width: 8),
Flexible(
child: Text(
model.author,
maxLines: 1,
overflow: TextOverflow.ellipsis,
style: const TextStyle(
fontSize: 10.5,
color: Colors.white70,
),
),
),
],
const Spacer(),
AnimatedOpacity(
opacity: _hover ? 1 : 0,
duration: const Duration(milliseconds: 160),
child: Container(
width: 30,
height: 30,
decoration: BoxDecoration(
color: GcColors.accent.withOpacity(0.9),
shape: BoxShape.circle,
),
child: const Icon(Icons.play_arrow_rounded,
size: 20, color: Color(0xFF08101F)),
),
),
],
), ),
), ),
], ],
), ),
const SizedBox(height: 7), ),
SizedBox( ),
height: 34, Padding(
child: Text( padding: const EdgeInsets.fromLTRB(16, 13, 16, 15),
model.description, child: Column(
maxLines: 2, crossAxisAlignment: CrossAxisAlignment.start,
overflow: TextOverflow.ellipsis, children: <Widget>[
style: const TextStyle( Row(
fontSize: 12, children: <Widget>[
color: GcColors.muted, Expanded(
height: 1.4, child: Text(
model.name,
overflow: TextOverflow.ellipsis,
style: TextStyle(
fontSize: 14.5,
fontWeight: FontWeight.w700,
color: GcColors.ink,
),
),
),
const SizedBox(width: 8),
Text(
model.sizeText,
style: TextStyle(
fontSize: 10.5,
color: GcColors.faint,
),
),
],
),
const SizedBox(height: 7),
// 简介:固定两行高度,避免卡片高低不齐。
SizedBox(
height: 34,
child: Text(
model.description.isEmpty
? T('home.noDescription')
: model.description,
maxLines: 2,
overflow: TextOverflow.ellipsis,
style: TextStyle(
fontSize: 12,
height: 1.4,
color: model.description.isEmpty
? GcColors.faint
: GcColors.muted,
),
), ),
), ),
), if (model.tags.isNotEmpty) ...<Widget>[
if (model.tags.isNotEmpty) ...<Widget>[ const SizedBox(height: 8),
const SizedBox(height: 6), Wrap(
Text( spacing: 6,
model.tags.join(' · '), runSpacing: 4,
style: const TextStyle( children: <Widget>[
fontSize: 10.5, for (final tag in model.tags.take(3))
color: GcColors.faint, _CoverPill(
text: tag,
color: GcColors.muted,
subtle: true,
),
],
), ),
],
const SizedBox(height: 13),
Row(
children: <Widget>[
FilledButton.icon(
onPressed: widget.onLaunch,
icon: const Icon(Icons.play_arrow_rounded, size: 17),
label: Text(T('home.launch')),
),
const Spacer(),
TextButton(
onPressed: widget.onOpenFolder,
child: Text(T('home.open')),
),
TextButton(
onPressed: widget.onDelete,
style: TextButton.styleFrom(
foregroundColor: GcColors.danger,
),
child: Text(T('home.delete')),
),
],
), ),
], ],
const SizedBox(height: 12), ),
Row(
children: <Widget>[
FilledButton(
onPressed: onLaunch,
child: Text(T('home.launch')),
),
const Spacer(),
TextButton(
onPressed: onOpenFolder,
child: Text(T('home.open')),
),
TextButton(
onPressed: onDelete,
style: TextButton.styleFrom(
foregroundColor: GcColors.danger,
),
child: Text(T('home.delete')),
),
],
),
],
), ),
), ],
], ),
),
),
);
}
}
/// 封面上的小胶囊标签(版本 / 标签)。
class _CoverPill extends StatelessWidget {
const _CoverPill({
required this.text,
required this.color,
this.subtle = false,
});
final String text;
final Color color;
final bool subtle;
@override
Widget build(BuildContext context) {
return Container(
padding: const EdgeInsets.symmetric(horizontal: 8, vertical: 3),
decoration: BoxDecoration(
color: subtle ? GcColors.surfaceAlt : color.withOpacity(0.14),
borderRadius: BorderRadius.circular(999),
border: Border.all(
color: subtle ? GcColors.line : color.withOpacity(0.35),
),
),
child: Text(
text,
style: TextStyle(
fontSize: 10,
height: 1.1,
color: subtle ? GcColors.faint : color,
fontWeight: FontWeight.w600,
), ),
), ),
); );
@@ -473,12 +632,23 @@ class _PreviewFallback extends StatelessWidget {
const _PreviewFallback(); const _PreviewFallback();
@override @override
Widget build(BuildContext context) => const Center( Widget build(BuildContext context) {
return Container(
decoration: const BoxDecoration(
gradient: LinearGradient(
begin: Alignment.topLeft,
end: Alignment.bottomRight,
colors: <Color>[Color(0xFF16233C), Color(0xFF0B1226)],
),
),
child: const Center(
child: Text( child: Text(
'◎', '◎',
style: TextStyle(fontSize: 34, color: Color(0xFF1B2A47)), style: TextStyle(fontSize: 34, color: Color(0xFF24365A)),
), ),
); ),
);
}
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
@@ -514,6 +684,12 @@ class _DownloadPageViewState extends State<DownloadPageView> {
String? _error; String? _error;
Timer? _poll; Timer? _poll;
/// 页面是否可见(被切走后仍保活,但没必要继续请求后端)。
bool _visible = true;
/// 上一次轮询时是否有活跃任务,用来判断「刚刚全部结束」。
bool _hadActive = false;
@override @override
void initState() { void initState() {
super.initState(); super.initState();
@@ -527,7 +703,14 @@ class _DownloadPageViewState extends State<DownloadPageView> {
return; return;
} }
_load(); _load();
_poll = Timer.periodic(const Duration(seconds: 1), (_) => _refreshJobs()); _schedulePoll(const Duration(seconds: 2));
}
@override
void didChangeDependencies() {
super.didChangeDependencies();
// TickerMode 由外壳的 Offstage 控制:切到别的页时变 false。
_visible = TickerMode.of(context);
} }
@override @override
@@ -536,6 +719,35 @@ class _DownloadPageViewState extends State<DownloadPageView> {
super.dispose(); super.dispose();
} }
/// 单次 Timer 链:有活跃任务时 1 秒一次,空闲时降到 5 秒,不可见时 10 秒。
///
/// 以前是 `Timer.periodic(1s)` 且永不停止 —— 只要进过下载页,之后每秒都
/// 在请求 `/api/download/jobs`,哪怕没有任何任务、页面也早就切走了。
void _schedulePoll(Duration delay) {
_poll?.cancel();
_poll = Timer(delay, _pollOnce);
}
Future<void> _pollOnce() async {
if (!mounted) return;
if (!_visible) {
_schedulePoll(const Duration(seconds: 10));
return;
}
_hadActive = _jobs.any((job) => job.isActive);
await _refreshJobs();
if (!mounted) return;
final active = _jobs.any((job) => job.isActive);
// 活跃 → 空闲:这一轮里下载结束了,首页的模型列表已经过期。
if (_hadActive && !active) widget.controller.modelsChanged();
_hadActive = active;
_schedulePoll(Duration(seconds: active ? 1 : 5));
}
Future<void> _load() async { Future<void> _load() async {
setState(() { setState(() {
_loading = true; _loading = true;
@@ -668,7 +880,7 @@ class _DownloadPageViewState extends State<DownloadPageView> {
Expanded( Expanded(
child: Text( child: Text(
source.name, source.name,
style: const TextStyle( style: TextStyle(
fontSize: 12.5, fontSize: 12.5,
fontWeight: FontWeight.w600, fontWeight: FontWeight.w600,
color: GcColors.ink, color: GcColors.ink,
@@ -676,7 +888,7 @@ class _DownloadPageViewState extends State<DownloadPageView> {
), ),
), ),
if (!source.enabled) if (!source.enabled)
const Text( Text(
'off', 'off',
style: TextStyle( style: TextStyle(
fontSize: 10, color: GcColors.faint), fontSize: 10, color: GcColors.faint),
@@ -686,7 +898,7 @@ class _DownloadPageViewState extends State<DownloadPageView> {
const SizedBox(height: 2), const SizedBox(height: 2),
Text( Text(
source.host, source.host,
style: const TextStyle( style: TextStyle(
fontSize: 10.5, color: GcColors.faint), fontSize: 10.5, color: GcColors.faint),
), ),
], ],
@@ -717,7 +929,7 @@ class _DownloadPageViewState extends State<DownloadPageView> {
Expanded( Expanded(
child: Text( child: Text(
T('dl.available'), T('dl.available'),
style: const TextStyle( style: TextStyle(
fontSize: 15, fontSize: 15,
fontWeight: FontWeight.w600, fontWeight: FontWeight.w600,
color: GcColors.ink, color: GcColors.ink,
@@ -746,7 +958,7 @@ class _DownloadPageViewState extends State<DownloadPageView> {
crossAxisAlignment: CrossAxisAlignment.start, crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[ children: <Widget>[
Text(T('common.error'), Text(T('common.error'),
style: const TextStyle(color: GcColors.danger)), style: TextStyle(color: GcColors.danger)),
const SizedBox(height: 8), const SizedBox(height: 8),
GcHint(_error!), GcHint(_error!),
], ],
@@ -758,7 +970,7 @@ class _DownloadPageViewState extends State<DownloadPageView> {
crossAxisAlignment: CrossAxisAlignment.start, crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[ children: <Widget>[
Text(T('dl.empty'), Text(T('dl.empty'),
style: const TextStyle(color: GcColors.ink)), style: TextStyle(color: GcColors.ink)),
const SizedBox(height: 8), const SizedBox(height: 8),
GcHint(T('dl.emptyHint')), GcHint(T('dl.emptyHint')),
], ],
@@ -780,7 +992,7 @@ class _DownloadPageViewState extends State<DownloadPageView> {
children: <Widget>[ children: <Widget>[
Text( Text(
model.name, model.name,
style: const TextStyle( style: TextStyle(
fontSize: 13, fontSize: 13,
fontWeight: FontWeight.w600, fontWeight: FontWeight.w600,
color: GcColors.ink, color: GcColors.ink,
@@ -789,7 +1001,7 @@ class _DownloadPageViewState extends State<DownloadPageView> {
const SizedBox(width: 8), const SizedBox(width: 8),
Text( Text(
'v${model.version} · ${model.sizeText}', 'v${model.version} · ${model.sizeText}',
style: const TextStyle( style: TextStyle(
fontSize: 10.5, fontSize: 10.5,
color: GcColors.faint), color: GcColors.faint),
), ),
@@ -806,7 +1018,7 @@ class _DownloadPageViewState extends State<DownloadPageView> {
), ),
child: Text( child: Text(
T('dl.installed'), T('dl.installed'),
style: const TextStyle( style: TextStyle(
fontSize: 10, fontSize: 10,
color: GcColors.ok), color: GcColors.ok),
), ),
@@ -819,7 +1031,7 @@ class _DownloadPageViewState extends State<DownloadPageView> {
model.description, model.description,
maxLines: 2, maxLines: 2,
overflow: TextOverflow.ellipsis, overflow: TextOverflow.ellipsis,
style: const TextStyle( style: TextStyle(
fontSize: 11.5, fontSize: 11.5,
color: GcColors.muted, color: GcColors.muted,
height: 1.4, height: 1.4,
@@ -882,7 +1094,7 @@ class _DownloadPageViewState extends State<DownloadPageView> {
Expanded( Expanded(
child: Text( child: Text(
'${job.name} v${job.version}', '${job.name} v${job.version}',
style: const TextStyle( style: TextStyle(
fontSize: 12.5, fontSize: 12.5,
fontWeight: FontWeight.w600, fontWeight: FontWeight.w600,
color: GcColors.ink, color: GcColors.ink,
@@ -929,7 +1141,7 @@ class _DownloadPageViewState extends State<DownloadPageView> {
const SizedBox(height: 4), const SizedBox(height: 4),
Text( Text(
job.error ?? job.detailText, job.error ?? job.detailText,
style: const TextStyle( style: TextStyle(
fontSize: 10.5, color: GcColors.faint), fontSize: 10.5, color: GcColors.faint),
), ),
], ],
@@ -977,7 +1189,11 @@ class _SettingsPageViewState extends State<SettingsPageView> {
int _fps = 120; int _fps = 120;
bool _autoUpdate = true; bool _autoUpdate = true;
String _language = 'auto'; String _language = 'auto';
bool _synced = false; ThemeMode _themeMode = ThemeMode.dark;
/// 上一次同步所用的设置对象。以前用的是 `bool _synced` —— 只同步一次,
/// 之后外部(更新状态条、其它页面)改了设置,本页仍显示旧值。
SettingsInfo? _syncedFrom;
String? _status; String? _status;
@override @override
@@ -987,13 +1203,14 @@ class _SettingsPageViewState extends State<SettingsPageView> {
} }
void _syncFrom(SettingsInfo settings) { void _syncFrom(SettingsInfo settings) {
if (_synced) return; if (identical(_syncedFrom, settings)) return;
_syncedFrom = settings;
_memory = settings.memoryMb.toDouble(); _memory = settings.memoryMb.toDouble();
_memoryAuto = settings.memoryAuto; _memoryAuto = settings.memoryAuto;
_fps = settings.renderFps; _fps = settings.renderFps;
_autoUpdate = settings.autoUpdateOnStartup; _autoUpdate = settings.autoUpdateOnStartup;
_language = settings.language; _language = settings.language;
_synced = true; _themeMode = GcPalette.parseMode(settings.theme);
} }
@override @override
@@ -1009,7 +1226,7 @@ class _SettingsPageViewState extends State<SettingsPageView> {
children: <Widget>[ children: <Widget>[
Text( Text(
T('set.title'), T('set.title'),
style: const TextStyle( style: TextStyle(
fontSize: 20, fontSize: 20,
fontWeight: FontWeight.w700, fontWeight: FontWeight.w700,
color: GcColors.ink, color: GcColors.ink,
@@ -1020,6 +1237,8 @@ class _SettingsPageViewState extends State<SettingsPageView> {
const SizedBox(height: 18), const SizedBox(height: 18),
_generalCard(settings), _generalCard(settings),
const SizedBox(height: 16), const SizedBox(height: 16),
_appearanceCard(settings),
const SizedBox(height: 16),
_memoryCard(settings), _memoryCard(settings),
const SizedBox(height: 16), const SizedBox(height: 16),
_sourcesCard(settings), _sourcesCard(settings),
@@ -1047,7 +1266,7 @@ class _SettingsPageViewState extends State<SettingsPageView> {
Row( Row(
children: <Widget>[ children: <Widget>[
SizedBox(width: 160, child: Text(T('set.language'), SizedBox(width: 160, child: Text(T('set.language'),
style: const TextStyle(fontSize: 12.5, color: GcColors.muted))), style: TextStyle(fontSize: 12.5, color: GcColors.muted))),
DropdownButton<String>( DropdownButton<String>(
value: _language, value: _language,
dropdownColor: GcColors.surfaceAlt, dropdownColor: GcColors.surfaceAlt,
@@ -1076,7 +1295,7 @@ class _SettingsPageViewState extends State<SettingsPageView> {
Row( Row(
children: <Widget>[ children: <Widget>[
SizedBox(width: 160, child: Text(T('set.fps'), SizedBox(width: 160, child: Text(T('set.fps'),
style: const TextStyle(fontSize: 12.5, color: GcColors.muted))), style: TextStyle(fontSize: 12.5, color: GcColors.muted))),
Expanded( Expanded(
child: Slider( child: Slider(
value: _fps.toDouble(), value: _fps.toDouble(),
@@ -1095,7 +1314,7 @@ class _SettingsPageViewState extends State<SettingsPageView> {
SizedBox( SizedBox(
width: 46, width: 46,
child: Text('$_fps', child: Text('$_fps',
style: const TextStyle( style: TextStyle(
fontSize: 12.5, color: GcColors.ink)), fontSize: 12.5, color: GcColors.ink)),
), ),
], ],
@@ -1106,6 +1325,181 @@ class _SettingsPageViewState extends State<SettingsPageView> {
); );
} }
Widget _appearanceCard(SettingsInfo settings) {
final current =
GcPalette.parseHex(settings.accentColor) ?? GcPalette.defaultAccent;
return GcCard(
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
GcSectionTitle(T('set.appearance')),
const SizedBox(height: 8),
GcHint(T('set.theme.desc')),
const SizedBox(height: 10),
SegmentedButton<ThemeMode>(
segments: <ButtonSegment<ThemeMode>>[
ButtonSegment<ThemeMode>(
value: ThemeMode.dark,
label: Text(T('set.theme.dark')),
icon: const Icon(Icons.dark_mode_outlined, size: 15),
),
ButtonSegment<ThemeMode>(
value: ThemeMode.light,
label: Text(T('set.theme.light')),
icon: const Icon(Icons.light_mode_outlined, size: 15),
),
ButtonSegment<ThemeMode>(
value: ThemeMode.system,
label: Text(T('set.theme.system')),
icon: const Icon(Icons.brightness_auto_outlined, size: 15),
),
],
selected: <ThemeMode>{_themeMode},
showSelectedIcon: false,
onSelectionChanged: (selection) async {
final mode = selection.first;
setState(() => _themeMode = mode);
GcPalette.mode.value = mode; // 立即预览
await widget.controller
.saveSettings(SettingsPatch(theme: GcPalette.modeToName(mode)));
if (mounted) setState(() => _status = T('common.applied'));
},
),
const SizedBox(height: 16),
GcHint(T('set.accent.desc')),
const SizedBox(height: 14),
Wrap(
spacing: 10,
runSpacing: 10,
children: <Widget>[
for (final color in GcPalette.presets)
_accentSwatch(color, current),
_customAccentChip(),
],
),
const SizedBox(height: 12),
Text(
'${T('set.accent')}: ${GcPalette.toHex(current)}',
style: TextStyle(fontSize: 11.5, color: GcColors.faint),
),
],
),
);
}
Widget _accentSwatch(Color color, Color current) {
// ignore: deprecated_member_use
final selected = color.value == current.value;
return Tooltip(
message: GcPalette.toHex(color),
child: GestureDetector(
onTap: () => _applyAccent(GcPalette.toHex(color)),
child: Container(
width: 36,
height: 36,
decoration: BoxDecoration(
color: color,
borderRadius: BorderRadius.circular(10),
border: Border.all(
color: selected ? Colors.white : Colors.transparent,
width: 2,
),
boxShadow: <BoxShadow>[
BoxShadow(
color: color.withOpacity(selected ? 0.55 : 0.18),
blurRadius: selected ? 14 : 6,
),
],
),
child: selected
? const Icon(Icons.check_rounded,
size: 19, color: Color(0xFF08101F))
: null,
),
),
);
}
Widget _customAccentChip() {
return MouseRegion(
cursor: SystemMouseCursors.click,
child: GestureDetector(
onTap: _pickCustomAccent,
child: Container(
height: 36,
padding: const EdgeInsets.symmetric(horizontal: 12),
decoration: BoxDecoration(
color: GcColors.surfaceAlt,
borderRadius: BorderRadius.circular(10),
border: Border.all(color: GcColors.line),
),
child: Row(
mainAxisSize: MainAxisSize.min,
children: <Widget>[
Icon(Icons.colorize_rounded,
size: 16, color: GcColors.faint),
const SizedBox(width: 6),
Text(
T('set.accent.custom'),
style: TextStyle(fontSize: 11.5, color: GcColors.muted),
),
],
),
),
),
);
}
Future<void> _pickCustomAccent() async {
final controller = TextEditingController(
text: GcPalette.toHex(GcPalette.accent.value),
);
final hex = await showDialog<String>(
context: context,
builder: (context) => AlertDialog(
backgroundColor: GcColors.surfaceAlt,
title: Text(T('set.accent.custom')),
content: TextField(
controller: controller,
autofocus: true,
style: TextStyle(color: GcColors.ink),
decoration: InputDecoration(
hintText: '#8FB6FF',
hintStyle: TextStyle(color: GcColors.faint),
helperText: T('set.accent.hexHint'),
helperStyle: TextStyle(color: GcColors.faint, fontSize: 11),
),
onSubmitted: (value) => Navigator.of(context).pop(value),
),
actions: <Widget>[
TextButton(
onPressed: () => Navigator.of(context).pop(),
child: Text(T('common.cancel')),
),
FilledButton(
onPressed: () => Navigator.of(context).pop(controller.text),
child: Text(T('common.confirm')),
),
],
),
);
controller.dispose();
if (hex != null) await _applyAccent(hex);
}
Future<void> _applyAccent(String hex) async {
final parsed = GcPalette.parseHex(hex);
if (parsed == null) {
if (mounted) setState(() => _status = T('set.accent.invalid'));
return;
}
final normalized = GcPalette.toHex(parsed);
GcPalette.apply(normalized); // 立即预览
await widget.controller
.saveSettings(SettingsPatch(accentColor: normalized));
if (mounted) setState(() => _status = T('common.applied'));
}
Widget _memoryCard(SettingsInfo settings) { Widget _memoryCard(SettingsInfo settings) {
return GcCard( return GcCard(
child: Column( child: Column(
@@ -1129,7 +1523,7 @@ class _SettingsPageViewState extends State<SettingsPageView> {
Expanded( Expanded(
child: Text( child: Text(
T('set.memory.auto'), T('set.memory.auto'),
style: const TextStyle(fontSize: 12.5, color: GcColors.muted), style: TextStyle(fontSize: 12.5, color: GcColors.muted),
), ),
), ),
], ],
@@ -1158,7 +1552,7 @@ class _SettingsPageViewState extends State<SettingsPageView> {
width: 96, width: 96,
child: Text( child: Text(
'${_memory.round()} MB', '${_memory.round()} MB',
style: const TextStyle(fontSize: 12.5, color: GcColors.ink), style: TextStyle(fontSize: 12.5, color: GcColors.ink),
), ),
), ),
], ],
@@ -1168,7 +1562,7 @@ class _SettingsPageViewState extends State<SettingsPageView> {
children: <Widget>[ children: <Widget>[
Text( Text(
'${T('set.memory.current')}: ${settings.memoryUsageText}', '${T('set.memory.current')}: ${settings.memoryUsageText}',
style: const TextStyle(fontSize: 11.5, color: GcColors.faint), style: TextStyle(fontSize: 11.5, color: GcColors.faint),
), ),
], ],
), ),
@@ -1199,7 +1593,7 @@ class _SettingsPageViewState extends State<SettingsPageView> {
children: <Widget>[ children: <Widget>[
Text( Text(
source.name, source.name,
style: const TextStyle( style: TextStyle(
fontSize: 12.5, fontSize: 12.5,
fontWeight: FontWeight.w600, fontWeight: FontWeight.w600,
color: GcColors.ink, color: GcColors.ink,
@@ -1208,7 +1602,7 @@ class _SettingsPageViewState extends State<SettingsPageView> {
const SizedBox(height: 2), const SizedBox(height: 2),
Text( Text(
source.url, source.url,
style: const TextStyle( style: TextStyle(
fontSize: 10.5, color: GcColors.faint), fontSize: 10.5, color: GcColors.faint),
), ),
], ],
@@ -1216,7 +1610,7 @@ class _SettingsPageViewState extends State<SettingsPageView> {
), ),
Text( Text(
source.enabled ? T('set.sourceEnabled') : '—', source.enabled ? T('set.sourceEnabled') : '—',
style: const TextStyle(fontSize: 11, color: GcColors.faint), style: TextStyle(fontSize: 11, color: GcColors.faint),
), ),
], ],
), ),
@@ -1271,12 +1665,12 @@ class _SettingsPageViewState extends State<SettingsPageView> {
SizedBox( SizedBox(
width: 160, width: 160,
child: Text(label, child: Text(label,
style: const TextStyle(fontSize: 12.5, color: GcColors.muted)), style: TextStyle(fontSize: 12.5, color: GcColors.muted)),
), ),
Expanded( Expanded(
child: SelectableText( child: SelectableText(
value, value,
style: const TextStyle(fontSize: 11.5, color: GcColors.faint), style: TextStyle(fontSize: 11.5, color: GcColors.faint),
), ),
), ),
], ],
@@ -1306,7 +1700,7 @@ class _SettingsPageViewState extends State<SettingsPageView> {
Expanded( Expanded(
child: Text( child: Text(
T('update.auto'), T('update.auto'),
style: const TextStyle(fontSize: 12.5, color: GcColors.muted), style: TextStyle(fontSize: 12.5, color: GcColors.muted),
), ),
), ),
], ],
@@ -1414,7 +1808,7 @@ class _AboutPageViewState extends State<AboutPageView> {
children: <Widget>[ children: <Widget>[
Text( Text(
T('nav.about'), T('nav.about'),
style: const TextStyle( style: TextStyle(
fontSize: 20, fontSize: 20,
fontWeight: FontWeight.w700, fontWeight: FontWeight.w700,
color: GcColors.ink, color: GcColors.ink,
@@ -1432,7 +1826,7 @@ class _AboutPageViewState extends State<AboutPageView> {
crossAxisAlignment: CrossAxisAlignment.start, crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[ children: <Widget>[
Text(T('common.error'), Text(T('common.error'),
style: const TextStyle(color: GcColors.danger)), style: TextStyle(color: GcColors.danger)),
const SizedBox(height: 8), const SizedBox(height: 8),
GcHint(_error!), GcHint(_error!),
const SizedBox(height: 12), const SizedBox(height: 12),
@@ -1450,7 +1844,7 @@ class _AboutPageViewState extends State<AboutPageView> {
children: <Widget>[ children: <Widget>[
Text( Text(
_about?.appName ?? 'Morris GC', _about?.appName ?? 'Morris GC',
style: const TextStyle( style: TextStyle(
fontSize: 18, fontSize: 18,
fontWeight: FontWeight.w700, fontWeight: FontWeight.w700,
color: GcColors.ink, color: GcColors.ink,
@@ -1491,7 +1885,10 @@ class _AboutPageViewState extends State<AboutPageView> {
child: Column( child: Column(
crossAxisAlignment: CrossAxisAlignment.start, crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[ children: <Widget>[
GcSectionTitle(T('about.developers')), GcSectionTitle(
T('about.developers'),
trailing: GcHint(T('about.contributorsHint')),
),
const SizedBox(height: 12), const SizedBox(height: 12),
if ((_about?.contributors ?? const <ContributorInfo>[]).isEmpty) if ((_about?.contributors ?? const <ContributorInfo>[]).isEmpty)
GcHint(T('about.noContributors')) GcHint(T('about.noContributors'))
@@ -1508,7 +1905,7 @@ class _AboutPageViewState extends State<AboutPageView> {
? null ? null
: NetworkImage(contributor.avatarUrl!), : NetworkImage(contributor.avatarUrl!),
child: contributor.avatarUrl == null child: contributor.avatarUrl == null
? const Text('◎', ? Text('◎',
style: TextStyle( style: TextStyle(
fontSize: 12, color: GcColors.accent)) fontSize: 12, color: GcColors.accent))
: null, : null,
@@ -1517,7 +1914,7 @@ class _AboutPageViewState extends State<AboutPageView> {
Expanded( Expanded(
child: Text( child: Text(
contributor.name, contributor.name,
style: const TextStyle( style: TextStyle(
fontSize: 12.5, fontSize: 12.5,
fontWeight: FontWeight.w600, fontWeight: FontWeight.w600,
color: GcColors.ink, color: GcColors.ink,
@@ -1527,7 +1924,7 @@ class _AboutPageViewState extends State<AboutPageView> {
Text( Text(
T('about.contributions', T('about.contributions',
<Object?>[contributor.contributions]), <Object?>[contributor.contributions]),
style: const TextStyle( style: TextStyle(
fontSize: 11, color: GcColors.faint), fontSize: 11, color: GcColors.faint),
), ),
], ],
@@ -1548,12 +1945,12 @@ class _AboutPageViewState extends State<AboutPageView> {
SizedBox( SizedBox(
width: 160, width: 160,
child: Text(label, child: Text(label,
style: const TextStyle(fontSize: 12.5, color: GcColors.muted)), style: TextStyle(fontSize: 12.5, color: GcColors.muted)),
), ),
Expanded( Expanded(
child: SelectableText( child: SelectableText(
value, value,
style: const TextStyle(fontSize: 12, color: GcColors.ink), style: TextStyle(fontSize: 12, color: GcColors.ink),
), ),
), ),
], ],
+35 -10
View File
@@ -31,6 +31,10 @@ class ShellPage extends StatefulWidget {
} }
class _ShellPageState extends State<ShellPage> { class _ShellPageState extends State<ShellPage> {
/// 页面缓存:键为「索引:语言」。同一个页面只构建一次,切走时用
/// [Offstage] 保活(不参与布局/绘制),切回来无需重建、状态也不丢。
final Map<String, Widget> _pages = <String, Widget>{};
@override @override
void initState() { void initState() {
super.initState(); super.initState();
@@ -78,7 +82,27 @@ class _ShellPageState extends State<ShellPage> {
); );
} }
switch (controller.index) { // 只构建当前页;其余已访问页面保留在树上但处于 Offstage。
final key = '${controller.index}:${I18n.language.value}';
_pages.putIfAbsent(key, () => _buildPage(controller, controller.index));
final visibleKey = key;
return Stack(
children: <Widget>[
for (final entry in _pages.entries)
Offstage(
offstage: entry.key != visibleKey,
child: TickerMode(
enabled: entry.key == visibleKey,
child: entry.value,
),
),
],
);
}
Widget _buildPage(ShellController controller, int index) {
switch (index) {
case 1: case 1:
return DownloadPageView(controller: controller); return DownloadPageView(controller: controller);
case 2: case 2:
@@ -116,13 +140,13 @@ class _Sidebar extends StatelessWidget {
borderRadius: BorderRadius.circular(8), borderRadius: BorderRadius.circular(8),
), ),
alignment: Alignment.center, alignment: Alignment.center,
child: const Text( child: Text(
'◎', '◎',
style: TextStyle(fontSize: 14, color: GcColors.accent), style: TextStyle(fontSize: 14, color: GcColors.accent),
), ),
), ),
const SizedBox(width: 10), const SizedBox(width: 10),
const Expanded( Expanded(
child: Text( child: Text(
'Morris GC', 'Morris GC',
style: TextStyle( style: TextStyle(
@@ -162,7 +186,7 @@ class _Sidebar extends StatelessWidget {
padding: const EdgeInsets.only(left: 14), padding: const EdgeInsets.only(left: 14),
child: Text( child: Text(
'v${settings?.version ?? '—'}', 'v${settings?.version ?? '—'}',
style: const TextStyle(fontSize: 10.5, color: GcColors.faint), style: TextStyle(fontSize: 10.5, color: GcColors.faint),
), ),
), ),
Padding( Padding(
@@ -234,14 +258,15 @@ class _UpdateBar extends StatelessWidget {
@override @override
Widget build(BuildContext context) { Widget build(BuildContext context) {
return Container( return Container(
decoration: const BoxDecoration( decoration: BoxDecoration(
color: GcColors.surface, color: GcColors.surface,
border: Border(top: BorderSide(color: GcColors.line)), border: Border(top: BorderSide(color: GcColors.line)),
), ),
padding: const EdgeInsets.symmetric(horizontal: 20, vertical: 9), padding: const EdgeInsets.symmetric(horizontal: 20, vertical: 9),
child: Row( child: Row(
children: <Widget>[ children: <Widget>[
const Text('⟳', style: TextStyle(fontSize: 16, color: GcColors.accent)), Text('⟳',
style: TextStyle(fontSize: 16, color: GcColors.accent)),
const SizedBox(width: 12), const SizedBox(width: 12),
Expanded( Expanded(
child: Column( child: Column(
@@ -249,7 +274,7 @@ class _UpdateBar extends StatelessWidget {
children: <Widget>[ children: <Widget>[
Text( Text(
controller.updateStatus, controller.updateStatus,
style: const TextStyle( style: TextStyle(
fontSize: 12.5, fontSize: 12.5,
fontWeight: FontWeight.w600, fontWeight: FontWeight.w600,
color: GcColors.ink, color: GcColors.ink,
@@ -259,13 +284,13 @@ class _UpdateBar extends StatelessWidget {
if (controller.updateDetail.isNotEmpty) if (controller.updateDetail.isNotEmpty)
Text( Text(
controller.updateDetail, controller.updateDetail,
style: const TextStyle(fontSize: 11, color: GcColors.faint), style: TextStyle(fontSize: 11, color: GcColors.faint),
overflow: TextOverflow.ellipsis, overflow: TextOverflow.ellipsis,
), ),
if (controller.launcherNotice.isNotEmpty) if (controller.launcherNotice.isNotEmpty)
Text( Text(
controller.launcherNotice, controller.launcherNotice,
style: const TextStyle(fontSize: 11, color: GcColors.warn), style: TextStyle(fontSize: 11, color: GcColors.warn),
), ),
], ],
), ),
@@ -306,7 +331,7 @@ class _BackendDown extends StatelessWidget {
children: <Widget>[ children: <Widget>[
Text( Text(
T('common.error'), T('common.error'),
style: const TextStyle( style: TextStyle(
fontSize: 17, fontSize: 17,
fontWeight: FontWeight.w600, fontWeight: FontWeight.w600,
color: GcColors.ink, color: GcColors.ink,
+182 -43
View File
@@ -1,71 +1,210 @@
import 'package:flutter/material.dart'; import 'package:flutter/material.dart';
/// 与 Avalonia 启动器一致的深色配色。 /// 主题偏好(可在设置页切换,并持久化到后端 settings.theme)。
///
/// 支持深色 / 浅色 / 跟随系统三种;[mode] 变化会让 `main.dart` 重建
/// `MaterialApp`,`themeMode` 交给 Flutter 决定实际亮度。
class GcPalette {
GcPalette._();
/// 默认强调色,与 Avalonia 启动器一致。
static const Color defaultAccent = Color(0xFF8FB6FF);
static final ValueNotifier<Color> accent =
ValueNotifier<Color>(defaultAccent);
/// 当前主题模式(dark / light / system)。
static final ValueNotifier<ThemeMode> mode = ValueNotifier<ThemeMode>(ThemeMode.dark);
/// 设置页可选的预设色板。
static const List<Color> presets = <Color>[
Color(0xFF8FB6FF), // 极光蓝(默认)
Color(0xFF7C6CFF), // 星云紫
Color(0xFF4FD1C5), // 湖水青
Color(0xFF6BE3A2), // 极光绿
Color(0xFFFFC46B), // 暖阳橙
Color(0xFFFF8FB1), // 樱粉
Color(0xFFFF7A7A), // 珊瑚红
Color(0xFFB0BEC5), // 石墨灰
];
/// 把后端设置里的 `theme` 字符串转成 [ThemeMode](未知值按深色处理)。
static ThemeMode parseMode(String? value) {
switch ((value ?? '').trim().toLowerCase()) {
case 'light':
return ThemeMode.light;
case 'system':
return ThemeMode.system;
case 'dark':
default:
return ThemeMode.dark;
}
}
/// 把 [ThemeMode] 转回后端设置的字符串。
static String modeToName(ThemeMode value) {
switch (value) {
case ThemeMode.light:
return 'light';
case ThemeMode.system:
return 'system';
case ThemeMode.dark:
return 'dark';
}
}
/// 应用主题模式(来自后端设置)。
static void applyTheme(String? value) {
final next = parseMode(value);
if (mode.value != next) mode.value = next;
}
/// 把 `#RRGGBB` / `RRGGBB` 解析为颜色;非法返回 null。
static Color? parseHex(String? value) {
if (value == null) return null;
var hex = value.trim();
if (hex.startsWith('#')) hex = hex.substring(1);
if (hex.length == 8) hex = hex.substring(2); // 忽略 alpha
if (hex.length != 6) return null;
final parsed = int.tryParse(hex, radix: 16);
if (parsed == null) return null;
return Color(0xFF000000 | parsed);
}
/// 颜色转 `#RRGGBB`。
static String toHex(Color color) {
// ignore: deprecated_member_use
final rgb = color.value & 0xFFFFFF;
return '#${rgb.toRadixString(16).padLeft(6, '0').toUpperCase()}';
}
/// 应用颜色(来自后端设置或用户点选)。
static void apply(String? hex) {
final color = parseHex(hex);
if (color == null) return;
// ignore: deprecated_member_use
if (accent.value.value != color.value) accent.value = color;
}
}
/// 配色:浅色 / 深色两套,按当前 [Brightness] 取值。
///
/// 以前这里是 const 常量,主题只能是深色 —— 设置里的 `theme` 字段写了也没人读。
/// 改成 getter 后,所有引用点自动跟随主题;代价是不能再放进 const 上下文。
class GcColors { class GcColors {
GcColors._(); GcColors._();
static const Color appBg = Color(0xFF0A1226); static bool _dark = true;
static const Color sideBg = Color(0xFF0C1529);
static const Color surface = Color(0xFF111C33); static bool get isDark => _dark;
static const Color surfaceAlt = Color(0xFF16233C);
static const Color line = Color(0xFF1B2740); /// 由 `MaterialApp.builder` 在每次构建前按实际亮度绑定。
static const Color accent = Color(0xFF8FB6FF); static void bind(Brightness brightness) => _dark = brightness == Brightness.dark;
static const Color accentStrong = Color(0xFF4C7DFF);
static const Color ink = Color(0xFFF2F6FF); static Color _pick(int dark, int light) => Color(_dark ? dark : light);
static const Color muted = Color(0xFFA9B8D4);
static const Color faint = Color(0xFF7C90B4); static Color get appBg => _pick(0xFF0A1226, 0xFFF3F6FB);
static const Color warn = Color(0xFFFFC46B); static Color get sideBg => _pick(0xFF0C1529, 0xFFFFFFFF);
static const Color danger = Color(0xFFFF7A7A); static Color get surface => _pick(0xFF111C33, 0xFFFFFFFF);
static const Color ok = Color(0xFF6BE3A2); static Color get surfaceAlt => _pick(0xFF16233C, 0xFFE9EFFA);
static Color get line => _pick(0xFF1B2740, 0xFFD8E2F2);
static Color get ink => _pick(0xFFF2F6FF, 0xFF0F1B2D);
static Color get muted => _pick(0xFFA9B8D4, 0xFF46587A);
static Color get faint => _pick(0xFF7C90B4, 0xFF7286A6);
static Color get warn => _pick(0xFFFFC46B, 0xFFB26A00);
static Color get danger => _pick(0xFFFF7A7A, 0xFFC0392B);
static Color get ok => _pick(0xFF6BE3A2, 0xFF1E8E5A);
/// 侧栏「MENU」一类最弱的说明文字。
static Color get ghost => _pick(0xFF4C5F80, 0xFF97A8C4);
/// 当前强调色(动态,跟随设置)。
static Color get accent => GcPalette.accent.value;
/// 强调色的加深版本,用于主按钮 / 轨道。浅色主题下需要反向调整,
/// 否则强调色在浅背景上对比度不足。
static Color get accentStrong => _strongen(accent);
static Color _strongen(Color color) {
final hsl = HSLColor.fromColor(color);
final lightness = _dark ? hsl.lightness - 0.10 : hsl.lightness - 0.22;
return hsl
.withSaturation((hsl.saturation + 0.12).clamp(0.0, 1.0))
.withLightness(lightness.clamp(0.0, 1.0))
.toColor();
}
} }
ThemeData buildGcTheme() { /// 按指定亮度构建主题。
final base = ThemeData.dark(useMaterial3: true); ///
/// 注意:不要在这里改 [GcColors] 的全局状态 —— MaterialApp 会同时构建
/// theme 与 darkTheme,后构建的那个会把状态写脏。亮度绑定由 `main.dart`
/// 的 builder 统一完成。
ThemeData buildGcTheme(Brightness brightness) {
final isDark = brightness == Brightness.dark;
final base = isDark
? ThemeData.dark(useMaterial3: true)
: ThemeData.light(useMaterial3: true);
Color pick(int dark, int light) => Color(isDark ? dark : light);
final appBg = pick(0xFF0A1226, 0xFFF3F6FB);
final surface = pick(0xFF111C33, 0xFFFFFFFF);
final surfaceAlt = pick(0xFF16233C, 0xFFE9EFFA);
final line = pick(0xFF1B2740, 0xFFD8E2F2);
final ink = pick(0xFFF2F6FF, 0xFF0F1B2D);
final danger = pick(0xFFFF7A7A, 0xFFC0392B);
final accent = GcPalette.accent.value;
final hsl = HSLColor.fromColor(accent);
final accentStrong = hsl
.withSaturation((hsl.saturation + 0.12).clamp(0.0, 1.0))
.withLightness((hsl.lightness - (isDark ? 0.10 : 0.22)).clamp(0.0, 1.0))
.toColor();
return base.copyWith( return base.copyWith(
scaffoldBackgroundColor: GcColors.appBg, scaffoldBackgroundColor: appBg,
colorScheme: base.colorScheme.copyWith( colorScheme: base.colorScheme.copyWith(
primary: GcColors.accentStrong, brightness: brightness,
secondary: GcColors.accent, primary: accentStrong,
surface: GcColors.surface, secondary: accent,
error: GcColors.danger, surface: surface,
error: danger,
), ),
textTheme: base.textTheme.apply( textTheme: base.textTheme.apply(
bodyColor: GcColors.ink, bodyColor: ink,
displayColor: GcColors.ink, displayColor: ink,
), ),
dividerColor: GcColors.line, dividerColor: line,
cardTheme: const CardTheme( cardTheme: CardTheme(
color: GcColors.surface, color: surface,
elevation: 0, elevation: 0,
margin: EdgeInsets.zero, margin: EdgeInsets.zero,
), ),
sliderTheme: base.sliderTheme.copyWith( sliderTheme: base.sliderTheme.copyWith(
activeTrackColor: GcColors.accentStrong, activeTrackColor: accentStrong,
thumbColor: GcColors.accent, thumbColor: accent,
inactiveTrackColor: GcColors.line, inactiveTrackColor: line,
), ),
switchTheme: SwitchThemeData( switchTheme: SwitchThemeData(
thumbColor: WidgetStateProperty.resolveWith( thumbColor: WidgetStateProperty.resolveWith(
(states) => states.contains(WidgetState.selected) (states) => states.contains(WidgetState.selected) ? accent : GcColors.faint,
? GcColors.accent
: GcColors.faint,
), ),
trackColor: WidgetStateProperty.resolveWith( trackColor: WidgetStateProperty.resolveWith(
(states) => states.contains(WidgetState.selected) (states) => states.contains(WidgetState.selected)
? GcColors.accentStrong.withOpacity(0.45) ? accentStrong.withOpacity(0.45)
: GcColors.line, : line,
), ),
), ),
progressIndicatorTheme: const ProgressIndicatorThemeData( progressIndicatorTheme: ProgressIndicatorThemeData(
color: GcColors.accent, color: accent,
linearTrackColor: GcColors.line, linearTrackColor: line,
), ),
tooltipTheme: const TooltipThemeData( tooltipTheme: TooltipThemeData(
decoration: BoxDecoration( decoration: BoxDecoration(
color: GcColors.surfaceAlt, color: surfaceAlt,
borderRadius: BorderRadius.all(Radius.circular(6)), borderRadius: const BorderRadius.all(Radius.circular(6)),
), ),
textStyle: TextStyle(color: GcColors.ink, fontSize: 12), textStyle: TextStyle(color: ink, fontSize: 12),
), ),
); );
} }
@@ -107,7 +246,7 @@ class GcSectionTitle extends StatelessWidget {
Expanded( Expanded(
child: Text( child: Text(
text, text,
style: const TextStyle( style: TextStyle(
fontSize: 15, fontSize: 15,
fontWeight: FontWeight.w600, fontWeight: FontWeight.w600,
color: GcColors.ink, color: GcColors.ink,
@@ -129,6 +268,6 @@ class GcHint extends StatelessWidget {
@override @override
Widget build(BuildContext context) => Text( Widget build(BuildContext context) => Text(
text, text,
style: const TextStyle(fontSize: 12, color: GcColors.faint, height: 1.5), style: TextStyle(fontSize: 12, color: GcColors.faint, height: 1.5),
); );
} }
+1
View File
@@ -0,0 +1 @@
flutter/ephemeral
+146
View File
@@ -0,0 +1,146 @@
# Project-level configuration.
cmake_minimum_required(VERSION 3.10)
project(runner LANGUAGES CXX)
# The name of the executable created for the application. Change this to change
# the on-disk name of your application.
set(BINARY_NAME "GC-UI")
# The unique GTK application identifier for this application. See:
# https://wiki.gnome.org/HowDoI/ChooseApplicationID
set(APPLICATION_ID "com.xhmcl.GC")
# Explicitly opt in to modern CMake behaviors to avoid warnings with recent
# versions of CMake.
cmake_policy(SET CMP0063 NEW)
# Load bundled libraries from the lib/ directory relative to the binary.
set(CMAKE_INSTALL_RPATH "$ORIGIN/lib")
# Root filesystem for cross-building.
if(FLUTTER_TARGET_PLATFORM_SYSROOT)
set(CMAKE_SYSROOT ${FLUTTER_TARGET_PLATFORM_SYSROOT})
set(CMAKE_FIND_ROOT_PATH ${CMAKE_SYSROOT})
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
endif()
# Define build configuration options.
if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
set(CMAKE_BUILD_TYPE "Debug" CACHE
STRING "Flutter build mode" FORCE)
set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS
"Debug" "Profile" "Release")
endif()
# Compilation settings that should be applied to most targets.
#
# Be cautious about adding new options here, as plugins use this function by
# default. In most cases, you should add new options to specific targets instead
# of modifying this function.
function(APPLY_STANDARD_SETTINGS TARGET)
target_compile_features(${TARGET} PUBLIC cxx_std_14)
target_compile_options(${TARGET} PRIVATE -Wall -Werror)
target_compile_options(${TARGET} PRIVATE "$<$<NOT:$<CONFIG:Debug>>:-O3>")
target_compile_definitions(${TARGET} PRIVATE "$<$<NOT:$<CONFIG:Debug>>:NDEBUG>")
endfunction()
# Flutter library and tool build rules.
set(FLUTTER_MANAGED_DIR "${CMAKE_CURRENT_SOURCE_DIR}/flutter")
add_subdirectory(${FLUTTER_MANAGED_DIR})
# System-level dependencies.
find_package(PkgConfig REQUIRED)
pkg_check_modules(GTK REQUIRED IMPORTED_TARGET gtk+-3.0)
add_definitions(-DAPPLICATION_ID="${APPLICATION_ID}")
# Define the application target. To change its name, change BINARY_NAME above,
# not the value here, or `flutter run` will no longer work.
#
# Any new source files that you add to the application should be added here.
add_executable(${BINARY_NAME}
"main.cc"
"my_application.cc"
"${FLUTTER_MANAGED_DIR}/generated_plugin_registrant.cc"
)
# Apply the standard set of build settings. This can be removed for applications
# that need different build settings.
apply_standard_settings(${BINARY_NAME})
# Add dependency libraries. Add any application-specific dependencies here.
target_link_libraries(${BINARY_NAME} PRIVATE flutter)
target_link_libraries(${BINARY_NAME} PRIVATE PkgConfig::GTK)
# Run the Flutter tool portions of the build. This must not be removed.
add_dependencies(${BINARY_NAME} flutter_assemble)
# Only the install-generated bundle's copy of the executable will launch
# correctly, since the resources must in the right relative locations. To avoid
# people trying to run the unbundled copy, put it in a subdirectory instead of
# the default top-level location.
set_target_properties(${BINARY_NAME}
PROPERTIES
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/intermediates_do_not_run"
)
# Generated plugin build rules, which manage building the plugins and adding
# them to the application.
include(flutter/generated_plugins.cmake)
# === Installation ===
# By default, "installing" just makes a relocatable bundle in the build
# directory.
set(BUILD_BUNDLE_DIR "${PROJECT_BINARY_DIR}/bundle")
# 无条件强制安装到 build 目录下的 bundle:某些环境下 CMAKE_INSTALL_PREFIX
# 会被初始化成 /usr/local,导致 flutter build linux 声称成功、却把产物装进
# 系统目录,build/.../bundle 是空的。
set(CMAKE_INSTALL_PREFIX "${BUILD_BUNDLE_DIR}" CACHE PATH "Flutter bundle 输出目录" FORCE)
# Start with a clean build bundle directory every time.
install(CODE "
file(REMOVE_RECURSE \"${BUILD_BUNDLE_DIR}/\")
" COMPONENT Runtime)
set(INSTALL_BUNDLE_DATA_DIR "${CMAKE_INSTALL_PREFIX}/data")
set(INSTALL_BUNDLE_LIB_DIR "${CMAKE_INSTALL_PREFIX}/lib")
install(TARGETS ${BINARY_NAME} RUNTIME DESTINATION "${CMAKE_INSTALL_PREFIX}"
COMPONENT Runtime)
install(FILES "${FLUTTER_ICU_DATA_FILE}" DESTINATION "${INSTALL_BUNDLE_DATA_DIR}"
COMPONENT Runtime)
install(FILES "${FLUTTER_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}"
COMPONENT Runtime)
foreach(bundled_library ${PLUGIN_BUNDLED_LIBRARIES})
install(FILES "${bundled_library}"
DESTINATION "${INSTALL_BUNDLE_LIB_DIR}"
COMPONENT Runtime)
endforeach(bundled_library)
# Copy the native assets provided by the build.dart from all packages.
set(NATIVE_ASSETS_DIR "${PROJECT_BUILD_DIR}native_assets/linux/")
install(DIRECTORY "${NATIVE_ASSETS_DIR}"
DESTINATION "${INSTALL_BUNDLE_LIB_DIR}"
COMPONENT Runtime)
# Fully re-copy the assets directory on each build to avoid having stale files
# from a previous install.
set(FLUTTER_ASSET_DIR_NAME "flutter_assets")
install(CODE "
file(REMOVE_RECURSE \"${INSTALL_BUNDLE_DATA_DIR}/${FLUTTER_ASSET_DIR_NAME}\")
" COMPONENT Runtime)
install(DIRECTORY "${PROJECT_BUILD_DIR}/${FLUTTER_ASSET_DIR_NAME}"
DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" COMPONENT Runtime)
# Install the AOT library on non-Debug builds only.
if(NOT CMAKE_BUILD_TYPE MATCHES "Debug")
install(FILES "${AOT_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}"
COMPONENT Runtime)
endif()
@@ -0,0 +1,88 @@
# This file controls Flutter-level build steps. It should not be edited.
cmake_minimum_required(VERSION 3.10)
set(EPHEMERAL_DIR "${CMAKE_CURRENT_SOURCE_DIR}/ephemeral")
# Configuration provided via flutter tool.
include(${EPHEMERAL_DIR}/generated_config.cmake)
# TODO: Move the rest of this into files in ephemeral. See
# https://github.com/flutter/flutter/issues/57146.
# Serves the same purpose as list(TRANSFORM ... PREPEND ...),
# which isn't available in 3.10.
function(list_prepend LIST_NAME PREFIX)
set(NEW_LIST "")
foreach(element ${${LIST_NAME}})
list(APPEND NEW_LIST "${PREFIX}${element}")
endforeach(element)
set(${LIST_NAME} "${NEW_LIST}" PARENT_SCOPE)
endfunction()
# === Flutter Library ===
# System-level dependencies.
find_package(PkgConfig REQUIRED)
pkg_check_modules(GTK REQUIRED IMPORTED_TARGET gtk+-3.0)
pkg_check_modules(GLIB REQUIRED IMPORTED_TARGET glib-2.0)
pkg_check_modules(GIO REQUIRED IMPORTED_TARGET gio-2.0)
set(FLUTTER_LIBRARY "${EPHEMERAL_DIR}/libflutter_linux_gtk.so")
# Published to parent scope for install step.
set(FLUTTER_LIBRARY ${FLUTTER_LIBRARY} PARENT_SCOPE)
set(FLUTTER_ICU_DATA_FILE "${EPHEMERAL_DIR}/icudtl.dat" PARENT_SCOPE)
set(PROJECT_BUILD_DIR "${PROJECT_DIR}/build/" PARENT_SCOPE)
set(AOT_LIBRARY "${PROJECT_DIR}/build/lib/libapp.so" PARENT_SCOPE)
list(APPEND FLUTTER_LIBRARY_HEADERS
"fl_basic_message_channel.h"
"fl_binary_codec.h"
"fl_binary_messenger.h"
"fl_dart_project.h"
"fl_engine.h"
"fl_json_message_codec.h"
"fl_json_method_codec.h"
"fl_message_codec.h"
"fl_method_call.h"
"fl_method_channel.h"
"fl_method_codec.h"
"fl_method_response.h"
"fl_plugin_registrar.h"
"fl_plugin_registry.h"
"fl_standard_message_codec.h"
"fl_standard_method_codec.h"
"fl_string_codec.h"
"fl_value.h"
"fl_view.h"
"flutter_linux.h"
)
list_prepend(FLUTTER_LIBRARY_HEADERS "${EPHEMERAL_DIR}/flutter_linux/")
add_library(flutter INTERFACE)
target_include_directories(flutter INTERFACE
"${EPHEMERAL_DIR}"
)
target_link_libraries(flutter INTERFACE "${FLUTTER_LIBRARY}")
target_link_libraries(flutter INTERFACE
PkgConfig::GTK
PkgConfig::GLIB
PkgConfig::GIO
)
add_dependencies(flutter flutter_assemble)
# === Flutter tool backend ===
# _phony_ is a non-existent file to force this command to run every time,
# since currently there's no way to get a full input/output list from the
# flutter tool.
add_custom_command(
OUTPUT ${FLUTTER_LIBRARY} ${FLUTTER_LIBRARY_HEADERS}
${CMAKE_CURRENT_BINARY_DIR}/_phony_
COMMAND ${CMAKE_COMMAND} -E env
${FLUTTER_TOOL_ENVIRONMENT}
"${FLUTTER_ROOT}/packages/flutter_tools/bin/tool_backend.sh"
${FLUTTER_TARGET_PLATFORM} ${CMAKE_BUILD_TYPE}
VERBATIM
)
add_custom_target(flutter_assemble DEPENDS
"${FLUTTER_LIBRARY}"
${FLUTTER_LIBRARY_HEADERS}
)
+6
View File
@@ -0,0 +1,6 @@
#include "my_application.h"
int main(int argc, char** argv) {
g_autoptr(MyApplication) app = my_application_new();
return g_application_run(G_APPLICATION(app), argc, argv);
}
+124
View File
@@ -0,0 +1,124 @@
#include "my_application.h"
#include <flutter_linux/flutter_linux.h>
#ifdef GDK_WINDOWING_X11
#include <gdk/gdkx.h>
#endif
#include "flutter/generated_plugin_registrant.h"
struct _MyApplication {
GtkApplication parent_instance;
char** dart_entrypoint_arguments;
};
G_DEFINE_TYPE(MyApplication, my_application, GTK_TYPE_APPLICATION)
// Implements GApplication::activate.
static void my_application_activate(GApplication* application) {
MyApplication* self = MY_APPLICATION(application);
GtkWindow* window =
GTK_WINDOW(gtk_application_window_new(GTK_APPLICATION(application)));
// Use a header bar when running in GNOME as this is the common style used
// by applications and is the setup most users will be using (e.g. Ubuntu
// desktop).
// If running on X and not using GNOME then just use a traditional title bar
// in case the window manager does more exotic layout, e.g. tiling.
// If running on Wayland assume the header bar will work (may need changing
// if future cases occur).
gboolean use_header_bar = TRUE;
#ifdef GDK_WINDOWING_X11
GdkScreen* screen = gtk_window_get_screen(window);
if (GDK_IS_X11_SCREEN(screen)) {
const gchar* wm_name = gdk_x11_screen_get_window_manager_name(screen);
if (g_strcmp0(wm_name, "GNOME Shell") != 0) {
use_header_bar = FALSE;
}
}
#endif
if (use_header_bar) {
GtkHeaderBar* header_bar = GTK_HEADER_BAR(gtk_header_bar_new());
gtk_widget_show(GTK_WIDGET(header_bar));
gtk_header_bar_set_title(header_bar, "Morris GC");
gtk_header_bar_set_show_close_button(header_bar, TRUE);
gtk_window_set_titlebar(window, GTK_WIDGET(header_bar));
} else {
gtk_window_set_title(window, "Morris GC");
}
gtk_window_set_default_size(window, 1280, 720);
gtk_widget_show(GTK_WIDGET(window));
g_autoptr(FlDartProject) project = fl_dart_project_new();
fl_dart_project_set_dart_entrypoint_arguments(project, self->dart_entrypoint_arguments);
FlView* view = fl_view_new(project);
gtk_widget_show(GTK_WIDGET(view));
gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(view));
fl_register_plugins(FL_PLUGIN_REGISTRY(view));
gtk_widget_grab_focus(GTK_WIDGET(view));
}
// Implements GApplication::local_command_line.
static gboolean my_application_local_command_line(GApplication* application, gchar*** arguments, int* exit_status) {
MyApplication* self = MY_APPLICATION(application);
// Strip out the first argument as it is the binary name.
self->dart_entrypoint_arguments = g_strdupv(*arguments + 1);
g_autoptr(GError) error = nullptr;
if (!g_application_register(application, nullptr, &error)) {
g_warning("Failed to register: %s", error->message);
*exit_status = 1;
return TRUE;
}
g_application_activate(application);
*exit_status = 0;
return TRUE;
}
// Implements GApplication::startup.
static void my_application_startup(GApplication* application) {
//MyApplication* self = MY_APPLICATION(object);
// Perform any actions required at application startup.
G_APPLICATION_CLASS(my_application_parent_class)->startup(application);
}
// Implements GApplication::shutdown.
static void my_application_shutdown(GApplication* application) {
//MyApplication* self = MY_APPLICATION(object);
// Perform any actions required at application shutdown.
G_APPLICATION_CLASS(my_application_parent_class)->shutdown(application);
}
// Implements GObject::dispose.
static void my_application_dispose(GObject* object) {
MyApplication* self = MY_APPLICATION(object);
g_clear_pointer(&self->dart_entrypoint_arguments, g_strfreev);
G_OBJECT_CLASS(my_application_parent_class)->dispose(object);
}
static void my_application_class_init(MyApplicationClass* klass) {
G_APPLICATION_CLASS(klass)->activate = my_application_activate;
G_APPLICATION_CLASS(klass)->local_command_line = my_application_local_command_line;
G_APPLICATION_CLASS(klass)->startup = my_application_startup;
G_APPLICATION_CLASS(klass)->shutdown = my_application_shutdown;
G_OBJECT_CLASS(klass)->dispose = my_application_dispose;
}
static void my_application_init(MyApplication* self) {}
MyApplication* my_application_new() {
return MY_APPLICATION(g_object_new(my_application_get_type(),
"application-id", APPLICATION_ID,
"flags", G_APPLICATION_NON_UNIQUE,
nullptr));
}
+18
View File
@@ -0,0 +1,18 @@
#ifndef FLUTTER_MY_APPLICATION_H_
#define FLUTTER_MY_APPLICATION_H_
#include <gtk/gtk.h>
G_DECLARE_FINAL_TYPE(MyApplication, my_application, MY, APPLICATION,
GtkApplication)
/**
* my_application_new:
*
* Creates a new Flutter-based application.
*
* Returns: a new #MyApplication.
*/
MyApplication* my_application_new();
#endif // FLUTTER_MY_APPLICATION_H_
@@ -5,10 +5,10 @@
// 'flutter create' template. // 'flutter create' template.
// The application's name. By default this is also the title of the Flutter window. // The application's name. By default this is also the title of the Flutter window.
PRODUCT_NAME = gc_ui PRODUCT_NAME = GC-UI
// The application's bundle identifier // The application's bundle identifier
PRODUCT_BUNDLE_IDENTIFIER = com.morris.gc.gcUi PRODUCT_BUNDLE_IDENTIFIER = com.morris.gc.gcUi
// The copyright displayed in application information // The copyright displayed in application information
PRODUCT_COPYRIGHT = Copyright © 2026 com.morris.gc. All rights reserved. PRODUCT_COPYRIGHT = Copyright © 2026 Morris. All rights reserved.
+1 -1
View File
@@ -73,7 +73,7 @@ void main() {
testWidgets('renders a card with its child', (tester) async { testWidgets('renders a card with its child', (tester) async {
await tester.pumpWidget( await tester.pumpWidget(
MaterialApp( MaterialApp(
theme: buildGcTheme(), theme: buildGcTheme(Brightness.dark),
home: const Scaffold( home: const Scaffold(
body: GcCard(child: Text('hello')), body: GcCard(child: Text('hello')),
), ),
+27 -3
View File
@@ -123,17 +123,21 @@ void main() {
'uiAvailable': true, 'uiAvailable': true,
}); });
Future<void> shoot(WidgetTester tester, String name, Widget page) async { Future<void> shoot(WidgetTester tester, String name, Widget page,
{Brightness brightness = Brightness.dark}) async {
tester.view.physicalSize = const Size(1280, 820); tester.view.physicalSize = const Size(1280, 820);
tester.view.devicePixelRatio = 1.0; tester.view.devicePixelRatio = 1.0;
addTearDown(tester.view.reset); addTearDown(tester.view.reset);
// GcColors 是静态取值,截图前先按目标亮度绑定,否则浅色截图仍是深色配色。
GcColors.bind(brightness);
final key = GlobalKey(); final key = GlobalKey();
await tester.pumpWidget( await tester.pumpWidget(
MaterialApp( MaterialApp(
debugShowCheckedModeBanner: false, debugShowCheckedModeBanner: false,
theme: buildGcTheme().copyWith( theme: buildGcTheme(brightness).copyWith(
textTheme: buildGcTheme().textTheme.apply( textTheme: buildGcTheme(brightness).textTheme.apply(
fontFamily: 'Noto Sans CJK SC', fontFamily: 'Noto Sans CJK SC',
), ),
), ),
@@ -290,4 +294,24 @@ void main() {
I18n.language.value = 'zh-CN'; I18n.language.value = 'zh-CN';
await shoot(tester, 'shell', ShellPage(controller: sampleController())); await shoot(tester, 'shell', ShellPage(controller: sampleController()));
}); });
testWidgets('home-light', (tester) async {
I18n.language.value = 'zh-CN';
await shoot(
tester,
'home-light',
HomePageView(controller: sampleController(), initialModels: sampleModels()),
brightness: Brightness.light,
);
});
testWidgets('settings-light', (tester) async {
I18n.language.value = 'zh-CN';
await shoot(
tester,
'settings-light',
SettingsPageView(controller: sampleController()),
brightness: Brightness.light,
);
});
} }
+1 -1
View File
@@ -4,7 +4,7 @@ project(gc_ui LANGUAGES CXX)
# The name of the executable created for the application. Change this to change # The name of the executable created for the application. Change this to change
# the on-disk name of your application. # the on-disk name of your application.
set(BINARY_NAME "gc_ui") set(BINARY_NAME "GC-UI")
# Explicitly opt in to modern CMake behaviors to avoid warnings with recent # Explicitly opt in to modern CMake behaviors to avoid warnings with recent
# versions of CMake. # versions of CMake.
+6 -6
View File
@@ -89,13 +89,13 @@ BEGIN
BEGIN BEGIN
BLOCK "040904e4" BLOCK "040904e4"
BEGIN BEGIN
VALUE "CompanyName", "com.morris.gc" "\0" VALUE "CompanyName", "Morris" "\0"
VALUE "FileDescription", "gc_ui" "\0" VALUE "FileDescription", "GC UI" "\0"
VALUE "FileVersion", VERSION_AS_STRING "\0" VALUE "FileVersion", VERSION_AS_STRING "\0"
VALUE "InternalName", "gc_ui" "\0" VALUE "InternalName", "GC-UI" "\0"
VALUE "LegalCopyright", "Copyright (C) 2026 com.morris.gc. All rights reserved." "\0" VALUE "LegalCopyright", "Copyright (C) 2026 Morris. All rights reserved." "\0"
VALUE "OriginalFilename", "gc_ui.exe" "\0" VALUE "OriginalFilename", "GC-UI.exe" "\0"
VALUE "ProductName", "gc_ui" "\0" VALUE "ProductName", "Morris GC" "\0"
VALUE "ProductVersion", VERSION_AS_STRING "\0" VALUE "ProductVersion", VERSION_AS_STRING "\0"
END END
END END
+1 -1
View File
@@ -27,7 +27,7 @@ int APIENTRY wWinMain(_In_ HINSTANCE instance, _In_opt_ HINSTANCE prev,
FlutterWindow window(project); FlutterWindow window(project);
Win32Window::Point origin(10, 10); Win32Window::Point origin(10, 10);
Win32Window::Size size(1280, 720); Win32Window::Size size(1280, 720);
if (!window.Create(L"gc_ui", origin, size)) { if (!window.Create(L"Morris GC", origin, size)) {
return EXIT_FAILURE; return EXIT_FAILURE;
} }
window.SetQuitOnClose(true); window.SetQuitOnClose(true);
+5 -2
View File
@@ -13,6 +13,9 @@ public sealed class AppSettings
/// <summary>light | dark</summary> /// <summary>light | dark</summary>
public string Theme { get; set; } = "light"; public string Theme { get; set; } = "light";
/// <summary>主题强调色(#RRGGBB),由设置页自定义并持久化。</summary>
public string AccentColor { get; set; } = "#8FB6FF";
/// <summary>渲染帧率:24 / 30 / 60 / 90 / 120(上限 120,关闭 VSync 同步)</summary> /// <summary>渲染帧率:24 / 30 / 60 / 90 / 120(上限 120,关闭 VSync 同步)</summary>
public int RenderFps { get; set; } = 120; public int RenderFps { get; set; } = 120;
@@ -37,8 +40,8 @@ public sealed class AppSettings
/// <summary>启动时检查模型 / 启动器是否为最新版。</summary> /// <summary>启动时检查模型 / 启动器是否为最新版。</summary>
public bool AutoUpdateOnStartup { get; set; } = true; public bool AutoUpdateOnStartup { get; set; } = true;
/// <summary>默认更新仓库地址。</summary> /// <summary>默认更新仓库地址(暂时只使用 Xhmcl,GitCode 实现保留但不再调用)。</summary>
public string UpdateRepository { get; set; } = "https://gitcode.com/Morris_1/GC"; public string UpdateRepository { get; set; } = "https://git.xhmcl.com/Morris/GC";
/// <summary>版本清单地址覆盖(留空则按 UpdateRepository 拼接)。</summary> /// <summary>版本清单地址覆盖(留空则按 UpdateRepository 拼接)。</summary>
public string? UpdateManifestUrl { get; set; } public string? UpdateManifestUrl { get; set; }
+11 -2
View File
@@ -20,12 +20,21 @@ public static class SignatureKeyring
private static readonly List<KeyEntry> KeysInternal = new() private static readonly List<KeyEntry> KeysInternal = new()
{ {
// 生产密钥(2026-11 生成)。指纹 b41b1dd6259ea9ed // 生产密钥(2026-12 换发)。指纹 ee6083be47a87907
// 上一代 gc-2026-11 的私钥没有留存,无法再签出可通过校验的清单,
// 因此新增这一把;旧公钥保留一个版本周期,方便过渡期排查。
new KeyEntry(
"gc-2026-12",
"MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4R+R2Pvinsu/xdaUu5mATPyYoEpL6" +
"cyugSVKAVMz6yY15SjkgEvdosfWuQJBbrPOOgGulE6Jht6v7FZx1dQguQ==",
"GC 主发布密钥"),
// 已停用(私钥遗失):保留仅为兼容历史诊断输出,不能用于验签新清单。
new KeyEntry( new KeyEntry(
"gc-2026-11", "gc-2026-11",
"MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEny5YKVBZUzOyRcSiuutlGmBb4+xm" + "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEny5YKVBZUzOyRcSiuutlGmBb4+xm" +
"PrNDGshilBlpmFyWu5Atq+FGP2tn+8Or8V7OH+/7lhCmXu8jZuC5/5CWSw==", "PrNDGshilBlpmFyWu5Atq+FGP2tn+8Or8V7OH+/7lhCmXu8jZuC5/5CWSw==",
"GC 主发布密钥") "已停用:私钥遗失")
}; };
static SignatureKeyring() => LoadFromEnvironment(); static SignatureKeyring() => LoadFromEnvironment();
+11 -1
View File
@@ -8,12 +8,14 @@ namespace GC.Services;
/// 运行目录约定(可执行文件旁边,不内置任何模型): /// 运行目录约定(可执行文件旁边,不内置任何模型):
/// <code> /// <code>
/// &lt;安装目录&gt;/ /// &lt;安装目录&gt;/
/// GC(.exe | .app/...) /// GCL(.exe | .app/...)
/// .GC/ /// .GC/
/// settings.json 设置与已安装版本记录 /// settings.json 设置与已安装版本记录
/// model/ 模型(启动时下载) /// model/ 模型(启动时下载)
/// cache/ 下载缓存 / 原子替换暂存 /// cache/ 下载缓存 / 原子替换暂存
/// update/ 待下次启动应用的启动器更新包 /// update/ 待下次启动应用的启动器更新包
/// safedog/ 更新守护进程(首次启动从安装包复制过来)
/// logs/ 日志,按天分中英两份:gc-YYYYMMDD.log / .en.log
/// </code> /// </code>
/// 开发态同样使用仓库根 .GC/model,并自动同步仓库 model/ 的可分发部分。 /// 开发态同样使用仓库根 .GC/model,并自动同步仓库 model/ 的可分发部分。
/// EMS_MODELS / EMS_DATA / EMS_HOME 可显式覆盖。 /// EMS_MODELS / EMS_DATA / EMS_HOME 可显式覆盖。
@@ -40,6 +42,12 @@ public sealed class AppPaths
public string CacheRoot => Path.Combine(HomeRoot, "cache"); public string CacheRoot => Path.Combine(HomeRoot, "cache");
public string UpdateRoot => Path.Combine(HomeRoot, "update"); public string UpdateRoot => Path.Combine(HomeRoot, "update");
/// <summary>日志目录:<c>.GC/logs</c>,里面按天放中英两份日志。</summary>
public string LogsRoot => Path.Combine(HomeRoot, "logs");
/// <summary>守护进程目录:<c>.GC/safedog</c>(程序本体与用户数据分开)。</summary>
public string SafedogRoot => Path.Combine(HomeRoot, "safedog");
/// <summary>用户配置目录(与可重建的缓存分开,删 cache 不会丢设置)。</summary> /// <summary>用户配置目录(与可重建的缓存分开,删 cache 不会丢设置)。</summary>
public string ConfigRoot => Path.Combine(HomeRoot, "config"); public string ConfigRoot => Path.Combine(HomeRoot, "config");
@@ -255,6 +263,8 @@ public sealed class AppPaths
Directory.CreateDirectory(CacheRoot); Directory.CreateDirectory(CacheRoot);
Directory.CreateDirectory(ModelRoot); Directory.CreateDirectory(ModelRoot);
Directory.CreateDirectory(UpdateRoot); Directory.CreateDirectory(UpdateRoot);
Directory.CreateDirectory(LogsRoot);
Directory.CreateDirectory(SafedogRoot);
MigrateLegacySettings(); MigrateLegacySettings();
+191 -46
View File
@@ -1,5 +1,6 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq;
using System.Net.Http; using System.Net.Http;
using System.Text.Json; using System.Text.Json;
using System.Threading; using System.Threading;
@@ -7,50 +8,70 @@ using System.Threading.Tasks;
namespace GC.Services; namespace GC.Services;
/// <summary>GitCode 仓库的一位贡献者。</summary> /// <summary>仓库的一位贡献者(按人归并后的结果)。</summary>
public sealed class Contributor public sealed class Contributor
{ {
public string Name { get; set; } = ""; public string Name { get; set; } = "";
public string? Email { get; set; } public string? Email { get; set; }
/// <summary>提交次数(API 里的 contributions)。</summary> /// <summary>提交次数。</summary>
public int Contributions { get; set; } public int Contributions { get; set; }
/// <summary> /// <summary>接口直接返回的头像地址(Gitea 的 avatar_url);为空时按邮箱哈希生成。</summary>
/// 登录名 -> 展示名。GitCode 的 contributors 接口只返回账号登录名, public string? Avatar { get; set; }
/// 不返回真实姓名,这里做一层映射,让关于页显示作者想展示的名字。
/// </summary>
private static readonly Dictionary<string, string> DisplayNames = new(StringComparer.OrdinalIgnoreCase)
{
["Morris_1"] = "Morris"
};
/// <summary>头像地址:GitCode 用邮箱哈希拼头像,取不到时返回 null。</summary> /// <summary>最近一次提交时间,用于贡献数相同时排序。</summary>
public DateTimeOffset? LastCommit { get; set; }
/// <summary>关于页展示的名字。</summary>
public string DisplayName => string.IsNullOrWhiteSpace(Name) ? "匿名" : Name;
/// <summary>头像地址:优先用接口返回的头像,否则按邮箱哈希拼 GitCode 头像。</summary>
public string? AvatarUrl => public string? AvatarUrl =>
string.IsNullOrWhiteSpace(Email) !string.IsNullOrWhiteSpace(Avatar)
? null ? Avatar
: $"https://cdn-img.gitcode.com/avatar/{Convert.ToHexString( : string.IsNullOrWhiteSpace(Email)
System.Security.Cryptography.MD5.HashData( ? null
System.Text.Encoding.UTF8.GetBytes(Email!.Trim().ToLowerInvariant()))) : $"https://cdn-img.gitcode.com/avatar/{Convert.ToHexString(
.ToLowerInvariant()}"; System.Security.Cryptography.MD5.HashData(
System.Text.Encoding.UTF8.GetBytes(Email!.Trim().ToLowerInvariant())))
public string DisplayName .ToLowerInvariant()}";
{
get
{
if (string.IsNullOrWhiteSpace(Name)) return "匿名";
return DisplayNames.TryGetValue(Name.Trim(), out var mapped) ? mapped : Name;
}
}
} }
/// <summary> /// <summary>
/// 读取 GitCode 仓库的贡献者列表(用于「关于」页面展示开发者)。 /// 读取仓库的真实贡献者:翻页拉提交记录,按作者归并统计。
/// 失败时静默返回空列表,不影响关于页其它内容。 ///
/// 为什么不用 /collaborators:Gitea 的协同者列表要求登录,且只包含被显式
/// 添加的协作者,和「谁真的写了代码」是两回事。这里直接读 /commits,
/// 统计每个人真实的提交数,失败时静默返回空列表,不影响关于页其它内容。
/// </summary> /// </summary>
public static class ContributorsService public static class ContributorsService
{ {
private const int PageSize = 50;
private const int MaxPages = 12;
private const int MaxShown = 8;
private static readonly TimeSpan CacheTtl = TimeSpan.FromMinutes(10);
private static readonly HttpClient Http = CreateHttp(); private static readonly HttpClient Http = CreateHttp();
/// <summary>同一作者的多个 git 身份 -> 统一展示名。</summary>
private static readonly Dictionary<string, string> Aliases = new(StringComparer.OrdinalIgnoreCase)
{
["morris"] = "Morris",
["morris_1"] = "Morris",
["2509_92447106"] = "Morris",
["chenmoyuan1214@qq.com"] = "Morris",
["morris@xhmcl.com"] = "Morris",
};
/// <summary>自动化提交(CI / 助手账号),不计入开发者。</summary>
private static readonly HashSet<string> IgnoredEmails = new(StringComparer.OrdinalIgnoreCase)
{
"agent@teamily.ai",
};
private static readonly object Gate = new();
private static (DateTimeOffset At, string Key, List<Contributor> Items)? _cache;
private static HttpClient CreateHttp() private static HttpClient CreateHttp()
{ {
var c = new HttpClient { Timeout = TimeSpan.FromSeconds(10) }; var c = new HttpClient { Timeout = TimeSpan.FromSeconds(10) };
@@ -59,48 +80,172 @@ public static class ContributorsService
return c; return c;
} }
/// <summary>默认仓库的 contributors 接口地址。</summary> /// <summary>按仓库地址推导接口:Xhmcl(Gitea) 与 GitCode 结构不同。</summary>
public static string BuildUrl(string repository) public static string BuildUrl(string repository)
{ {
var raw = string.IsNullOrWhiteSpace(repository) var raw = string.IsNullOrWhiteSpace(repository)
? SourcePreset.GitCode.HomeUrl : repository.Trim(); ? SourcePreset.Xhmcl.HomeUrl : repository.Trim();
if (!Uri.TryCreate(raw, UriKind.Absolute, out var uri)) if (!Uri.TryCreate(raw, UriKind.Absolute, out var uri))
return "https://api.gitcode.com/api/v5/repos/Morris_1/GC/contributors"; return "https://git.xhmcl.com/api/v1/repos/Morris/GC/commits";
var parts = uri.AbsolutePath.Trim('/').Split('/', StringSplitOptions.RemoveEmptyEntries); var parts = uri.AbsolutePath.Trim('/').Split('/', StringSplitOptions.RemoveEmptyEntries);
if (parts.Length < 2) if (parts.Length < 2)
return "https://api.gitcode.com/api/v5/repos/Morris_1/GC/contributors"; return "https://git.xhmcl.com/api/v1/repos/Morris/GC/commits";
var repo = parts[1].EndsWith(".git", StringComparison.OrdinalIgnoreCase) var repo = parts[1].EndsWith(".git", StringComparison.OrdinalIgnoreCase)
? parts[1][..^4] : parts[1]; ? parts[1][..^4] : parts[1];
return $"https://api.gitcode.com/api/v5/repos/{parts[0]}/{repo}/contributors";
// GitCode 的实现在仓库仍指向 gitcode.com 时才走它。
if (uri.Host.Contains("gitcode.com", StringComparison.OrdinalIgnoreCase))
return $"https://api.gitcode.com/api/v5/repos/{parts[0]}/{repo}/contributors";
return $"https://{uri.Host}/api/v1/repos/{parts[0]}/{repo}/commits";
} }
public static async Task<List<Contributor>> FetchAsync(string repository, CancellationToken ct = default) public static async Task<List<Contributor>> FetchAsync(string repository, CancellationToken ct = default)
{ {
var url = BuildUrl(repository); var url = BuildUrl(repository);
lock (Gate)
{
if (_cache is { } hit && hit.Key == url && DateTimeOffset.UtcNow - hit.At < CacheTtl)
return hit.Items;
}
List<Contributor> list;
try try
{ {
using var timeout = CancellationTokenSource.CreateLinkedTokenSource(ct); using var timeout = CancellationTokenSource.CreateLinkedTokenSource(ct);
timeout.CancelAfter(TimeSpan.FromSeconds(10)); timeout.CancelAfter(TimeSpan.FromSeconds(15));
var text = await Http.GetStringAsync(url, timeout.Token); list = url.Contains("api.gitcode.com", StringComparison.OrdinalIgnoreCase)
var trimmed = text.TrimStart(); ? await FetchFromGitCodeAsync(url, timeout.Token)
if (trimmed.Length == 0 || trimmed[0] != '[') return new List<Contributor>(); : await FetchFromCommitsAsync(url, timeout.Token);
var list = JsonSerializer.Deserialize<List<Contributor>>(text, new JsonSerializerOptions
{
PropertyNameCaseInsensitive = true
}) ?? new List<Contributor>();
// 按提交数从多到少,贡献最多的排最前
list.Sort((a, b) => b.Contributions.CompareTo(a.Contributions));
return list;
} }
catch (Exception ex) catch (Exception ex)
{ {
Console.Error.WriteLine($"读取贡献者失败: {ex.Message}"); Console.Error.WriteLine($"读取贡献者失败: {ex.Message}");
return new List<Contributor>(); return new List<Contributor>();
} }
lock (Gate) _cache = (DateTimeOffset.UtcNow, url, list);
return list;
} }
/// <summary>Gitea:翻页读提交记录并归并作者。</summary>
private static async Task<List<Contributor>> FetchFromCommitsAsync(string commitUrl, CancellationToken ct)
{
var byKey = new Dictionary<string, Contributor>(StringComparer.OrdinalIgnoreCase);
for (var page = 1; page <= MaxPages; page++)
{
var url = $"{commitUrl}?limit={PageSize}&page={page}&stat=false";
var text = await Http.GetStringAsync(url, ct);
using var doc = JsonDocument.Parse(text);
if (doc.RootElement.ValueKind != JsonValueKind.Array) break;
var seen = 0;
foreach (var item in doc.RootElement.EnumerateArray())
{
seen++;
string? login = null, name = null, email = null, avatar = null;
DateTimeOffset? date = null;
if (item.TryGetProperty("author", out var author) &&
author.ValueKind == JsonValueKind.Object)
{
login = author.TryGetProperty("login", out var l) ? l.GetString() : null;
avatar = author.TryGetProperty("avatar_url", out var a) ? a.GetString() : null;
}
if (item.TryGetProperty("commit", out var commit) &&
commit.TryGetProperty("author", out var ca) &&
ca.ValueKind == JsonValueKind.Object)
{
name = ca.TryGetProperty("name", out var n) ? n.GetString() : null;
email = ca.TryGetProperty("email", out var e) ? e.GetString() : email;
if (ca.TryGetProperty("date", out var d) &&
DateTimeOffset.TryParse(d.GetString(), out var parsed))
date = parsed;
}
Add(byKey, login, name, email, avatar, date);
}
if (seen < PageSize) break;
}
return Sort(byKey.Values);
}
/// <summary>GitCode:contributors 接口直接返回贡献数与邮箱。</summary>
private static async Task<List<Contributor>> FetchFromGitCodeAsync(string url, CancellationToken ct)
{
var text = await Http.GetStringAsync(url, ct);
if (text.TrimStart().Length == 0 || text.TrimStart()[0] != '[')
return new List<Contributor>();
var byKey = new Dictionary<string, Contributor>(StringComparer.OrdinalIgnoreCase);
using var doc = JsonDocument.Parse(text);
foreach (var item in doc.RootElement.EnumerateArray())
{
var name = item.TryGetProperty("name", out var n) ? n.GetString() : null;
var email = item.TryGetProperty("email", out var e) ? e.GetString() : null;
var count = item.TryGetProperty("contributions", out var c) && c.TryGetInt32(out var v) ? v : 1;
var contributor = Add(byKey, null, name, email, null, null, count);
if (contributor != null) contributor.Contributions = Math.Max(contributor.Contributions, count);
}
return Sort(byKey.Values);
}
private static Contributor? Add(
Dictionary<string, Contributor> byKey,
string? login, string? name, string? email, string? avatar, DateTimeOffset? date,
int weight = 1)
{
if (!string.IsNullOrWhiteSpace(email) && IgnoredEmails.Contains(email.Trim()))
return null;
var (key, display) = Resolve(login, name, email);
if (!byKey.TryGetValue(key, out var contributor))
{
contributor = new Contributor { Name = display };
byKey[key] = contributor;
}
contributor.Contributions += weight;
if (string.IsNullOrWhiteSpace(contributor.Email) && !string.IsNullOrWhiteSpace(email))
contributor.Email = email;
if (string.IsNullOrWhiteSpace(contributor.Avatar) && !string.IsNullOrWhiteSpace(avatar))
contributor.Avatar = avatar;
if (date.HasValue && (contributor.LastCommit == null || date > contributor.LastCommit))
contributor.LastCommit = date;
return contributor;
}
/// <summary>把同一个人在不同时期的 git 身份归并到同一个展示名。</summary>
private static (string Key, string Display) Resolve(string? login, string? name, string? email)
{
foreach (var raw in new[] { login, name, email })
{
if (string.IsNullOrWhiteSpace(raw)) continue;
if (Aliases.TryGetValue(raw.Trim(), out var display))
return ("#" + display.ToLowerInvariant(), display);
}
var label = !string.IsNullOrWhiteSpace(login) ? login!
: !string.IsNullOrWhiteSpace(name) ? name!
: email!;
return (label.Trim().ToLowerInvariant(), label.Trim());
}
private static List<Contributor> Sort(IEnumerable<Contributor> items) =>
items
.OrderByDescending(c => c.Contributions)
.ThenByDescending(c => c.LastCommit ?? DateTimeOffset.MinValue)
.ThenBy(c => c.Name, StringComparer.OrdinalIgnoreCase)
.Take(MaxShown)
.ToList();
} }
+27 -1
View File
@@ -115,7 +115,6 @@ public static class DownloadModuleHost
public static class LauncherRuntimeInfo public static class LauncherRuntimeInfo
{ {
private static string? _versionOverride; private static string? _versionOverride;
public static string CurrentLauncherVersion public static string CurrentLauncherVersion
{ {
get get
@@ -155,3 +154,30 @@ public static class LauncherRuntimeInfo
public static void OverrideLauncherVersion(string? version) => _versionOverride = version; public static void OverrideLauncherVersion(string? version) => _versionOverride = version;
} }
/// <summary>
/// 界面(Flutter)与后端(GC.UI.Server)之间的约定:端口、环境变量名。
///
/// 之前这个端口在 GC-BOOT、后端、Flutter 前端各写了一遍 17890,改一处就断链;
/// 现在统一由这里定义,启动器选好端口后通过环境变量传给另外两边。
/// </summary>
public static class GcUiContract
{
/// <summary>默认端口(与历史版本保持一致,便于复用已在运行的后端)。</summary>
public const int DefaultPort = 17890;
/// <summary>端口被占用时最多向后尝试几个。</summary>
public const int PortScanRange = 10;
/// <summary>传给后端与前端的环境变量名。</summary>
public const string PortEnvVar = "GC_UI_PORT";
/// <summary>读取环境变量里指定的端口;非法或未设置时返回 <see cref="DefaultPort"/>。</summary>
public static int PortFromEnvironment()
{
var value = Environment.GetEnvironmentVariable(PortEnvVar);
return int.TryParse(value, out var port) && port > 0 && port < 65536
? port
: DefaultPort;
}
}
+94
View File
@@ -0,0 +1,94 @@
using System;
using System.IO;
using System.Text;
namespace GC.Services;
/// <summary>
/// 双语文件日志。
///
/// 每条记录同时写两个文件(都在 <c>.GC/logs</c> 下,按天滚动):
/// <code>
/// gc-20261118.log 中文
/// gc-20261118.en.log 英文
/// </code>
/// 中英分开而不是写在一个文件里:用户排查时不用在一行里找自己看得懂的那半句;
/// 也给反馈问题时直接发对应语言的文件即可。
///
/// 日志失败绝不影响主流程(磁盘满、只读目录都只是少一份日志)。
/// </summary>
public static class GcLog
{
private static readonly object Gate = new();
private static string? _dir;
private static string _day = "";
private static string _zhPath = "";
private static string _enPath = "";
public static bool Enabled
{
get { lock (Gate) return _dir != null; }
}
/// <summary>绑定日志目录(通常是 <c>.GC/logs</c>)。重复调用会切到新目录。</summary>
public static void Init(string dir)
{
try
{
Directory.CreateDirectory(dir);
}
catch
{
// 目录都建不了就退化成只写控制台
return;
}
lock (Gate)
{
_dir = dir;
_day = "";
}
}
public static void Info(string zh, string en) => Write("INFO ", zh, en);
public static void Warn(string zh, string en) => Write("WARN ", zh, en);
public static void Error(string zh, string en) => Write("ERROR", zh, en);
private static void Write(string level, string zh, string en)
{
var now = DateTime.Now;
var prefix = $"{now:yyyy-MM-dd HH:mm:ss} [{level}] ";
var lineZh = prefix + zh;
var lineEn = prefix + en;
try { Console.WriteLine(lineZh); } catch { /* 无控制台 */ }
lock (Gate)
{
if (_dir == null) return;
var day = now.ToString("yyyyMMdd");
if (day != _day)
{
_day = day;
_zhPath = Path.Combine(_dir, $"gc-{day}.log");
_enPath = Path.Combine(_dir, $"gc-{day}.en.log");
}
Append(_zhPath, lineZh);
Append(_enPath, lineEn);
}
}
private static void Append(string path, string line)
{
try
{
File.AppendAllText(path, line + Environment.NewLine, new UTF8Encoding(false));
}
catch
{
// 日志失败不能影响程序
}
}
}
+68 -3
View File
@@ -9,10 +9,26 @@ namespace GC.Services;
/// <summary> /// <summary>
/// 本地模型库。启动器只**扫描 / 删除**模型包,不再解析或缓存任何场景数据 —— /// 本地模型库。启动器只**扫描 / 删除**模型包,不再解析或缓存任何场景数据 ——
/// 场景、贴图、界面都由模型自己的程序集负责。 /// 场景、贴图、界面都由模型自己的程序集负责。
///
/// 扫描结果与目录体积都做短时缓存:前端(首页 / 下载页)会频繁轮询
/// <c>/api/models</c>,而每个模型的体积要递归遍历整棵目录。没有缓存时
/// 一次刷新就是成千上万次 stat,低配机器上会明显卡顿。
/// </summary> /// </summary>
public sealed class ModelRepository public sealed class ModelRepository
{ {
/// <summary>扫描结果缓存时长:够挡住连点刷新,又不会让手动放进来的模型等太久。</summary>
private static readonly TimeSpan ScanTtl = TimeSpan.FromSeconds(2);
/// <summary>目录体积缓存时长(目录 mtime 变了会提前失效)。</summary>
private static readonly TimeSpan SizeTtl = TimeSpan.FromMinutes(1);
private readonly AppPaths _paths; private readonly AppPaths _paths;
private readonly object _gate = new();
private readonly Dictionary<string, (long Size, DateTime Stamp, DateTime At)> _sizes =
new(StringComparer.OrdinalIgnoreCase);
private List<ModelPackage>? _cache;
private DateTime _cacheAt = DateTime.MinValue;
public ModelRepository(AppPaths paths) => _paths = paths; public ModelRepository(AppPaths paths) => _paths = paths;
@@ -20,7 +36,13 @@ public sealed class ModelRepository
public IReadOnlyList<ModelPackage> Scan() public IReadOnlyList<ModelPackage> Scan()
{ {
lock (_gate)
{
if (_cache != null && DateTime.UtcNow - _cacheAt < ScanTtl) return _cache;
}
_paths.WaitForDevelopmentModels(); _paths.WaitForDevelopmentModels();
var result = new List<ModelPackage>(); var result = new List<ModelPackage>();
foreach (var (manifest, dir) in ModelScanner.Scan(_paths.ModelRoot)) foreach (var (manifest, dir) in ModelScanner.Scan(_paths.ModelRoot))
{ {
@@ -28,13 +50,20 @@ public sealed class ModelRepository
{ {
Manifest = manifest, Manifest = manifest,
Directory = dir, Directory = dir,
SizeBytes = ModelScanner.DirectorySize(dir) SizeBytes = SizeOf(dir)
}); });
} }
lock (_gate)
{
_cache = result;
_cacheAt = DateTime.UtcNow;
}
return result; return result;
} }
public ModelPackage? Find(string id) => Scan().FirstOrDefault(p => p.Id.Equals(id, StringComparison.OrdinalIgnoreCase)); public ModelPackage? Find(string id)
=> Scan().FirstOrDefault(p => p.Id.Equals(id, StringComparison.OrdinalIgnoreCase));
public bool Delete(string id) public bool Delete(string id)
{ {
@@ -43,6 +72,7 @@ public sealed class ModelRepository
try try
{ {
Directory.Delete(package.Directory, true); Directory.Delete(package.Directory, true);
Invalidate();
Changed?.Invoke(); Changed?.Invoke();
return true; return true;
} }
@@ -53,5 +83,40 @@ public sealed class ModelRepository
} }
} }
public void NotifyChanged() => Changed?.Invoke(); public void NotifyChanged()
{
Invalidate();
Changed?.Invoke();
}
/// <summary>清空缓存:模型被安装 / 删除 / 覆盖后必须调用。</summary>
private void Invalidate()
{
lock (_gate)
{
_cache = null;
_cacheAt = DateTime.MinValue;
}
lock (_sizes) _sizes.Clear();
}
/// <summary>目录体积,按「目录 mtime + TTL」缓存。</summary>
private long SizeOf(string dir)
{
DateTime stamp;
try { stamp = Directory.GetLastWriteTimeUtc(dir); }
catch { stamp = DateTime.MinValue; }
lock (_sizes)
{
if (_sizes.TryGetValue(dir, out var cached) &&
cached.Stamp == stamp &&
DateTime.UtcNow - cached.At < SizeTtl)
return cached.Size;
}
var size = ModelScanner.DirectorySize(dir);
lock (_sizes) _sizes[dir] = (size, stamp, DateTime.UtcNow);
return size;
}
} }
+2 -2
View File
@@ -21,7 +21,7 @@ public sealed class ReleaseInfo
public string Version => NormalizeVersion(TagName, Name); public string Version => NormalizeVersion(TagName, Name);
private static readonly string[] VersionPrefixes = private static readonly string[] VersionPrefixes =
{ "v", "V", "GC-", "gc-", "release-", "Release-" }; { "v", "V", "GCL-", "gcl-", "GC-", "gc-", "release-", "Release-" };
private static readonly string[] PrereleaseTags = private static readonly string[] PrereleaseTags =
{ "alpha", "beta", "rc", "pre", "dev", "snapshot" }; { "alpha", "beta", "rc", "pre", "dev", "snapshot" };
@@ -31,7 +31,7 @@ public sealed class ReleaseInfo
var raw = !string.IsNullOrWhiteSpace(tag) ? tag : name; var raw = !string.IsNullOrWhiteSpace(tag) ? tag : name;
if (string.IsNullOrWhiteSpace(raw)) return ""; if (string.IsNullOrWhiteSpace(raw)) return "";
raw = raw!.Trim(); raw = raw!.Trim();
// "v1.0.1" / "GC-1.0.1" / "release-1.0.1" -> 取第一段像版本号的部分 // "v1.0.1" / "GCL-1.0.1" / "GC-1.0.1" / "release-1.0.1" -> 取第一段像版本号的部分
foreach (var prefix in VersionPrefixes) foreach (var prefix in VersionPrefixes)
if (raw.StartsWith(prefix, StringComparison.Ordinal)) { raw = raw[prefix.Length..]; break; } if (raw.StartsWith(prefix, StringComparison.Ordinal)) { raw = raw[prefix.Length..]; break; }
// 形如 GC-1.0.1-Win-amd64 时只取版本段;但 2.3.0-beta 这类预发布串要保留完整。 // 形如 GC-1.0.1-Win-amd64 时只取版本段;但 2.3.0-beta 这类预发布串要保留完整。
+120
View File
@@ -0,0 +1,120 @@
using System;
using System.IO;
namespace GC.Services;
/// <summary>
/// 运行期目录准备:
/// <list type="number">
/// <item>创建 <c>.GC/logs</c> 与 <c>.GC/safedog</c>;</item>
/// <item>把安装包里的守护进程复制到 <c>.GC/safedog</c>(程序本体与用户数据分开);</item>
/// <item>初始化双语日志并写一条启动记录。</item>
/// </list>
///
/// 为什么要复制而不是直接用包里的:更新时会整目录替换程序文件,
/// 正在运行的守护进程无法被覆盖。放到 .GC 后,整目录替换永远不碰它,
/// 新版守护进程在下一次启动时复制进来即可。
/// </summary>
public static class RuntimeLayout
{
/// <summary>准备目录与日志,返回实际使用的守护进程路径(可能为 null)。</summary>
public static string? Ensure(AppPaths paths)
{
try { Directory.CreateDirectory(paths.LogsRoot); } catch { }
try { Directory.CreateDirectory(paths.SafedogRoot); } catch { }
GcLog.Init(paths.LogsRoot);
var safedog = InstallSafedog(paths);
GcLog.Info(
$"启动 GC {LauncherRuntimeInfo.CurrentLauncherVersion}({LauncherRuntimeInfo.CurrentRid})," +
$"数据目录 {paths.HomeRoot},守护进程 {(safedog == null ? "未找到" : Path.GetFileName(safedog))}",
$"Starting GC {LauncherRuntimeInfo.CurrentLauncherVersion} ({LauncherRuntimeInfo.CurrentRid}), " +
$"data directory {paths.HomeRoot}, safedog {(safedog == null ? "not found" : Path.GetFileName(safedog))}");
return safedog;
}
/// <summary>把包内守护进程同步到 <c>.GC/safedog</c>。已是最新则不动。</summary>
private static string? InstallSafedog(AppPaths paths)
{
var name = SavedogFiles.ExecutableName;
var target = Path.Combine(paths.SafedogRoot, name);
var source = FindPackaged(paths, name);
if (source != null && NeedsCopy(source, target))
{
try
{
Directory.CreateDirectory(paths.SafedogRoot);
File.Copy(source, target, overwrite: true);
MarkExecutable(target);
GcLog.Info($"已更新守护进程到 {target}", $"Safedog updated at {target}");
}
catch (Exception ex)
{
GcLog.Warn($"复制守护进程失败(继续使用已有版本):{ex.Message}",
$"Failed to copy safedog (falling back to the existing one): {ex.Message}");
}
}
return File.Exists(target) ? target : source;
}
private static string? FindPackaged(AppPaths paths, string name)
{
var candidates = new[]
{
Path.Combine(paths.InstallDirectory, "safedog", name),
Path.Combine(paths.InstallDirectory, name),
Path.Combine(paths.AppRoot, "safedog", name),
Path.Combine(paths.AppRoot, name),
};
foreach (var candidate in candidates)
{
if (File.Exists(candidate)) return candidate;
}
// macOS:可能在 .app/Contents/MacOS 里
try
{
foreach (var app in Directory.GetDirectories(paths.InstallDirectory, "*.app"))
{
var inside = Path.Combine(app, "Contents", "MacOS", name);
if (File.Exists(inside)) return inside;
}
}
catch { }
return null;
}
private static bool NeedsCopy(string source, string target)
{
try
{
if (!File.Exists(target)) return true;
var a = new FileInfo(source);
var b = new FileInfo(target);
return a.Length != b.Length || a.LastWriteTimeUtc > b.LastWriteTimeUtc;
}
catch
{
return true;
}
}
private static void MarkExecutable(string path)
{
if (OperatingSystem.IsWindows()) return;
try
{
var mode = File.GetUnixFileMode(path);
File.SetUnixFileMode(path, mode | UnixFileMode.UserExecute |
UnixFileMode.GroupExecute | UnixFileMode.OtherExecute);
}
catch { }
}
}
+8 -8
View File
@@ -18,10 +18,11 @@ public sealed class SettingsService
public void Load() public void Load()
{ {
Current = Json.Read<AppSettings>(_paths.SettingsFile) ?? new AppSettings(); Current = Json.Read<AppSettings>(_paths.SettingsFile) ?? new AppSettings();
if (Current.UpdateRepository.Contains("gitcode.com/2509_92447106/GC", StringComparison.OrdinalIgnoreCase))
// 暂时停用 GitCode:旧配置里的 GitCode 仓库地址统一迁到 Xhmcl。
if (Current.UpdateRepository.Contains("gitcode.com", StringComparison.OrdinalIgnoreCase))
{ {
Current.UpdateRepository = Current.UpdateRepository.Replace( Current.UpdateRepository = SourcePreset.Xhmcl.HomeUrl;
"2509_92447106", "Morris_1", StringComparison.OrdinalIgnoreCase);
Save(); Save();
} }
SeedDefaultSource(); SeedDefaultSource();
@@ -29,12 +30,11 @@ public sealed class SettingsService
} }
/// <summary> /// <summary>
/// 只允许两个内置源:Xhmcl 与 GitCode(同一份仓库的两个镜像)。 /// 当前只启用 Xhmcl 一个内置源。GitCode 的定义与下载实现保留在代码里,
/// 不再支持用户自定义源 —— 每次加载都把 Sources 规整成这两条, /// 但不再参与测速 / 下载 / 更新;恢复时把 GitCode 加回 <see cref="SourcePreset.All"/> 即可。
/// 老配置里的自定义源会被清理掉。
/// </summary> /// </summary>
public const string DefaultSourceId = "gitcode"; public const string DefaultSourceId = "xhmcl";
public const string DefaultSourceUrl = "https://gitcode.com/Morris_1/GC"; public const string DefaultSourceUrl = "https://git.xhmcl.com/Morris/GC";
private void SeedDefaultSource() private void SeedDefaultSource()
{ {
+16 -9
View File
@@ -5,10 +5,11 @@ using System.Linq;
namespace GC.Services; namespace GC.Services;
/// <summary> /// <summary>
/// 内置下载源。只允许这两个,不再支持用户自定义源。 /// 内置下载源。
/// ///
/// 两个源的内容是同一份仓库(同一个 version.json、同一批模型), /// 目前只启用 Xhmcl;GitCode 的 preset 与下载实现仍保留在代码中,
/// 区别只是**托管在哪台服务器**上;启动时探测两者延迟,取快的那个下载。 /// 但不参与测速 / 下载 / 更新。两个源本来指向同一份仓库内容,
/// 区别只是托管服务器;恢复双源时把 GitCode 加回 <see cref="All"/>。
/// </summary> /// </summary>
public sealed class SourcePreset public sealed class SourcePreset
{ {
@@ -63,17 +64,23 @@ public sealed class SourcePreset
Branch = "main" Branch = "main"
}; };
public static readonly SourcePreset[] All = { Xhmcl, GitCode }; /// <summary>
/// 当前启用的源:暂时只保留 Xhmcl。GitCode 的定义与实现仍保留在代码里,
/// 但不参与测速、下载与更新(需要恢复时把 GitCode 加回这个数组即可)。
/// </summary>
public static readonly SourcePreset[] All = { Xhmcl };
public static SourcePreset? Find(string? id) => public static SourcePreset? Find(string? id) =>
All.FirstOrDefault(p => string.Equals(p.Id, id, StringComparison.OrdinalIgnoreCase)); All.FirstOrDefault(p => string.Equals(p.Id, id, StringComparison.OrdinalIgnoreCase));
/// <summary>把任意仓库地址映射到这两个内置源之一(用于兼容旧配置)。</summary> /// <summary>把任意仓库地址映射到启用的内置源(用于兼容旧配置)。</summary>
public static SourcePreset Detect(string? url) public static SourcePreset Detect(string? url)
{ {
if (string.IsNullOrWhiteSpace(url)) return GitCode; if (!string.IsNullOrWhiteSpace(url) &&
var u = url!.ToLowerInvariant(); url!.Contains("xhmcl.com", StringComparison.OrdinalIgnoreCase))
if (u.Contains("xhmcl.com")) return Xhmcl; return Xhmcl;
return GitCode;
// 旧配置里的 GitCode 地址不再作为下载源,统一落到 Xhmcl。
return Xhmcl;
} }
} }
+11 -6
View File
@@ -193,7 +193,9 @@ internal static class Program
Console.WriteLine($"当前平台: {rid},启动器版本: {LauncherRuntimeInfo.CurrentLauncherVersion}"); Console.WriteLine($"当前平台: {rid},启动器版本: {LauncherRuntimeInfo.CurrentLauncherVersion}");
var stage = Path.Combine(tmp, "launcher-stage"); var stage = Path.Combine(tmp, "launcher-stage");
Directory.CreateDirectory(stage); Directory.CreateDirectory(stage);
File.WriteAllText(Path.Combine(stage, "GC-9.9.9-" + LauncherUpdater.PlatformLabel + ".exe"), // Linux 的启动器没有扩展名,测试包名要跟着平台走
var launcherExt = OperatingSystem.IsWindows() ? ".exe" : "";
File.WriteAllText(Path.Combine(stage, "GCL-9.9.9-" + LauncherUpdater.PlatformLabel + launcherExt),
"new launcher"); "new launcher");
var zip = Path.Combine(tmp, "GC-" + rid + ".zip"); var zip = Path.Combine(tmp, "GC-" + rid + ".zip");
ZipFile.CreateFromDirectory(stage, zip); ZipFile.CreateFromDirectory(stage, zip);
@@ -207,7 +209,7 @@ internal static class Program
WriteSigned(remoteManifest, rv, signer); WriteSigned(remoteManifest, rv, signer);
// 造一个旧版在当前目录 // 造一个旧版在当前目录
var oldName = "GC-1.0.0-" + LauncherUpdater.PlatformLabel + ".exe"; var oldName = "GC-1.0.0-" + LauncherUpdater.PlatformLabel + launcherExt;
File.WriteAllText(Path.Combine(paths.InstallDirectory, oldName), "old launcher"); File.WriteAllText(Path.Combine(paths.InstallDirectory, oldName), "old launcher");
var dl = Task.Run(() => LauncherUpdater.DownloadAsync(paths, updater.Remote, null)) var dl = Task.Run(() => LauncherUpdater.DownloadAsync(paths, updater.Remote, null))
@@ -227,7 +229,8 @@ internal static class Program
// 5) 校验标记文件与替换脚本(相对路径,无绝对路径) // 5) 校验标记文件与替换脚本(相对路径,无绝对路径)
var marker = Path.Combine(paths.UpdateRoot, "update.txt"); var marker = Path.Combine(paths.UpdateRoot, "update.txt");
Check(File.Exists(marker), "写出更新标记 update.txt"); Check(File.Exists(marker), "写出更新标记 update.txt");
var scheduled = LauncherUpdater.ScheduleApply(paths, dl.PackageName ?? ""); // 只验证脚本内容,不真的执行(否则脚本会在临时目录被删掉后搬文件、刷错误)
var scheduled = LauncherUpdater.ScheduleApply(paths, dl.PackageName ?? "", execute: false);
var scriptPath = Path.Combine(paths.UpdateRoot, var scriptPath = Path.Combine(paths.UpdateRoot,
OperatingSystem.IsWindows() ? "apply.bat" : "apply.sh"); OperatingSystem.IsWindows() ? "apply.bat" : "apply.sh");
Check(scheduled && File.Exists(scriptPath), "替换脚本可生成"); Check(scheduled && File.Exists(scriptPath), "替换脚本可生成");
@@ -235,14 +238,14 @@ internal static class Program
{ {
var script = File.ReadAllText(scriptPath); var script = File.ReadAllText(scriptPath);
Check(!script.Contains(tmp), "脚本不含绝对路径"); Check(!script.Contains(tmp), "脚本不含绝对路径");
Check(script.Contains("GC-*.app") || script.Contains("GC-*"), "脚本按 GC-* 匹配删除"); Check(script.Contains("GC-*") || script.Contains("GCL-*"), "脚本按 GC-*/GCL-* 匹配删除");
} }
// 5b) 只发产物、不发 Release:更新包只存在于仓库 dist/<系统>-<架构>/ 目录里。 // 5b) 只发产物、不发 Release:更新包只存在于仓库 dist/<系统>-<架构>/ 目录里。
// 清单不写 url、不写 path,只给 dir + name + sha256,客户端要能自己找过去。 // 清单不写 url、不写 path,只给 dir + name + sha256,客户端要能自己找过去。
var distDir = Path.Combine(remote, "dist", LauncherUpdater.PlatformLabel); var distDir = Path.Combine(remote, "dist", LauncherUpdater.PlatformLabel);
Directory.CreateDirectory(distDir); Directory.CreateDirectory(distDir);
var distName = "GC-9.9.10-" + LauncherUpdater.PlatformLabel + ".zip"; var distName = "GCL-9.9.10-" + LauncherUpdater.PlatformLabel + ".zip";
var distZip = Path.Combine(distDir, distName); var distZip = Path.Combine(distDir, distName);
File.Copy(zip, distZip, true); File.Copy(zip, distZip, true);
@@ -310,8 +313,10 @@ internal static class Program
/// <summary>序列化清单并用私钥签名(测试里模拟一次正式发布)。</summary> /// <summary>序列化清单并用私钥签名(测试里模拟一次正式发布)。</summary>
private static void WriteSigned(string path, RepoVersion version, ECDsa key) private static void WriteSigned(string path, RepoVersion version, ECDsa key)
{ {
// keyId 必须与 .signing/ 里的私钥对应的公钥条目一致,否则客户端按 keyId
// 查不到受信任公钥,会判成 Invalid 而不是 Verified。
var text = JsonSerializer.Serialize(version, Json.Options) + "\n"; var text = JsonSerializer.Serialize(version, Json.Options) + "\n";
File.WriteAllText(path, ManifestSignature.SignDocument(text, key, "gc-2026-11")); File.WriteAllText(path, ManifestSignature.SignDocument(text, key, "gc-2026-12"));
} }
private static void CopyTree(string src, string dst) private static void CopyTree(string src, string dst)
+49 -25
View File
@@ -11,8 +11,8 @@
- UI:C# + .NET 8(可切 .NET 10)+ Avalonia,跨平台 - UI:C# + .NET 8(可切 .NET 10)+ Avalonia,跨平台
- 模型加载:`AssemblyLoadContext` 加载模型自带 dll,契约与 Avalonia 走默认上下文,关窗即卸载 - 模型加载:`AssemblyLoadContext` 加载模型自带 dll,契约与 Avalonia 走默认上下文,关窗即卸载
- 目标平台:**macOS arm64 / Windows x64 / Windows arm64**(Linux 可自行编译,未列入发布矩阵) - 目标平台:**Windows x64 / Windows arm64 / macOS arm64 / Linux x64**
- 更新仓库:<https://gitcode.com/Morris_1/GC>,模型目录 <https://gitcode.com/Morris_1/GC/tree/main/model> - 更新仓库:<https://git.xhmcl.com/Morris/GC>,模型目录 <https://git.xhmcl.com/Morris/GC/src/branch/main/model>
## GC-UI:前后端分离版(Flutter 前端) ## GC-UI:前后端分离版(Flutter 前端)
@@ -59,16 +59,24 @@ Windows 用 `.\build.ps1`,参数相同(`build / check / models / stamp / run
## 运行目录(发布包里就长这样) ## 运行目录(发布包里就长这样)
``` ```
<安装目录>/ <解压出来的目录>/ ← 压缩包里只有这一个文件夹
GC.exe | GC.app/ GCL-<版本>-<平台>(.exe | .app/) 启动器
GC-SAVEDOG[.exe] 更新守护进程(与主程序同目录,macOS 在 .app/Contents/MacOS 内) GC-UI(.exe) Flutter 前端
.GC/ safedog/GC-SAVEDOG[.exe] 更新守护进程(运行时复制到 .GC/safedog)
config/settings.json 用户设置(与缓存分开:删 cache 不会丢配置) data/ lib/ *.dll 后端与 Flutter 运行时
model/ 启动时下载的模型 .GC/ 首次启动自动生成
cache/ 下载暂存 / 原子替换 config/settings.json 用户设置(与缓存分开:删 cache 不会丢配置)
update/ 待应用的启动器更新(apply-request.json + package.zip) model/ 启动时下载的模型
cache/ 下载暂存 / 原子替换
update/ 待应用的启动器更新(apply-request.json + package.zip)
safedog/GC-SAVEDOG[.exe] 实际运行的守护进程(不随整目录替换被覆盖)
logs/gc-YYYYMMDD.log 日志(中文)
logs/gc-YYYYMMDD.en.log 日志(English)
``` ```
压缩包内只有一个顶层目录,解压后不会散落一屏 dll;主程序、后端、前端、守护进程都在
这个目录里。`.GC` 紧挨着主程序,装在哪都便携 —— 整个目录复制走,模型、设置、日志跟着走。
**发布包不含任何模型**。首次启动联网检查后把模型下载到 `.GC/model/` 并立刻显示; **发布包不含任何模型**。首次启动联网检查后把模型下载到 `.GC/model/` 并立刻显示;
安装目录不可写时自动退回用户数据目录。`.GC/cache` 与 `.GC/model` 随时可删,程序会重新下载; 安装目录不可写时自动退回用户数据目录。`.GC/cache` 与 `.GC/model` 随时可删,程序会重新下载;
`.GC/config/settings.json` 删掉等于恢复出厂设置。 `.GC/config/settings.json` 删掉等于恢复出厂设置。
@@ -83,18 +91,22 @@ Windows 用 `.\build.ps1`,参数相同(`build / check / models / stamp / run
启动器更新的完整流程: 启动器更新的完整流程:
``` ```
启动器下载 zip -> 校验 sha256 -> 写 apply-request.json -> 启动 GC-SAVEDOG -> 自己退出 启动器下载 zip -> 校验 sha256 -> 写 apply-request.json -> 启动 .GC/safedog/GC-SAVEDOG -> 自己退出
GC-SAVEDOG: 二次验签 -> 检查 zip 安全性 -> 解压到 .GC/update/stage GC-SAVEDOG: 二次验签 -> 检查 zip 安全性 -> 解压到 .GC/update/stage
-> 移入安装目录(绝不覆盖已有版本) -> 整目录替换:旧文件搬到 .GC/update/backup,新文件就位(保留 .GC 不动)
-> 启动新版,等 .GC/update/health.json -> 启动新版,等 .GC/update/health.json
-> 收到:删同平台旧版本,写 last-good.json -> 收到:删备份、写 last-good.json
-> 没收到/进程退出:删新版、重启旧版,写 state.json = rolledback -> 没收到/进程退出:撤掉新文件、把备份搬回、重启旧版,写 state.json = rolledback
``` ```
发布包是**整目录**(启动器 + 后端运行时 + Flutter 前端资源),所以更新必须整目录替换:
只替换一个 exe 会留下旧后端 / 旧界面,新前端调不通接口。替换只动程序文件,
`.GC`(模型库、设置、日志、更新目录)和正在运行的 `GC-SAVEDOG.exe` 一律跳过。
也就是说:**新版本起不来,用户不会被卡死**。找不到 `GC-SAVEDOG` 的旧安装会退回脚本流程(过渡用)。 也就是说:**新版本起不来,用户不会被卡死**。找不到 `GC-SAVEDOG` 的旧安装会退回脚本流程(过渡用)。
- 默认更新仓库写在 `.GC/config/settings.json` 的 `updateRepository`: - 默认更新仓库写在 `.GC/config/settings.json` 的 `updateRepository`:
`https://gitcode.com/Morris_1/GC`(也可换成自己的仓库或 `.../tree/main/model` 地址) `https://git.xhmcl.com/Morris/GC`(也可换成自己的仓库或 `.../src/branch/main/model` 地址)
- 断网、仓库没推 `version.json`、下载失败:**一律保留本地模型,绝不清空模型库**,底部状态条说明原因 - 断网、仓库没推 `version.json`、下载失败:**一律保留本地模型,绝不清空模型库**,底部状态条说明原因
- 首次启动断网且本地无模型:状态条会明确提示「去下载页重试 / 手动放入 `.GC/model/`」,不会白屏干等 - 首次启动断网且本地无模型:状态条会明确提示「去下载页重试 / 手动放入 `.GC/model/`」,不会白屏干等
- 离线教室:把仓库(含 `version.json` + `model/`)拷到 U 盘,在 `settings.json` 填 - 离线教室:把仓库(含 `version.json` + `model/`)拷到 U 盘,在 `settings.json` 填
@@ -135,12 +147,23 @@ Windows 用 `.\build.ps1`,参数相同(`build / check / models / stamp / run
### 签名密钥 ### 签名密钥
- 私钥:`.signing/gc-signing.pem`(**已在 `.gitignore`,永不入库**;请自行备份) - 私钥:`.signing/gc-signing.pem`(**已在 `.gitignore`,永不入库**;请自行备份)
- 公钥:硬编码在 `GC/src/Security/SignatureKeyring.cs`,指纹 `b41b1dd6259ea9ed` - 公钥:硬编码在 `GC/src/Security/SignatureKeyring.cs`
- 生成新密钥:`dotnet run --project GC-SAVEDOG -- keygen` - 当前生效:`gc-2026-12`,指纹 `ee6083be47a87907`
- 轮换:把新公钥追加进 `SignatureKeyring.Keys`(保留旧公钥一个版本周期),再重新签名清单 - 已停用:`gc-2026-11`,指纹 `b41b1dd6259ea9ed`(私钥遗失,仅保留占位)
- 生成新密钥:`dotnet run --project GC-SAVEDOG -- keygen --key-id gc-YYYY-MM`
- 轮换:把新公钥追加进 `SignatureKeyring.Keys`(保留旧公钥一个版本周期),
同时把 `GC_SIGNING_KEY_ID`(默认值在 `buildsh/lib/build_funcs.sh`)改成新 keyId,
再重新签名清单
- 部署前核对两边公钥一致: - 部署前核对两边公钥一致:
`dotnet run --project GC-SAVEDOG -- verify --manifest version.json` `dotnet run --project GC-SAVEDOG -- verify --manifest version.json`
`build.sh` 在刷新清单后自动调用 `sign_manifest` 签名并同步 `model/version.json`;
`.signing/gc-signing.pem` 不存在时只告警,清单不带签名(客户端会拒绝更新)。
> 换钥匙的代价:老客户端只认识编译进去的那份公钥,所以**用新密钥签出的清单
> 在旧版本上会判成「签名无效」**。密钥一旦丢失,只能靠发一个新版本把新公钥带出去,
> 中间这段时间老客户端无法自动更新 —— 私钥务必备份两处以上。
### zip 解压加固 ### zip 解压加固
更新包和模型源 zip 一律当成不可信输入:拒绝 `../`、绝对路径、盘符、UNC、符号链接; 更新包和模型源 zip 一律当成不可信输入:拒绝 `../`、绝对路径、盘符、UNC、符号链接;
@@ -202,8 +225,8 @@ Repository/
| 方式 | 清单字段 | 说明 | | 方式 | 清单字段 | 说明 |
| --- | --- | --- | | --- | --- | --- |
| Release 附件(推荐) | `url` | `.../releases/download/v<版本>/GC-<版本>-<系统>-<架构>.zip` | | Release 附件(推荐) | `url` | `.../releases/download/<版本>/GCL-<版本>-<系统>-<架构>.zip` |
| 仓库编译产物 | `path` / `dir` / `name` | `dist/<系统>-<架构>/GC-<版本>-<系统>-<架构>.zip` | | 仓库编译产物 | `path` / `dir` / `name` | `dist/<系统>-<架构>/GCL-<版本>-<系统>-<架构>.zip` |
下载端按 `url` → `path` → `dist/<系统>-<架构>/` 目录扫描的顺序尝试, 下载端按 `url` → `path` → `dist/<系统>-<架构>/` 目录扫描的顺序尝试,
**每个候选都必须与清单里的 `sha256` 一致**(`sha256` 由签名保护), **每个候选都必须与清单里的 `sha256` 一致**(`sha256` 由签名保护),
@@ -229,15 +252,16 @@ Repository/
| 产物 | 平台 | | 产物 | 平台 |
| --- | --- | | --- | --- |
| `dist/mac-arm64/GC-<版本>-mac-arm64.zip` | macOS Apple Silicon 应用包(含 GC-SAVEDOG) | | `dist/mac-arm64/GCL-<版本>-mac-arm64.zip` | macOS Apple Silicon(单顶层 `GCL-….app`) |
| `dist/win-amd64/GC-<版本>-win-amd64.zip` | Windows x64 单文件启动器 + `GC-SAVEDOG.exe` | | `dist/win-amd64/GCL-<版本>-win-amd64.zip` | Windows x64(单顶层 `GCL-…/`,含 Flutter 前端与 `safedog/`) |
| `dist/win-arm64/GC-<版本>-win-arm64.zip` | Windows on ARM 同上 | | `dist/win-arm64/GCL-<版本>-win-arm64.zip` | Windows on ARM 同上 |
| `dist/linux-arm64/GCL-<版本>-linux-arm64.zip` | Linux ARM64 同上(启动器无扩展名;默认不构建,需 aarch64 主机 + `GC_BUILD_LINUX=1`) |
平台目录就是「该平台的编译产物目录」:打包完成后只留最终 zip(原始 `.app` / `.exe` 平台目录就是「该平台的编译产物目录」:打包完成后只留最终 zip(原始 `.app` / `.exe`
会被挪到 `build/trash/`,下次构建时移出,不做递归删除)。 会被挪到 `build/trash/`,下次构建时移出,不做递归删除)。
发新版:`./build.sh build -version=1.0.8` → 把 `dist/<平台>/GC-1.0.8-<平台>.zip` 发新版:`./build.sh build` → 把 `dist/<平台>/GCL-<版本>-<平台>.zip`
上传到 gitcode Release(tag `v1.0.8`),**或者**直接提交/上传到仓库的 上传到 Gitea Release(tag `v1.0.8`),**或者**直接提交/上传到仓库的
`dist/<平台>/` 目录 → 提交并推送 `version.json` / `model/version.json`。 `dist/<平台>/` 目录 → 提交并推送 `version.json` / `model/version.json`。
两种都能被客户端识别,客户端下次启动就会看到更新。 两种都能被客户端识别,客户端下次启动就会看到更新。
+3 -1
View File
@@ -3,6 +3,7 @@
# GC 构建入口(薄封装) # GC 构建入口(薄封装)
# #
# ./build.sh build 完整发布(原 publish),带 apt 风格进度条 # ./build.sh build 完整发布(原 publish),带 apt 风格进度条
# 默认要求每个平台都带 Flutter 前端;--allow-no-ui 允许降级
# ./build.sh check 验证:编译 + 自检 + 离屏渲染 + 产物 # ./build.sh check 验证:编译 + 自检 + 离屏渲染 + 产物
# ./build.sh models 编译模型 dll + 封面 + 版本戳 # ./build.sh models 编译模型 dll + 封面 + 版本戳
# ./build.sh stamp 重新生成 version.json # ./build.sh stamp 重新生成 version.json
@@ -33,11 +34,12 @@ VERSION=$(sed -n 's/.*<Version>\(.*\)<\/Version>.*/\1/p' Directory.Build.props |
TASK="${1:-build}" TASK="${1:-build}"
shift 2>/dev/null || true shift 2>/dev/null || true
# 解析 -version=<版本号>(也接受 --version=) # 解析 -version=<版本号>(也接受 --version=)与 --allow-no-ui
CLI_VERSION="" CLI_VERSION=""
for arg in "$@"; do for arg in "$@"; do
case "$arg" in case "$arg" in
-version=*|--version=*) CLI_VERSION="${arg#*=}" ;; -version=*|--version=*) CLI_VERSION="${arg#*=}" ;;
-allow-no-ui|--allow-no-ui) export GC_ALLOW_NO_UI=1 ;;
esac esac
done done
if [ -n "$CLI_VERSION" ]; then if [ -n "$CLI_VERSION" ]; then
+3 -3
View File
@@ -275,7 +275,7 @@ function New-MacAppBundle {
<plist version="1.0"><dict> <plist version="1.0"><dict>
<key>CFBundleName</key><string>GC</string> <key>CFBundleName</key><string>GC</string>
<key>CFBundleDisplayName</key><string>GC</string> <key>CFBundleDisplayName</key><string>GC</string>
<key>CFBundleIdentifier</key><string>cn.neorf.GC</string> <key>CFBundleIdentifier</key><string>com.xhmcl.GC</string>
<key>CFBundleVersion</key><string>$script:BuildVersion</string> <key>CFBundleVersion</key><string>$script:BuildVersion</string>
<key>CFBundleShortVersionString</key><string>$script:BuildVersion</string> <key>CFBundleShortVersionString</key><string>$script:BuildVersion</string>
<key>CFBundlePackageType</key><string>APPL</string> <key>CFBundlePackageType</key><string>APPL</string>
@@ -324,8 +324,8 @@ function Invoke-FullBuild {
Start-BuildStep '版本戳'; Invoke-VersionStamp; Complete-BuildStep Start-BuildStep '版本戳'; Invoke-VersionStamp; Complete-BuildStep
Start-BuildStep '编译 Mac'; Publish-Rid 'osx-arm64' 'dist/mac-arm64' $false; Complete-BuildStep Start-BuildStep '编译 Mac'; Publish-Rid 'osx-arm64' 'dist/mac-arm64' $false; Complete-BuildStep
Start-BuildStep '编译 Win-x64'; Publish-Rid 'win-x64' 'dist/win-amd64' $true; Complete-BuildStep Start-BuildStep '编译 Win-x64'; Publish-Rid 'win-x64' 'dist/win-amd64' $false; Complete-BuildStep
Start-BuildStep '编译 Win-arm64'; Publish-Rid 'win-arm64' 'dist/win-arm64' $true; Complete-BuildStep Start-BuildStep '编译 Win-arm64'; Publish-Rid 'win-arm64' 'dist/win-arm64' $false; Complete-BuildStep
Start-BuildStep '运行骨架' Start-BuildStep '运行骨架'
New-MacAppBundle New-MacAppBundle
+105 -10
View File
@@ -1,13 +1,66 @@
#!/bin/sh #!/bin/sh
# buildsh/build.sh —— 完整发布(原 publish) # buildsh/build.sh —— 完整发布(原 publish)
# 步骤及权重按实测耗时设定,供进度条估算总进度与剩余时间: #
# 清理(2) 版本(3) Mac(35) WinX64(25) WinArm(25) 骨架(3) 打包(5) 收尾(2) = 100 # 目标平台按构建主机决定,每条产物都带 Flutter 前端:
# macOS 主机 : mac-arm64(原生)+ win-amd64 / win-arm64(mingw 交叉)
# Linux 主机 : win-amd64 / win-arm64(mingw 交叉)
# Linux 产物默认不构建:目标为 linux-arm64,官方 Flutter 引擎只有
# x64 产物,必须在 aarch64 主机上编。需要时用 GC_BUILD_LINUX=1 显式开启
# (云端 aarch64 runner 就是这么用的)。
# Windows 主机: win-amd64 / win-arm64(原生)
#
# 前端是默认必需项:flutter 缺失或编译失败一律中断,不再悄悄产出只带 Avalonia
# 回退界面的包。确实要降级时用 ./build.sh build --allow-no-ui。
#
# 进度权重按实测耗时设定,供进度条估算总进度与剩余时间。
bs_build() { bs_build() {
ROOT_DIR="$1" ROOT_DIR="$1"
: "${APP_PROJ:?}" "${SLN:?}" "${VERSION:?}" : "${APP_PROJ:?}" "${SLN:?}" "${VERSION:?}"
progress_init 100 2 3 35 25 25 3 5 2 HOST=$(uname -s)
BUILD_MAC=0
BUILD_LINUX=0
case "$HOST" in
Darwin) BUILD_MAC=1 ;;
MINGW*|MSYS*|CYGWIN*) : ;; # Windows 主机只能编 Windows
*) BUILD_LINUX=1 ;;
esac
# Linux 产物默认不出:目标平台是 linux-arm64,而官方 Flutter 引擎只发 x64 产物,
# x64 主机上编出来的是 x64 二进制,装到 arm 机器上跑不起来。
# 需要时显式开启(云端 aarch64 runner):GC_BUILD_LINUX=1 ./build.sh build
if [ "$BUILD_LINUX" = 1 ]; then
case "${GC_BUILD_LINUX:-0}" in
1|true|yes)
case "$(uname -m)" in
aarch64|arm64) ;;
*)
BUILD_LINUX=0
echo "!! 已请求 Linux 产物,但当前主机是 $(uname -m)"
echo " (linux-arm64 需要有 aarch64 主机,Flutter 引擎只有 x64 官方产物)"
;;
esac
;;
*)
BUILD_LINUX=0
echo "==> 跳过 Linux 产物(默认不构建;需要时用 GC_BUILD_LINUX=1 显式开启)"
;;
esac
fi
# 显式降级:允许在没有该平台 Flutter 宿主的情况下仍出 Avalonia 版包
ALLOW_NO_UI="${GC_ALLOW_NO_UI:-0}"
# 权重:清理 版本 Mac WinX64 WinArm64 Linux 前端 骨架 打包 收尾
WEIGHTS="2 3"
[ "$BUILD_MAC" = 1 ] && WEIGHTS="$WEIGHTS 35"
WEIGHTS="$WEIGHTS 25 25"
[ "$BUILD_LINUX" = 1 ] && WEIGHTS="$WEIGHTS 30"
WEIGHTS="$WEIGHTS 25 3 5 2"
TOTAL=0
for _w in $WEIGHTS; do TOTAL=$((TOTAL + _w)); done
progress_init "$TOTAL" $WEIGHTS
progress_step "清理旧产物"; progress_tick 100 progress_step "清理旧产物"; progress_tick 100
rm -rf "$ROOT_DIR/dist"; mkdir -p "$ROOT_DIR/dist" rm -rf "$ROOT_DIR/dist"; mkdir -p "$ROOT_DIR/dist"
@@ -37,20 +90,62 @@ bs_build() {
progress_tick 100 progress_tick 100
} }
progress_step "编译 Mac" if [ "$BUILD_MAC" = 1 ]; then
_run_publish mac 90 publish_rid "osx-arm64" "dist/mac-arm64" false || return 1 progress_step "编译 Mac"
_run_publish mac 90 publish_rid "osx-arm64" "dist/mac-arm64" false || return 1
publish_backend "osx-arm64" "dist/mac-arm64" || return 1
# Flutter 的 macOS 产物必须用 Xcode 在本机编,Linux 上无法替代
build_flutter_ui macos "dist/mac-arm64" || {
echo "!! macOS 前端编译失败。macOS 版 Flutter 只能在 macOS 上编。"
return 1
}
elif [ "$ALLOW_NO_UI" = 1 ]; then
progress_step "编译 Mac"
_run_publish mac 90 publish_rid "osx-arm64" "dist/mac-arm64" false || return 1
publish_backend "osx-arm64" "dist/mac-arm64" || return 1
echo "!! --allow-no-ui:macOS 包内不含 Flutter 前端,启动器将回退 Avalonia"
fi
progress_step "编译 Win-x64" progress_step "编译 Win-x64"
_run_publish winx64 70 publish_rid "win-x64" "dist/win-amd64" true || return 1 _run_publish winx64 70 publish_rid "win-x64" "dist/win-amd64" false || return 1
publish_backend "win-x64" "dist/win-amd64" || return 1
progress_step "编译 Win-arm64" progress_step "编译 Win-arm64"
_run_publish winarm 70 publish_rid "win-arm64" "dist/win-arm64" true || return 1 _run_publish winarm 70 publish_rid "win-arm64" "dist/win-arm64" false || return 1
publish_backend "win-arm64" "dist/win-arm64" || return 1
if [ "$BUILD_LINUX" = 1 ]; then
progress_step "编译 Linux"
_run_publish linux 70 publish_rid "linux-arm64" "dist/linux-arm64" false || return 1
publish_backend "linux-arm64" "dist/linux-arm64" || return 1
build_flutter_ui linux "dist/linux-arm64" || return 1
fi
# Windows 前端:Windows 主机走官方 toolchain;Linux/macOS 主机用 mingw-w64 +
# wine 交叉编译(buildsh/cross)。只产出 x64 一份,两个包共用,
# ARM64 上由系统模拟 x64 进程运行前端。
progress_step "编译 Win 前端"
case "$HOST" in
MINGW*|MSYS*|CYGWIN*) build_flutter_ui windows "dist/win-flutter" || return 1 ;;
*) build_flutter_ui_cross "dist/win-flutter" || return 1 ;;
esac
for label in win-amd64 win-arm64; do
cp -R "$ROOT_DIR/dist/win-flutter/." "$ROOT_DIR/dist/$label/"
done
rm -rf "$ROOT_DIR/dist/win-flutter"
progress_step "运行骨架"; progress_tick 100 progress_step "运行骨架"; progress_tick 100
package_mac_app if [ -d "$ROOT_DIR/dist/mac-arm64" ]; then
package_mac_app
fi
prepare_runtime_layout "dist/win-amd64" prepare_runtime_layout "dist/win-amd64"
prepare_runtime_layout "dist/win-arm64" prepare_runtime_layout "dist/win-arm64"
prepare_runtime_layout "dist/mac-arm64/GC.app/Contents/MacOS" if [ "$BUILD_LINUX" = 1 ]; then
prepare_runtime_layout "dist/linux-arm64"
fi
if [ -d "$ROOT_DIR/dist/mac-arm64/GC.app/Contents/MacOS" ]; then
prepare_runtime_layout "dist/mac-arm64/GC.app/Contents/MacOS"
fi
progress_step "打包 zip"; progress_tick 100 progress_step "打包 zip"; progress_tick 100
pack_launcher pack_launcher
@@ -58,5 +153,5 @@ bs_build() {
progress_step "收尾"; progress_tick 100 progress_step "收尾"; progress_tick 100
progress_done progress_done
echo "==> 完成,产物:" echo "==> 完成,产物:"
ls -lh "$ROOT_DIR"/dist/*/GC-"$VERSION"-*.zip 2>/dev/null || true ls -lh "$ROOT_DIR"/dist/*/GCL-"$VERSION"-*.zip 2>/dev/null || true
} }
+108
View File
@@ -0,0 +1,108 @@
cmake_minimum_required(VERSION 3.14)
# 交叉编译 Flutter Windows 桌面外壳。
#
# 只编译 C++ 层:runner(Win32 窗口)+ cpp_client_wrapper(Dart 互操作)。
# Dart 侧的 flutter_assets 由 flutter assemble 单独产出,最后与
# flutter_windows.dll 一起摆进同一个目录就是完整的可运行包。
#
# 与 windows/CMakeLists.txt 的区别:不调用 tool_backend.bat(它在非 Windows
# 上不可执行),也不依赖 Visual Studio 生成器。
project(gc_ui_cross LANGUAGES CXX RC)
get_filename_component(APP_DIR "${CMAKE_CURRENT_LIST_DIR}/../../GC-UI/frontend" ABSOLUTE)
set(WIN_DIR "${APP_DIR}/windows")
set(RUN_DIR "${WIN_DIR}/runner")
set(EPHEMERAL "${WIN_DIR}/flutter/ephemeral")
set(WRAPPER "${EPHEMERAL}/cpp_client_wrapper")
set(DLL_LIB "${EPHEMERAL}/flutter_windows.dll.lib")
foreach(required
"${EPHEMERAL}/flutter_windows.dll"
"${DLL_LIB}"
"${WRAPPER}/core_implementations.cc")
if(NOT EXISTS "${required}")
message(FATAL_ERROR
"缺少 Flutter Windows 引擎产物:${required}\n"
"先运行 buildsh/cross/build-ui-win-cross.sh 里的 fetch_engine 步骤。")
endif()
endforeach()
set(FLUTTER_VERSION "1.0.0" CACHE STRING "写入 exe 版本资源")
# windres 在非 Windows 主机上不按 rc 文件所在目录解析图标路径,
# 这里把 resources\\app_icon.ico 换成绝对路径再交给 windres。
# 注意只替换这一处:rc 里其它 "\0" 是字符串转义,不能动。
file(READ "${RUN_DIR}/Runner.rc" _rc_text)
string(REPLACE "resources\\\\app_icon.ico" "${RUN_DIR}/resources/app_icon.ico" _rc_text "${_rc_text}")
# windres 收到 -DFLUTTER_VERSION=\"1.0.0\" 时会把反斜杠留在宏值里,展开成非法 token。
# 直接把宏定义成字面量,绕开命令行转义。
string(REPLACE "#define VERSION_AS_STRING FLUTTER_VERSION"
"#define VERSION_AS_STRING \"${FLUTTER_VERSION}\""
_rc_text "${_rc_text}")
file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/Runner.cross.rc" "${_rc_text}")
add_executable(${BINARY_NAME} WIN32
"${RUN_DIR}/main.cpp"
"${RUN_DIR}/flutter_window.cpp"
"${RUN_DIR}/utils.cpp"
"${RUN_DIR}/win32_window.cpp"
"${WIN_DIR}/flutter/generated_plugin_registrant.cc"
"${WRAPPER}/core_implementations.cc"
"${WRAPPER}/standard_codec.cc"
"${WRAPPER}/plugin_registrar.cc"
"${WRAPPER}/flutter_engine.cc"
"${WRAPPER}/flutter_view_controller.cc"
"${CMAKE_CURRENT_BINARY_DIR}/Runner.cross.rc"
)
target_include_directories(${BINARY_NAME} PRIVATE
"${RUN_DIR}"
"${WIN_DIR}"
"${EPHEMERAL}"
"${EPHEMERAL}/include"
"${WRAPPER}/include"
)
target_compile_features(${BINARY_NAME} PRIVATE cxx_std_17)
# Flutter 的 C++ wrapper 需要 RTTI 与异常;线程安全相关的锁依赖 posix 线程模型。
target_compile_options(${BINARY_NAME} PRIVATE
-fexceptions
-frtti
-Wall
-Wno-unused-parameter
-Wno-missing-field-initializers
)
# Runner.rc 里的 #include "resource.h" / runner.exe.manifest 都是相对路径,
# windres 不按源文件目录解析,必须显式给 -I。
set_source_files_properties("${RUN_DIR}/Runner.rc" PROPERTIES
COMPILE_FLAGS "-I\"${RUN_DIR}\"")
target_compile_definitions(${BINARY_NAME} PRIVATE
"FLUTTER_VERSION=\"${FLUTTER_VERSION}\""
"FLUTTER_VERSION_MAJOR=${FLUTTER_VERSION_MAJOR}"
"FLUTTER_VERSION_MINOR=${FLUTTER_VERSION_MINOR}"
"FLUTTER_VERSION_PATCH=${FLUTTER_VERSION_PATCH}"
"FLUTTER_VERSION_BUILD=${FLUTTER_VERSION_BUILD}"
"NOMINMAX"
)
target_link_libraries(${BINARY_NAME} PRIVATE
"${DLL_LIB}"
dwmapi
ole32
uuid
)
# runner 的入口是 wWinMain(宽字符版);MSVC 自动处理,mingw 需要 -municode
# 才会链接 wWinMainCRTStartup,否则报 undefined reference to `WinMain'。
target_link_options(${BINARY_NAME} PRIVATE -municode)
set_target_properties(${BINARY_NAME} PROPERTIES
OUTPUT_NAME "GC-UI"
SUFFIX ".exe"
)
+221
View File
@@ -0,0 +1,221 @@
#!/usr/bin/env bash
#
# 在 Linux / macOS 上交叉编译 Flutter Windows 桌面界面(GC-UI)。
#
# ./buildsh/cross/build-ui-win-cross.sh [输出目录]
#
# 产物目录是可直接拷到 Windows 上运行的一整套:
# GC-UI.exe flutter_windows.dll data/{icudtl.dat,app.so,flutter_assets/}
#
# 原理:
# Flutter 的 Windows 外壳(runner + cpp_client_wrapper)是纯 Win32 + 标准 C++,
# 只通过 C ABI 调 flutter_windows.dll,所以 mingw-w64 就能编译。
# 唯一的 Windows 专属步骤是 AOT 快照生成(gen_snapshot.exe 是 PE 文件),
# 用 wine 执行即可,全流程不需要 Windows 机器或 MSVC。
#
# 依赖:
# Linux sudo apt install mingw-w64 cmake ninja-build wine unzip curl
# macOS brew install mingw-w64 cmake ninja && brew install --cask wine-stable
#
# 环境变量:
# FLUTTER_BIN flutter 可执行文件(默认 PATH 中的 flutter,要求 3.24+)
# WIN_ENGINE_MIRROR 引擎产物来源(默认官方 GCS,国内可换 storage.flutter-io.cn)
#
set -euo pipefail
ROOT_DIR=$(cd "$(dirname "$0")/../.." && pwd)
UI_DIR="$ROOT_DIR/GC-UI/frontend"
OUT_DIR="${1:-$UI_DIR/build/windows/x64/runner/Release}"
BUILD_DIR="$UI_DIR/build/windows/x64/cross"
say() { printf '\033[36m==>\033[0m %s\n' "$*"; }
warn() { printf '\033[33m!!\033[0m %s\n' "$*"; }
die() { printf '\033[31mxx\033[0m %s\n' "$*" >&2; exit 1; }
need() { command -v "$1" >/dev/null 2>&1 || die "缺少 $1($2)"; }
# ---------------------------------------------------------------- 工具链
MINGW_CXX=""
check_toolchain() {
need cmake "Linux: apt install cmake;macOS: brew install cmake"
need ninja "Linux: apt install ninja-build;macOS: brew install ninja"
need unzip "Linux: apt install unzip"
need curl "Linux: apt install curl"
for c in x86_64-w64-mingw32-g++-posix x86_64-w64-mingw32-g++; do
if command -v "$c" >/dev/null 2>&1; then MINGW_CXX="$c"; break; fi
done
[ -n "$MINGW_CXX" ] || die "缺少 mingw-w64 C++ 编译器
Linux: sudo apt install g++-mingw-w64-x86-64-posix
macOS: brew install mingw-w64"
command -v x86_64-w64-mingw32-windres >/dev/null 2>&1 || die "缺少 mingw-w64 资源编译器"
# gen_snapshot.exe 靠 wine 执行;没有 wine 就只能出 debug 版(JIT)
if command -v wine >/dev/null 2>&1 || command -v wine64 >/dev/null 2>&1; then
WINE_BIN=$(command -v wine 2>/dev/null || command -v wine64)
else
die "缺少 wine(AOT 快照需要执行 Windows 版 gen_snapshot.exe)
Linux: sudo apt install wine
macOS: brew install --cask wine-stable"
fi
}
# ---------------------------------------------------------------- Flutter
resolve_flutter() {
FLUTTER_BIN="${FLUTTER_BIN:-flutter}"
command -v "$FLUTTER_BIN" >/dev/null 2>&1 || die "未找到 flutter,可设置 FLUTTER_BIN=/path/to/flutter"
local bin_path root target
bin_path=$(command -v "$FLUTTER_BIN")
while [ -L "$bin_path" ]; do
target=$(readlink "$bin_path")
case "$target" in
/*) bin_path="$target" ;;
*) bin_path="$(cd "$(dirname "$bin_path")" && pwd)/$target" ;;
esac
done
root=$(cd "$(dirname "$bin_path")/.." && pwd)
[ -f "$root/bin/internal/engine.version" ] || die "$root 不像 Flutter SDK 根目录"
FLUTTER_ROOT="$root"
ENGINE_DIR="$root/bin/cache/artifacts/engine"
ENGINE_HASH=$(tr -d '[:space:]' < "$root/bin/internal/engine.version")
# pubspec 要求 Dart 3.5+(Flutter 3.24+),版本不对直接提醒
local dart_ver
dart_ver=$("$root/bin/cache/dart-sdk/bin/dart" --version 2>/dev/null | grep -oE '[0-9]+\.[0-9]+\.[0-9]+' | head -1) || dart_ver=""
say "Flutter SDK: $root(engine ${ENGINE_HASH:0:10}${dart_ver:+, dart $dart_ver})"
}
# ---------------------------------------------------------------- 引擎产物
ENGINE_DIR="" # 由 resolve_flutter 填充
fetch_engine() {
local base="$MIRROR/flutter/$ENGINE_HASH"
local cache="${TMPDIR:-/tmp}/gc-win-engine"
mkdir -p "$cache"
# 每个条目:远端相对路径 | 落地目录 | 落地后的标志文件
local -a items=(
"windows-x64-release/windows-x64-flutter.zip|$ENGINE_DIR/windows-x64-release|flutter_windows.dll.lib"
"windows-x64/artifacts.zip|$ENGINE_DIR/windows-x64|frontend_server_aot.dart.snapshot"
"windows-x64/flutter-cpp-client-wrapper.zip|$ENGINE_DIR/windows-x64/cpp_client_wrapper|core_implementations.cc"
)
local item remote dest marker zip
for item in "${items[@]}"; do
IFS='|' read -r remote dest marker <<<"$item"
[ -f "$dest/$marker" ] && continue
zip="$cache/$(echo "$remote" | tr '/' '_')"
if [ ! -s "$zip" ]; then
say "下载 $(basename "$remote")"
curl -fL --retry 3 --retry-delay 2 -o "$zip.part" "$base/$remote" \
|| die "下载失败:$base/$remote
可设置 WIN_ENGINE_MIRROR=https://storage.flutter-io.cn/flutter_infra_release 走国内镜像"
mv "$zip.part" "$zip"
fi
mkdir -p "$dest"
unzip -oq "$zip" -d "$dest"
done
install_gen_snapshot_shim
}
# flutter_tools 会直接 exec $ENGINE_DIR/*/gen_snapshot(无 .exe 后缀)。
# 这里放一个调用 wine 的同名脚本,并给原本的 exe 加上 .win 后缀避免混淆。
install_gen_snapshot_shim() {
local dirs=("$ENGINE_DIR/windows-x64-release" "$ENGINE_DIR/windows-x64")
local dir shim
for dir in "${dirs[@]}"; do
[ -f "$dir/gen_snapshot.exe" ] || continue
[ -f "$dir/gen_snapshot.exe.win" ] || mv "$dir/gen_snapshot.exe" "$dir/gen_snapshot.exe.win"
shim="$dir/gen_snapshot"
cat > "$shim" <<EOF
#!/bin/sh
# 由 buildsh/cross/build-ui-win-cross.sh 生成:用 wine 执行 Windows 版 gen_snapshot。
export WINEPREFIX="\${WINEPREFIX:-\$HOME/.wine64}"
export WINEDEBUG=-all
exec "$WINE_BIN" "$dir/gen_snapshot.exe.win" "\$@"
EOF
chmod +x "$shim"
done
}
# ---------------------------------------------------------------- 构建
build_assets_and_aot() {
say "生成 Dart 资源与 AOT 快照"
( cd "$UI_DIR" && "$FLUTTER_BIN" --no-version-check --suppress-analytics pub get >/dev/null )
local dart="$FLUTTER_ROOT/bin/cache/dart-sdk/bin/dart"
local tool="$FLUTTER_ROOT/packages/flutter_tools/bin/tool_backend.dart"
# tool_backend 是官方 CMake 调用的同一入口:解包引擎产物到 ephemeral、
# 生成 flutter_assets、aot_elf_release。它末尾的收尾步骤在非 Windows host
# 上可能非零退出,所以只校验产物是否齐备。
( cd "$UI_DIR" && \
FLUTTER_ROOT="$FLUTTER_ROOT" \
PROJECT_DIR="$UI_DIR" \
FLUTTER_STORAGE_BASE_URL="${FLUTTER_STORAGE_BASE_URL:-$MIRROR}" \
"$dart" "$tool" windows-x64 release ) || true
[ -f "$UI_DIR/build/windows/app.so" ] || die "AOT 快照未生成(wine 执行 gen_snapshot 失败?)"
[ -d "$UI_DIR/build/flutter_assets" ] || die "flutter_assets 未生成"
say "AOT 快照 $(du -h "$UI_DIR/build/windows/app.so" | cut -f1),资源 $(du -sh "$UI_DIR/build/flutter_assets" | cut -f1)"
}
build_cpp() {
local ver major minor patch build_no
read -r major minor patch build_no <<<"$(sed -n 's/^version:[[:space:]]*//p' "$UI_DIR/pubspec.yaml" \
| head -1 | awk -F'[.+]' '{print $1+0, $2+0, $3+0, ($4==""?0:$4+0)}')"
ver="${major}.${minor}.${patch}"
say "编译 C++ 外壳($(basename "$MINGW_CXX"))"
cmake -S "$ROOT_DIR/buildsh/cross" -B "$BUILD_DIR" -G Ninja \
-DCMAKE_TOOLCHAIN_FILE="$ROOT_DIR/buildsh/cross/toolchain-mingw.cmake" \
-DCMAKE_BUILD_TYPE=Release \
-DBINARY_NAME=GC-UI \
-DFLUTTER_VERSION="$ver" \
-DFLUTTER_VERSION_MAJOR="$major" \
-DFLUTTER_VERSION_MINOR="$minor" \
-DFLUTTER_VERSION_PATCH="$patch" \
-DFLUTTER_VERSION_BUILD="$build_no" >/dev/null
cmake --build "$BUILD_DIR" -- -j "$(getconf _NPROCESSORS_ONLN 2>/dev/null || echo 4)" \
|| die "C++ 编译失败"
[ -f "$BUILD_DIR/GC-UI.exe" ] || die "未产出 GC-UI.exe"
}
stage() {
local eph="$UI_DIR/windows/flutter/ephemeral"
say "组装到 $OUT_DIR"
rm -rf "$OUT_DIR"
mkdir -p "$OUT_DIR/data"
cp "$BUILD_DIR/GC-UI.exe" "$OUT_DIR/"
cp "$eph/flutter_windows.dll" "$OUT_DIR/"
cp "$eph/icudtl.dat" "$OUT_DIR/data/"
cp "$UI_DIR/build/windows/app.so" "$OUT_DIR/data/"
cp -R "$UI_DIR/build/flutter_assets/." "$OUT_DIR/data/flutter_assets/"
say "完成:$(du -sh "$OUT_DIR" | cut -f1)"
find "$OUT_DIR" -maxdepth 2 -mindepth 1 | sed "s|$OUT_DIR| .|"
}
# ---------------------------------------------------------------- main
MIRROR="${WIN_ENGINE_MIRROR:-https://storage.googleapis.com/flutter_infra_release}"
check_toolchain
resolve_flutter
fetch_engine
build_assets_and_aot
build_cpp
stage
+36
View File
@@ -0,0 +1,36 @@
# 在 Linux / macOS 上交叉编译 Flutter Windows 桌面应用的 CMake 工具链。
#
# 原理:Flutter 的 Windows 嵌入层(windows/runner/*.cpp + cpp_client_wrapper)
# 是纯 Win32 + 标准 C++,只通过 C ABI 调用 flutter_windows.dll。因此用
# mingw-w64(GCC,posix 线程模型)即可产出与官方 toolchain 等价的 PE 产物,
# 不需要 Windows 机器,也不需要 MSVC。
#
# 用法:
# cmake -B build -G Ninja -DCMAKE_TOOLCHAIN_FILE=.../toolchain-mingw.cmake ...
set(CMAKE_SYSTEM_NAME Windows)
set(CMAKE_SYSTEM_VERSION 10.0)
set(CMAKE_SYSTEM_PROCESSOR x86_64)
set(MINGW_PREFIX "x86_64-w64-mingw32" CACHE STRING "目标三元组前缀")
# 必须用 posix 线程模型:Flutter 的 C++ wrapper 依赖 std::mutex / std::thread,
# win32 线程模型下的 libstdc++ 不提供这些类型。
find_program(MINGW_C NAMES ${MINGW_PREFIX}-gcc-posix ${MINGW_PREFIX}-gcc REQUIRED)
find_program(MINGW_CXX NAMES ${MINGW_PREFIX}-g++-posix ${MINGW_PREFIX}-g++ REQUIRED)
find_program(MINGW_RC NAMES ${MINGW_PREFIX}-windres REQUIRED)
set(CMAKE_C_COMPILER "${MINGW_C}")
set(CMAKE_CXX_COMPILER "${MINGW_CXX}")
set(CMAKE_RC_COMPILER "${MINGW_RC}")
set(CMAKE_FIND_ROOT_PATH "/usr/${MINGW_PREFIX}")
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
# 静态链接 libgcc / libstdc++ / winpthread,产物只依赖 flutter_windows.dll
# 和系统 DLL,拷到干净机器上也能跑。
set(CMAKE_CXX_FLAGS_INIT "-DUNICODE -D_UNICODE -DNOMINMAX -D_HAS_EXCEPTIONS=1")
set(CMAKE_EXE_LINKER_FLAGS_INIT "-static -static-libgcc -static-libstdc++")
+178 -28
View File
@@ -24,7 +24,7 @@ stamp_launcher_only() {
# 没有私钥时只警告:清单不带 signature,客户端会按「未签名」处理。 # 没有私钥时只警告:清单不带 signature,客户端会按「未签名」处理。
sign_manifest() { sign_manifest() {
KEY="$ROOT_DIR/.signing/gc-signing.pem" KEY="$ROOT_DIR/.signing/gc-signing.pem"
KEYID="${GC_SIGNING_KEY_ID:-gc-2026-11}" KEYID="${GC_SIGNING_KEY_ID:-gc-2026-12}"
if [ ! -f "$KEY" ]; then if [ ! -f "$KEY" ]; then
echo "!! 未找到签名私钥 ${KEY},本次 version.json 未签名(客户端会拒绝更新)" echo "!! 未找到签名私钥 ${KEY},本次 version.json 未签名(客户端会拒绝更新)"
echo " 生成密钥:dotnet run --project GC-SAVEDOG -- keygen" echo " 生成密钥:dotnet run --project GC-SAVEDOG -- keygen"
@@ -94,7 +94,7 @@ TXT
"memoryMb": 2048, "memoryMb": 2048,
"autoUpdateOnStartup": true, "autoUpdateOnStartup": true,
"requireSignedManifest": true, "requireSignedManifest": true,
"updateRepository": "https://gitcode.com/Morris_1/GC", "updateRepository": "https://git.xhmcl.com/Morris/GC",
"updateManifestUrl": "", "updateManifestUrl": "",
"updateLocalRoot": "", "updateLocalRoot": "",
"installedModelVersions": {}, "installedModelVersions": {},
@@ -164,9 +164,10 @@ pack_models() {
# 启动器更新包:只包含程序文件,排除 .GC(否则会覆盖用户已下载的模型与设置) # 启动器更新包:只包含程序文件,排除 .GC(否则会覆盖用户已下载的模型与设置)
# #
# 产物落点遵循「仓库 dist/<系统>-<架构>/」布局: # 产物落点遵循「仓库 dist/<系统>-<架构>/」布局:
# dist/mac-arm64/GC-<版本>-mac-arm64.zip # dist/mac-arm64/GCL-<版本>-mac-arm64.zip
# dist/win-amd64/GC-<版本>-win-amd64.zip # dist/win-amd64/GCL-<版本>-win-amd64.zip
# dist/win-arm64/GC-<版本>-win-arm64.zip # dist/win-arm64/GCL-<版本>-win-arm64.zip
# dist/linux-arm64/GCL-<版本>-linux-arm64.zip
# 启动器更新时既可以从 Release 附件下载,也会到这些目录里找编译产物 # 启动器更新时既可以从 Release 附件下载,也会到这些目录里找编译产物
# (见 GC-DOWNLOAD/LauncherArtifacts.cs),所以两种发布方式都能用。 # (见 GC-DOWNLOAD/LauncherArtifacts.cs),所以两种发布方式都能用。
# #
@@ -174,40 +175,189 @@ pack_models() {
# macOS: .app 必须打成 zip 才能作为单文件分发;文件名用 .app.zip, # macOS: .app 必须打成 zip 才能作为单文件分发;文件名用 .app.zip,
# 这样 macOS 双击会用归档工具解压出可运行的 .app。 # 这样 macOS 双击会用归档工具解压出可运行的 .app。
# 若直接命名 .app,系统会把 zip 当成应用包解析 => 报「已损坏/打不开」。 # 若直接命名 .app,系统会把 zip 当成应用包解析 => 报「已损坏/打不开」。
pack_launcher() { # 发布本地 UI 后端(GC.UI.Server)。启动器会拉起它并等待 /api/health,
echo "==> 生成启动器产物(GC-<版本>-<系统>-<架构>)" # 模型窗口也由它承载,所以必须和启动器放在同一目录。
publish_backend() {
RID="$1"; OUT="$2"
echo "==> 编译 UI 后端 (${RID}) -> ${OUT}"
dotnet publish "$ROOT_DIR/GC-UI/backend/GC.UI.Server/GC.UI.Server.csproj" \
-c Release \
-r "$RID" \
--self-contained true \
-p:Version="$VERSION" \
-p:DebugType=none \
-p:PublishSingleFile=false \
-p:PublishTrimmed=false \
-o "$ROOT_DIR/$OUT" || return 1
}
# --- Windows:exe 单文件(连同 GC-SAVEDOG.exe 一起打进 zip)--- # 当前主机原生构建 Flutter 前端(Windows 主机编 Windows,macOS 主机编 macOS,
# Linux 主机编 Linux)。跨平台的 Windows 版由 build_flutter_ui_cross 负责。
#
# 默认「必须有前端」:缺 flutter 或编译失败直接返回非 0,让 build.sh 停下来说明
# 原因,而不是悄悄出一个只有 Avalonia 回退界面的包。确实需要降级时用
# ./build.sh build --allow-no-ui 显式声明。
build_flutter_ui() {
PLAT="$1"; DEST="$2"
UI_SRC="$ROOT_DIR/GC-UI/frontend"
if [ ! -d "$UI_SRC" ]; then
echo "!! 找不到 Flutter 工程:$UI_SRC"
return 1
fi
FLUTTER_BIN="${FLUTTER_BIN:-flutter}"
if ! command -v "$FLUTTER_BIN" >/dev/null 2>&1; then
echo "!! 未找到 flutter(可用 FLUTTER_BIN=<路径> 指定)"
return 1
fi
echo "==> 构建 Flutter 前端 (${PLAT})"
( cd "$UI_SRC" && "$FLUTTER_BIN" pub get && "$FLUTTER_BIN" build "$PLAT" --release ) || return 1
mkdir -p "$ROOT_DIR/$DEST"
case "$PLAT" in
windows)
# Release/ 里含 GC-UI.exe、flutter_windows.dll 和 data/
cp -R "$UI_SRC/build/windows/x64/runner/Release/." "$ROOT_DIR/$DEST/"
;;
macos)
rm -rf "$ROOT_DIR/$DEST/GC-UI.app"
cp -R "$UI_SRC/build/macos/Build/Products/Release/GC-UI.app" "$ROOT_DIR/$DEST/"
;;
linux)
# bundle/ 里是 GC-UI、lib/*.so 与 data/,整体铺到包的根目录。
# 目录名跟着目标架构走:aarch64 主机在 build/linux/arm64/,x64 在 build/linux/x64/。
BUNDLE=""
for cand in "$UI_SRC/build/linux/arm64/release/bundle" \
"$UI_SRC/build/linux/x64/release/bundle"; do
[ -d "$cand" ] && BUNDLE="$cand" && break
done
if [ -z "$BUNDLE" ]; then
echo "!! 找不到 Flutter Linux bundle(期望 build/linux/{arm64,x64}/release/bundle)"
return 1
fi
# 目标包是 arm64,却只编出 x64 bundle:说明主机架构不对,宁可失败也不出坏包
case "$BUNDLE" in
*/arm64/*) ;;
*)
if [ "$(uname -m)" != "aarch64" ] && [ "$(uname -m)" != "arm64" ]; then
echo "!! Linux 包目标为 arm64,但当前主机 $(uname -m) 只能编出 x64 前端"
return 1
fi
;;
esac
cp -R "$BUNDLE/." "$ROOT_DIR/$DEST/"
;;
*)
echo "!! 不支持的 Flutter 目标平台:$PLAT"
return 1
;;
esac
echo " -> $DEST(Flutter ${PLAT})"
}
# 在 Linux / macOS 上交叉编译 Windows 前端:mingw-w64 编 C++ 外壳,
# wine 跑 Windows 版 gen_snapshot 生成 AOT 快照,无需 Windows 机器。
# 产物布局与官方 toolchain 完全一致(GC-UI.exe + flutter_windows.dll + data/)。
build_flutter_ui_cross() {
DEST="$1"
UI_SRC="$ROOT_DIR/GC-UI/frontend"
[ -d "$UI_SRC" ] || return 0
FLUTTER_BIN="${FLUTTER_BIN:-flutter}"
if ! command -v "$FLUTTER_BIN" >/dev/null 2>&1; then
echo "!! 未找到 flutter(可用 FLUTTER_BIN=<路径> 指定)"
return 1
fi
mkdir -p "$ROOT_DIR/build/logs"
echo "==> 交叉编译 Windows 前端(mingw-w64 + wine)"
if ! FLUTTER_BIN="$FLUTTER_BIN" bash "$ROOT_DIR/buildsh/cross/build-ui-win-cross.sh" \
"$UI_SRC/build/windows/x64/runner/Release" \
>"$ROOT_DIR/build/logs/flutter-win-cross.log" 2>&1; then
echo "!! 交叉编译失败(日志:build/logs/flutter-win-cross.log)"
tail -5 "$ROOT_DIR/build/logs/flutter-win-cross.log" 2>/dev/null | sed 's/^/ /'
return 1
fi
mkdir -p "$ROOT_DIR/$DEST"
cp -R "$UI_SRC/build/windows/x64/runner/Release/." "$ROOT_DIR/$DEST/"
echo " -> $DEST(Flutter windows,交叉编译)"
}
pack_launcher() {
echo "==> 生成启动器产物(GCL-<版本>-<系统>-<架构>)"
# --- Windows:启动器 + 守护进程 + UI 后端 + Flutter 前端,整目录打包 ---
for pair in "win-x64:win-amd64" "win-arm64:win-arm64"; do for pair in "win-x64:win-amd64" "win-arm64:win-arm64"; do
RID="${pair%%:*}"; LABEL="${pair##*:}" RID="${pair%%:*}"; LABEL="${pair##*:}"
SRC="$ROOT_DIR/dist/$LABEL" SRC="$ROOT_DIR/dist/$LABEL"
[ -d "$SRC" ] || SRC="$ROOT_DIR/dist/$RID" # 兼容旧布局 [ -d "$SRC" ] || SRC="$ROOT_DIR/dist/$RID" # 兼容旧布局
[ -d "$SRC" ] || continue [ -d "$SRC" ] || continue
# 注意排除守护进程:GC-SAVEDOG.exe 在字典序里排在 GC.exe 前面
EXE=$(ls "$SRC"/*.exe 2>/dev/null | grep -v 'GC-SAVEDOG' | head -1) # 启动器固定是 GC.exe;后端与前端是可选的随包产物,不能当成启动器。
EXE="$SRC/GC.exe"
[ -f "$EXE" ] || EXE=$(ls "$SRC"/*.exe 2>/dev/null | grep -v 'GC-SAVEDOG\|GC.UI.Server\|GC-UI' | head -1)
[ -n "$EXE" ] || continue [ -n "$EXE" ] || continue
# 包内只有一个顶层目录(GCL-<版本>-<平台>),解压后不会散落一屏 dll。
TMP="$ROOT_DIR/dist/.winpkg-$LABEL" TMP="$ROOT_DIR/dist/.winpkg-$LABEL"
rm -rf "$TMP"; mkdir -p "$TMP" PKGNAME="GCL-${VERSION}-${LABEL}"
cp "$EXE" "$TMP/GC-${VERSION}-${LABEL}.exe" PKG="$TMP/$PKGNAME"
chmod +x "$TMP/GC-${VERSION}-${LABEL}.exe" 2>/dev/null || true rm -rf "$TMP"; mkdir -p "$PKG"
if [ -f "$SRC/GC-SAVEDOG.exe" ]; then cp -R "$SRC"/. "$PKG"/
cp "$SRC/GC-SAVEDOG.exe" "$TMP/GC-SAVEDOG.exe" rm -f "$PKG"/*.zip
else mv "$PKG/$(basename "$EXE")" "$PKG/$PKGNAME.exe"
chmod +x "$PKG/$PKGNAME.exe" 2>/dev/null || true
if [ ! -f "$PKG/GC-SAVEDOG.exe" ]; then
echo " !! 缺少 GC-SAVEDOG.exe,该平台将退回旧脚本更新" echo " !! 缺少 GC-SAVEDOG.exe,该平台将退回旧脚本更新"
else
# 守护进程放 safedog/:首次启动复制到 .GC/safedog,更新替换不再动它
mkdir -p "$PKG/safedog"
mv "$PKG/GC-SAVEDOG.exe" "$PKG/safedog/"
fi
if [ ! -f "$PKG/GC-UI.exe" ]; then
echo " !! 包内没有 Flutter 前端,启动器将使用内置 Avalonia 界面"
fi fi
ZIP="$ROOT_DIR/dist/$LABEL/GC-${VERSION}-${LABEL}.zip" ZIP="$ROOT_DIR/dist/$LABEL/$PKGNAME.zip"
rm -f "$ZIP" rm -f "$ZIP"
( cd "$TMP" && zip -q "$ZIP" ./* ) ( cd "$TMP" && zip -qr "$ZIP" "$PKGNAME" )
rm -rf "$TMP" rm -rf "$TMP"
echo " -> dist/$LABEL/GC-${VERSION}-${LABEL}.zip" echo " -> dist/$LABEL/$PKGNAME.zip"
done done
# --- Linux:整目录打包(启动器 + 守护 + 后端 + Flutter 前端)---
SRC="$ROOT_DIR/dist/linux-arm64"
if [ -d "$SRC" ]; then
TMP="$ROOT_DIR/dist/.linuxpkg"
PKGNAME="GCL-${VERSION}-linux-arm64"
PKG="$TMP/$PKGNAME"
rm -rf "$TMP"; mkdir -p "$PKG"
cp -R "$SRC"/. "$PKG"/
rm -f "$PKG"/*.zip
if [ -f "$PKG/GC" ]; then
mv "$PKG/GC" "$PKG/$PKGNAME"
chmod +x "$PKG/$PKGNAME" 2>/dev/null || true
fi
if [ -f "$PKG/GC-SAVEDOG" ]; then
mkdir -p "$PKG/safedog"
mv "$PKG/GC-SAVEDOG" "$PKG/safedog/"
fi
if [ ! -f "$PKG/GC-UI" ]; then
echo " !! 包内没有 Flutter 前端,启动器将使用内置 Avalonia 界面"
fi
ZIP="$ROOT_DIR/dist/linux-arm64/$PKGNAME.zip"
rm -f "$ZIP"
( cd "$TMP" && zip -qry "$ZIP" "$PKGNAME" )
rm -rf "$TMP"
echo " -> dist/linux-arm64/$PKGNAME.zip"
fi
# --- macOS:先得到真实 .app 目录(改名 + 同步 Info.plist)--- # --- macOS:先得到真实 .app 目录(改名 + 同步 Info.plist)---
MACAPP="$ROOT_DIR/dist/mac-arm64/GC.app" MACAPP="$ROOT_DIR/dist/mac-arm64/GC.app"
if [ -d "$MACAPP" ]; then if [ -d "$MACAPP" ]; then
FINAL="$ROOT_DIR/dist/GC-${VERSION}-mac-arm64.app" FINAL="$ROOT_DIR/dist/GCL-${VERSION}-mac-arm64.app"
rm -rf "$FINAL" rm -rf "$FINAL"
mv "$MACAPP" "$FINAL" mv "$MACAPP" "$FINAL"
chmod +x "$FINAL/Contents/MacOS/GC" 2>/dev/null || true chmod +x "$FINAL/Contents/MacOS/GC" 2>/dev/null || true
@@ -221,14 +371,14 @@ pack_launcher() {
fi fi
# --- 统一压缩:每个产物都打成同名 .zip,放进自己的平台目录 --- # --- 统一压缩:每个产物都打成同名 .zip,放进自己的平台目录 ---
# GC-1.0.3-mac-arm64.app -> dist/mac-arm64/GC-1.0.3-mac-arm64.zip # GCL-1.0.3-mac-arm64.app -> dist/mac-arm64/GCL-1.0.3-mac-arm64.zip
# 客户端下载时按「原名去掉扩展名 + .zip」取包,再解压回原名。 # 客户端下载时按「原名去掉扩展名 + .zip」取包,再解压回原名。
echo "==> 压缩为 zip" echo "==> 压缩为 zip"
for art in "$ROOT_DIR"/dist/GC-"$VERSION"-*.exe "$ROOT_DIR"/dist/GC-"$VERSION"-*.app; do for art in "$ROOT_DIR"/dist/GCL-"$VERSION"-*.exe "$ROOT_DIR"/dist/GCL-"$VERSION"-*.app; do
[ -e "$art" ] || continue [ -e "$art" ] || continue
base=$(basename "$art") base=$(basename "$art")
name="${base%.*}" # 去掉 .exe / .app name="${base%.*}" # 去掉 .exe / .app
label="${name#GC-${VERSION}-}" # mac-arm64 / win-amd64 label="${name#GCL-${VERSION}-}" # mac-arm64 / win-amd64
ZIP="$ROOT_DIR/dist/${label}/${name}.zip" ZIP="$ROOT_DIR/dist/${label}/${name}.zip"
mkdir -p "$ROOT_DIR/dist/${label}" mkdir -p "$ROOT_DIR/dist/${label}"
rm -f "$ZIP" rm -f "$ZIP"
@@ -250,7 +400,7 @@ pack_launcher() {
# 一次性删除又慢又不可逆,先挪走更安全(暂存区在下次构建开始时挪出 dist)。 # 一次性删除又慢又不可逆,先挪走更安全(暂存区在下次构建开始时挪出 dist)。
TRASH="$ROOT_DIR/build/trash" TRASH="$ROOT_DIR/build/trash"
mkdir -p "$TRASH" mkdir -p "$TRASH"
for leftover in "$ROOT_DIR"/dist/GC-"$VERSION"-*.exe "$ROOT_DIR"/dist/GC-"$VERSION"-*.app; do for leftover in "$ROOT_DIR"/dist/GCL-"$VERSION"-*.exe "$ROOT_DIR"/dist/GCL-"$VERSION"-*.app; do
[ -e "$leftover" ] || continue [ -e "$leftover" ] || continue
mv "$leftover" "$TRASH/$(basename "$leftover")-$(date +%s)" 2>/dev/null || true mv "$leftover" "$TRASH/$(basename "$leftover")-$(date +%s)" 2>/dev/null || true
done done
@@ -259,15 +409,15 @@ pack_launcher() {
stamp_launcher_only stamp_launcher_only
echo "" echo ""
echo "==> dist 里可发布的 zip:" echo "==> dist 里可发布的 zip:"
ls -lh "$ROOT_DIR"/dist/*/GC-"$VERSION"-*.zip 2>/dev/null || true ls -lh "$ROOT_DIR"/dist/*/GCL-"$VERSION"-*.zip 2>/dev/null || true
} }
# 删除 publish 过程中的中间目录:平台目录里只留最终 zip # 删除 publish 过程中的中间目录:平台目录里只留最终 zip
strip_intermediate_dirs() { strip_intermediate_dirs() {
for d in win-amd64 win-x64 win-arm64 mac-arm64; do for d in win-amd64 win-x64 win-arm64 mac-arm64 linux-arm64 linux-x64; do
[ -d "$ROOT_DIR/dist/$d" ] || continue [ -d "$ROOT_DIR/dist/$d" ] || continue
find "$ROOT_DIR/dist/$d" -mindepth 1 -maxdepth 1 \ find "$ROOT_DIR/dist/$d" -mindepth 1 -maxdepth 1 \
! -name "GC-${VERSION}-*.zip" -exec rm -rf {} + 2>/dev/null || true ! -name "GCL-${VERSION}-*.zip" -exec rm -rf {} + 2>/dev/null || true
done done
find "$ROOT_DIR/dist" -name ".DS_Store" -delete 2>/dev/null || true find "$ROOT_DIR/dist" -name ".DS_Store" -delete 2>/dev/null || true
} }
@@ -284,7 +434,7 @@ package_mac_app() {
<dict> <dict>
<key>CFBundleName</key><string>GC</string> <key>CFBundleName</key><string>GC</string>
<key>CFBundleDisplayName</key><string>GC</string> <key>CFBundleDisplayName</key><string>GC</string>
<key>CFBundleIdentifier</key><string>cn.neorf.GC</string> <key>CFBundleIdentifier</key><string>com.xhmcl.GC</string>
<key>CFBundleVersion</key><string>${VERSION}</string> <key>CFBundleVersion</key><string>${VERSION}</string>
<key>CFBundleShortVersionString</key><string>${VERSION}</string> <key>CFBundleShortVersionString</key><string>${VERSION}</string>
<key>CFBundlePackageType</key><string>APPL</string> <key>CFBundlePackageType</key><string>APPL</string>
+2 -2
View File
@@ -74,10 +74,10 @@ dll / json 的哈希 —— 本地文件被替换会直接拒绝加载。
"descriptionI18n": { "zh-CN": "……", "en": "……" }, "descriptionI18n": { "zh-CN": "……", "en": "……" },
"version": "1.6", "version": "1.6",
"updatedAt": "2026-11-14T08:00:00Z", "updatedAt": "2026-11-14T08:00:00Z",
"author": "NeoRF", "author": "Morris",
"tags": ["astronomy", "geography"], "tags": ["astronomy", "geography"],
"assembly": "EarthRotationModel.dll", "assembly": "EarthRotationModel.dll",
"type": "NeoRF.EarthModels.RotationModelFactory", "type": "GC.EarthModels.RotationModelFactory",
"preview": "preview.png", "preview": "preview.png",
"apiVersion": 1, "apiVersion": 1,
"minAppVersion": "1.0.7" "minAppVersion": "1.0.7"
+1 -1
View File
@@ -5,7 +5,7 @@
<TargetFramework>net8.0</TargetFramework> <TargetFramework>net8.0</TargetFramework>
<Nullable>enable</Nullable> <Nullable>enable</Nullable>
<ImplicitUsings>disable</ImplicitUsings> <ImplicitUsings>disable</ImplicitUsings>
<RootNamespace>NeoRF.EarthModels</RootNamespace> <RootNamespace>GC.EarthModels</RootNamespace>
<AssemblyName>EarthModelPreview</AssemblyName> <AssemblyName>EarthModelPreview</AssemblyName>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks> <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
</PropertyGroup> </PropertyGroup>
+2 -2
View File
@@ -10,9 +10,9 @@ using Avalonia.Headless;
using Avalonia.Media.Imaging; using Avalonia.Media.Imaging;
using Avalonia.Platform; using Avalonia.Platform;
using GC.ModelSdk; using GC.ModelSdk;
using NeoRF.EarthModels; using GC.EarthModels;
namespace NeoRF.EarthModels.Preview; namespace GC.EarthModels.Preview;
/// <summary> /// <summary>
/// 封面生成工具:给每个模型画一张 preview.png。 /// 封面生成工具:给每个模型画一张 preview.png。
+3 -3
View File
@@ -11,7 +11,7 @@ using GC.Services;
// 仓库根 version.json 与 model/version.json(内容相同,便于两种源地址读取)。 // 仓库根 version.json 与 model/version.json(内容相同,便于两种源地址读取)。
// 仓库地址(编译产物的 Release 也发在这里):与启动器默认 updateRepository 保持一致。 // 仓库地址(编译产物的 Release 也发在这里):与启动器默认 updateRepository 保持一致。
const string Repository = "https://gitcode.com/Morris_1/GC"; const string Repository = "https://git.xhmcl.com/Morris/GC";
// 位置参数:<仓库根> <启动器版本>;开关:--launcher-only // 位置参数:<仓库根> <启动器版本>;开关:--launcher-only
// --launcher-only 只刷新 launcher.packages(构建脚本在打完 zip 之后再调一次), // --launcher-only 只刷新 launcher.packages(构建脚本在打完 zip 之后再调一次),
@@ -150,8 +150,8 @@ var packages = new Dictionary<string, Dictionary<string, object>>();
// 2) 仓库里的编译产物 dist/<系统>-<架构>/GC-<版本>-<系统>-<架构>.zip —— // 2) 仓库里的编译产物 dist/<系统>-<架构>/GC-<版本>-<系统>-<架构>.zip ——
// 不发 Release、只提交产物也能更新(用户明确要求支持这种布局)。 // 不发 Release、只提交产物也能更新(用户明确要求支持这种布局)。
// 两种都写:url 只是「去哪儿找」,真正的完整性凭据是下面的 sha256(受签名保护)。 // 两种都写:url 只是「去哪儿找」,真正的完整性凭据是下面的 sha256(受签名保护)。
var releaseBase = $"{Repository}/releases/download/v{launcherVersion}"; var releaseBase = $"{Repository}/releases/download/{launcherVersion}";
foreach (var rid in new[] { "win-x64", "win-arm64", "osx-arm64", "osx-x64", "linux-x64" }) foreach (var rid in new[] { "win-x64", "win-arm64", "osx-arm64", "osx-x64", "linux-arm64" })
{ {
var label = LauncherArtifacts.LabelOf(rid); var label = LauncherArtifacts.LabelOf(rid);
var fileName = LauncherArtifacts.PackageFileName(launcherVersion, rid); var fileName = LauncherArtifacts.PackageFileName(launcherVersion, rid);
+1 -1
View File
@@ -12,7 +12,7 @@ using Avalonia.Media.Imaging;
using Avalonia.Platform; using Avalonia.Platform;
using Avalonia.Threading; using Avalonia.Threading;
namespace NeoRF.EarthModels; namespace GC.EarthModels;
public enum SceneView public enum SceneView
{ {
+1 -1
View File
@@ -11,7 +11,7 @@ using Avalonia.Media;
using Avalonia.Threading; using Avalonia.Threading;
using GC.ModelSdk; using GC.ModelSdk;
namespace NeoRF.EarthModels; namespace GC.EarthModels;
/// <summary> /// <summary>
/// 模型自己的界面:画布 + 触控友好工具栏 + 课堂演示卡 + 节气定格与步进。 /// 模型自己的界面:画布 + 触控友好工具栏 + 课堂演示卡 + 节气定格与步进。
+1 -1
View File
@@ -2,7 +2,7 @@ using System;
using Avalonia.Controls; using Avalonia.Controls;
using GC.ModelSdk; using GC.ModelSdk;
namespace NeoRF.EarthModels; namespace GC.EarthModels;
/// <summary> /// <summary>
/// 地球模型共享运行时:读自己目录下的 scene.json / land.json / i18n, /// 地球模型共享运行时:读自己目录下的 scene.json / land.json / i18n,
+1 -1
View File
@@ -2,7 +2,7 @@ using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Numerics; using System.Numerics;
namespace NeoRF.EarthModels; namespace GC.EarthModels;
/// <summary> /// <summary>
/// 地理模型的球面几何工具:经纬度 ↔ 单位球坐标、正交投影到屏幕、 /// 地理模型的球面几何工具:经纬度 ↔ 单位球坐标、正交投影到屏幕、
+1 -1
View File
@@ -4,7 +4,7 @@ using System.IO;
using System.Text.Json; using System.Text.Json;
using System.Text.Json.Serialization; using System.Text.Json.Serialization;
namespace NeoRF.EarthModels; namespace GC.EarthModels;
/// <summary>&lt;id&gt;.model/land.json —— 简化的大陆轮廓(经纬度多边形)。</summary> /// <summary>&lt;id&gt;.model/land.json —— 简化的大陆轮廓(经纬度多边形)。</summary>
public sealed class LandData public sealed class LandData
+1 -1
View File
@@ -3,7 +3,7 @@ using System.Text.Encodings.Web;
using System.Text.Json; using System.Text.Json;
using System.Text.Json.Serialization; using System.Text.Json.Serialization;
namespace NeoRF.EarthModels; namespace GC.EarthModels;
/// <summary>模型自己的 JSON 读写(不依赖启动器)。</summary> /// <summary>模型自己的 JSON 读写(不依赖启动器)。</summary>
public static class ModelJson public static class ModelJson
+1 -1
View File
@@ -4,7 +4,7 @@ using System.Globalization;
using System.IO; using System.IO;
using System.Text.Json; using System.Text.Json;
namespace NeoRF.EarthModels; namespace GC.EarthModels;
/// <summary> /// <summary>
/// 模型自己的一份文案。优先读模型数据目录里的 <c>i18n/&lt;language&gt;.json</c>, /// 模型自己的一份文案。优先读模型数据目录里的 <c>i18n/&lt;language&gt;.json</c>,
+1 -1
View File
@@ -1,6 +1,6 @@
using System.Collections.Generic; using System.Collections.Generic;
namespace NeoRF.EarthModels; namespace GC.EarthModels;
/// <summary>&lt;id&gt;.model/scene.json —— 模型数据(可视化场景描述)。</summary> /// <summary>&lt;id&gt;.model/scene.json —— 模型数据(可视化场景描述)。</summary>
public sealed class SceneDefinition public sealed class SceneDefinition
+1 -1
View File
@@ -2,7 +2,7 @@ using System;
using System.IO; using System.IO;
using Avalonia.Media; using Avalonia.Media;
namespace NeoRF.EarthModels; namespace GC.EarthModels;
/// <summary> /// <summary>
/// 模型自己的场景运行时:场景描述 + 预烘焙地表纹理 + 调色板。 /// 模型自己的场景运行时:场景描述 + 预烘焙地表纹理 + 调色板。
+1 -1
View File
@@ -3,7 +3,7 @@ using System.Collections.Generic;
using System.Threading.Tasks; using System.Threading.Tasks;
using Avalonia.Media; using Avalonia.Media;
namespace NeoRF.EarthModels; namespace GC.EarthModels;
/// <summary> /// <summary>
/// 预烘焙的等经纬度地表贴图:反照率 + 高度 + 冰盖 + 云层 + 夜间灯光。 /// 预烘焙的等经纬度地表贴图:反照率 + 高度 + 冰盖 + 云层 + 夜间灯光。
+1 -1
View File
@@ -3,7 +3,7 @@ using System.Numerics;
using System.Threading.Tasks; using System.Threading.Tasks;
using Avalonia.Media.Imaging; using Avalonia.Media.Imaging;
namespace NeoRF.EarthModels; namespace GC.EarthModels;
/// <summary> /// <summary>
/// 球体像素级渲染:正交投影 + 预烘焙地表纹理 + 地形光照 + 云层 + 夜灯 + 大气边缘光。 /// 球体像素级渲染:正交投影 + 预烘焙地表纹理 + 地形光照 + 云层 + 夜灯 + 大气边缘光。
+4 -4
View File
@@ -16,8 +16,8 @@
"terrain" "terrain"
], ],
"assembly": "ContourMapModel.dll", "assembly": "ContourMapModel.dll",
"type": "NeoRF.ContourMap.ContourMapFactory", "type": "GC.ContourMap.ContourMapFactory",
"version": "1.0", "version": "1.1",
"chrome": { "chrome": {
"titleBar": "#0C1828", "titleBar": "#0C1828",
"titleBorder": "#1B2740", "titleBorder": "#1B2740",
@@ -25,6 +25,6 @@
"button": "#9FB4D4", "button": "#9FB4D4",
"frame": "#0A1524" "frame": "#0A1524"
}, },
"build": "e4b3f2b87e", "build": "773ab2161d",
"updatedAt": "2026-11-14T11:34:35Z" "updatedAt": "2026-11-18T10:16:41Z"
} }
+1 -1
View File
@@ -4,7 +4,7 @@
<TargetFramework>net8.0</TargetFramework> <TargetFramework>net8.0</TargetFramework>
<Nullable>enable</Nullable> <Nullable>enable</Nullable>
<ImplicitUsings>disable</ImplicitUsings> <ImplicitUsings>disable</ImplicitUsings>
<RootNamespace>NeoRF.ContourMap</RootNamespace> <RootNamespace>GC.ContourMap</RootNamespace>
<AssemblyName>ContourMapModel</AssemblyName> <AssemblyName>ContourMapModel</AssemblyName>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks> <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<IsPackable>false</IsPackable> <IsPackable>false</IsPackable>
+1 -1
View File
@@ -6,7 +6,7 @@ using Avalonia.Layout;
using Avalonia.Media; using Avalonia.Media;
using GC.ModelSdk; using GC.ModelSdk;
namespace NeoRF.ContourMap; namespace GC.ContourMap;
/// <summary>等高线模型入口(清单里的 type 指向这里)。</summary> /// <summary>等高线模型入口(清单里的 type 指向这里)。</summary>
public sealed class ContourMapFactory : IModelFactory public sealed class ContourMapFactory : IModelFactory
+1 -1
View File
@@ -5,7 +5,7 @@ using Avalonia.Controls;
using Avalonia.Layout; using Avalonia.Layout;
using Avalonia.Media; using Avalonia.Media;
namespace NeoRF.ContourMap; namespace GC.ContourMap;
/// <summary>等高线模型的界面:顶部标题、中间双图联动、右侧判读要点、底部实时读数。</summary> /// <summary>等高线模型的界面:顶部标题、中间双图联动、右侧判读要点、底部实时读数。</summary>
public sealed class ContourPage public sealed class ContourPage
+1 -1
View File
@@ -6,7 +6,7 @@ using Avalonia;
using Avalonia.Controls; using Avalonia.Controls;
using Avalonia.Media; using Avalonia.Media;
namespace NeoRF.ContourMap; namespace GC.ContourMap;
/// <summary> /// <summary>
/// 等高线教学画布,左右两块: /// 等高线教学画布,左右两块:
+1 -1
View File
@@ -1,6 +1,6 @@
using System.Collections.Generic; using System.Collections.Generic;
namespace NeoRF.ContourMap; namespace GC.ContourMap;
/// <summary>内置全量文案兜底:没有语言包也能完整显示。</summary> /// <summary>内置全量文案兜底:没有语言包也能完整显示。</summary>
internal static class DefaultTexts internal static class DefaultTexts
+1 -1
View File
@@ -1,7 +1,7 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
namespace NeoRF.ContourMap; namespace GC.ContourMap;
/// <summary>地形部位识别结果:课本要求学生能在等高线图上认出这五种部位。</summary> /// <summary>地形部位识别结果:课本要求学生能在等高线图上认出这五种部位。</summary>
public enum TerrainFeature public enum TerrainFeature
+1 -1
View File
@@ -1,7 +1,7 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
namespace NeoRF.ContourMap; namespace GC.ContourMap;
/// <summary>五种基本地形类型(教科书分类)。</summary> /// <summary>五种基本地形类型(教科书分类)。</summary>
public enum TerrainKind public enum TerrainKind
+4 -4
View File
@@ -9,7 +9,7 @@
"en": "Climate zones, continent/ocean outlines, plates and borders — clean line art." "en": "Climate zones, continent/ocean outlines, plates and borders — clean line art."
}, },
"assembly": "EarthGeographyModel.dll", "assembly": "EarthGeographyModel.dll",
"type": "NeoRF.EarthModels.GeographyModelFactory", "type": "GC.EarthModels.GeographyModelFactory",
"author": "Morris GC", "author": "Morris GC",
"tags": [ "tags": [
"geography", "geography",
@@ -17,7 +17,7 @@
"atlas" "atlas"
], ],
"dataDir": "earth-geography.model", "dataDir": "earth-geography.model",
"version": "1.8", "version": "1.9",
"chrome": { "chrome": {
"titleBar": "#0C1828", "titleBar": "#0C1828",
"titleBorder": "#1B2740", "titleBorder": "#1B2740",
@@ -25,6 +25,6 @@
"button": "#9FB4D4", "button": "#9FB4D4",
"frame": "#0A1524" "frame": "#0A1524"
}, },
"build": "3b645c45c2", "build": "cc68b8863b",
"updatedAt": "2026-11-14T11:34:35Z" "updatedAt": "2026-11-18T10:16:41Z"
} }
@@ -4,7 +4,7 @@
<TargetFramework>net8.0</TargetFramework> <TargetFramework>net8.0</TargetFramework>
<Nullable>enable</Nullable> <Nullable>enable</Nullable>
<ImplicitUsings>disable</ImplicitUsings> <ImplicitUsings>disable</ImplicitUsings>
<RootNamespace>NeoRF.EarthModels</RootNamespace> <RootNamespace>GC.EarthModels</RootNamespace>
<AssemblyName>EarthGeographyModel</AssemblyName> <AssemblyName>EarthGeographyModel</AssemblyName>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks> <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<IsPackable>false</IsPackable> <IsPackable>false</IsPackable>
+1 -1
View File
@@ -1,7 +1,7 @@
using System.Collections.Generic; using System.Collections.Generic;
using System.Text.Json.Serialization; using System.Text.Json.Serialization;
namespace NeoRF.EarthModels; namespace GC.EarthModels;
/// <summary>地球地理模型的数据文件:全部是经纬度折线,只有轮廓没有填色。</summary> /// <summary>地球地理模型的数据文件:全部是经纬度折线,只有轮廓没有填色。</summary>
public sealed class GeoData public sealed class GeoData
@@ -7,7 +7,7 @@ using Avalonia.Layout;
using Avalonia.Media; using Avalonia.Media;
using GC.ModelSdk; using GC.ModelSdk;
namespace NeoRF.EarthModels; namespace GC.EarthModels;
/// <summary> /// <summary>
/// 地球地理模型:五带划分 + 七大洲四大洋轮廓 + 六大板块与洲界,纯线稿。 /// 地球地理模型:五带划分 + 七大洲四大洋轮廓 + 六大板块与洲界,纯线稿。
+1 -1
View File
@@ -8,7 +8,7 @@ using Avalonia.Input;
using Avalonia.Media; using Avalonia.Media;
using GC.ModelSdk; using GC.ModelSdk;
namespace NeoRF.EarthModels; namespace GC.EarthModels;
public enum GeoMode { Sphere3D, Flat2D } public enum GeoMode { Sphere3D, Flat2D }
+5 -5
View File
@@ -6,7 +6,7 @@
"zh-CN": "地球公转", "zh-CN": "地球公转",
"en": "Earth Revolution" "en": "Earth Revolution"
}, },
"author": "NeoRF", "author": "Morris",
"description": "四季更替、黄赤交角与二分二至", "description": "四季更替、黄赤交角与二分二至",
"descriptionI18n": { "descriptionI18n": {
"zh-CN": "地球绕太阳公转一年:地轴指向不变,太阳直射点南北往返,形成四季。", "zh-CN": "地球绕太阳公转一年:地轴指向不变,太阳直射点南北往返,形成四季。",
@@ -20,10 +20,10 @@
"entry": "scene.json", "entry": "scene.json",
"license": "MIT", "license": "MIT",
"assembly": "EarthRevolutionModel.dll", "assembly": "EarthRevolutionModel.dll",
"type": "NeoRF.EarthModels.RevolutionModelFactory", "type": "GC.EarthModels.RevolutionModelFactory",
"preview": "preview.png", "preview": "preview.png",
"apiVersion": 1, "apiVersion": 1,
"version": "1.6", "version": "1.7",
"chrome": { "chrome": {
"titleBar": "#0C1828", "titleBar": "#0C1828",
"titleBorder": "#1B2740", "titleBorder": "#1B2740",
@@ -31,6 +31,6 @@
"button": "#9FB4D4", "button": "#9FB4D4",
"frame": "#0A1524" "frame": "#0A1524"
}, },
"build": "947efa36bb", "build": "53b7a0fbc3",
"updatedAt": "2026-11-14T11:34:35Z" "updatedAt": "2026-11-18T10:16:41Z"
} }
@@ -4,7 +4,7 @@
<TargetFramework>net8.0</TargetFramework> <TargetFramework>net8.0</TargetFramework>
<Nullable>enable</Nullable> <Nullable>enable</Nullable>
<ImplicitUsings>disable</ImplicitUsings> <ImplicitUsings>disable</ImplicitUsings>
<RootNamespace>NeoRF.EarthModels</RootNamespace> <RootNamespace>GC.EarthModels</RootNamespace>
<AssemblyName>EarthRevolutionModel</AssemblyName> <AssemblyName>EarthRevolutionModel</AssemblyName>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks> <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<IsPackable>false</IsPackable> <IsPackable>false</IsPackable>
@@ -1,6 +1,6 @@
using GC.ModelSdk; using GC.ModelSdk;
namespace NeoRF.EarthModels; namespace GC.EarthModels;
/// <summary>地球公转模型入口(清单里的 type 指向这里)。</summary> /// <summary>地球公转模型入口(清单里的 type 指向这里)。</summary>
public sealed class RevolutionModelFactory : IModelFactory public sealed class RevolutionModelFactory : IModelFactory
+5 -5
View File
@@ -6,7 +6,7 @@
"zh-CN": "地球自转", "zh-CN": "地球自转",
"en": "Earth Rotation" "en": "Earth Rotation"
}, },
"author": "NeoRF", "author": "Morris",
"description": "昼夜交替、晨昏线与太阳直射点", "description": "昼夜交替、晨昏线与太阳直射点",
"descriptionI18n": { "descriptionI18n": {
"zh-CN": "观察自转中的地球:昼夜半球、晨昏线与太阳直射点位置。", "zh-CN": "观察自转中的地球:昼夜半球、晨昏线与太阳直射点位置。",
@@ -20,10 +20,10 @@
"entry": "scene.json", "entry": "scene.json",
"license": "MIT", "license": "MIT",
"assembly": "EarthRotationModel.dll", "assembly": "EarthRotationModel.dll",
"type": "NeoRF.EarthModels.RotationModelFactory", "type": "GC.EarthModels.RotationModelFactory",
"preview": "preview.png", "preview": "preview.png",
"apiVersion": 1, "apiVersion": 1,
"version": "1.6", "version": "1.7",
"chrome": { "chrome": {
"titleBar": "#0C1828", "titleBar": "#0C1828",
"titleBorder": "#1B2740", "titleBorder": "#1B2740",
@@ -31,6 +31,6 @@
"button": "#9FB4D4", "button": "#9FB4D4",
"frame": "#0A1524" "frame": "#0A1524"
}, },
"build": "a803d9c020", "build": "ecd52665f9",
"updatedAt": "2026-11-14T11:34:35Z" "updatedAt": "2026-11-18T10:16:41Z"
} }
@@ -4,7 +4,7 @@
<TargetFramework>net8.0</TargetFramework> <TargetFramework>net8.0</TargetFramework>
<Nullable>enable</Nullable> <Nullable>enable</Nullable>
<ImplicitUsings>disable</ImplicitUsings> <ImplicitUsings>disable</ImplicitUsings>
<RootNamespace>NeoRF.EarthModels</RootNamespace> <RootNamespace>GC.EarthModels</RootNamespace>
<AssemblyName>EarthRotationModel</AssemblyName> <AssemblyName>EarthRotationModel</AssemblyName>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks> <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<IsPackable>false</IsPackable> <IsPackable>false</IsPackable>
@@ -1,6 +1,6 @@
using GC.ModelSdk; using GC.ModelSdk;
namespace NeoRF.EarthModels; namespace GC.EarthModels;
/// <summary>地球自转模型入口(清单里的 type 指向这里)。</summary> /// <summary>地球自转模型入口(清单里的 type 指向这里)。</summary>
public sealed class RotationModelFactory : IModelFactory public sealed class RotationModelFactory : IModelFactory
+4 -4
View File
@@ -21,10 +21,10 @@
"entry": "scales.json", "entry": "scales.json",
"license": "MIT", "license": "MIT",
"assembly": "ScaleCalculatorModel.dll", "assembly": "ScaleCalculatorModel.dll",
"type": "NeoRF.ScaleCalculator.ScaleCalculatorFactory", "type": "GC.ScaleCalculator.ScaleCalculatorFactory",
"preview": "preview.png", "preview": "preview.png",
"apiVersion": 1, "apiVersion": 1,
"version": "1.5", "version": "1.6",
"chrome": { "chrome": {
"titleBar": "#FFFFFF", "titleBar": "#FFFFFF",
"titleBorder": "#E3E8F3", "titleBorder": "#E3E8F3",
@@ -32,6 +32,6 @@
"button": "#5B6A86", "button": "#5B6A86",
"frame": "#F4F6FB" "frame": "#F4F6FB"
}, },
"build": "02a555272a", "build": "105653737d",
"updatedAt": "2026-11-14T11:34:35Z" "updatedAt": "2026-11-18T10:16:41Z"
} }
Loaded 100 of 112 files, more files were not shown because too many files have changed in this diff. Show more