Compare commits

..
28 Commits
Author SHA1 Message Date
Morris 6ee2e8bead Merge pull request '1.0.11:发布包改为单文件,非本体文件收进 .GC/bin' (#15) from release/1.0.11-singlefile into main
Reviewed-on: Morris/GC#15
2026-11-18 13:10:16 +00:00
Morris daf218ce71 1.0.11:发布包改为单文件,非本体文件收进 .GC/bin
- 启动器改成 self-contained 单文件(压缩);GC.UI.Server 抽出 BackendServer.Start,
  由启动器在自己的进程内托管,发布包只剩一个 exe,不再复制两套 .NET 运行时
- 后端保留独立入口(GC.UI.Server 仍可单独 dotnet run),开发调试方式不变
- 守护进程等非本体文件统一放 .GC/bin:首次启动复制到 .GC/safedog 再运行;
  更新时只合并 .GC/bin,config/model/cache/update/logs 原地不动
- 压缩包不再预置 .GC 模板,首次启动由 AppPaths.EnsureCreated + RuntimeLayout 生成
- macOS 同样打进 .app 内的单文件启动器
- 版本号 1.0.11,version.json / model/version.json 重签(gc-2026-12)
2026-11-18 21:08:54 +08:00
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
114 changed files with 4508 additions and 1252 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 前端产物,
# 发布为一个「预览版(prerelease)」Release —— 不占用 latest。
# 手动:Actions 页面点 Run workflow(Gitea 的 workflow_dispatch),用于验证 runner 是否就绪;
# 也可以从命令行调 POST /api/v1/repos/{owner}/{repo}/actions/workflows/{file}/dispatches。
# 触发:**仅手动**。定时任务已取消(不再每天自动构建),需要时在 Actions 页面点
# Run workflow,或从命令行调
# POST /api/v1/repos/{owner}/{repo}/actions/workflows/{file}/dispatches。
# 产物:Windows 与 macOS 的 Flutter 前端,发布为一个「预览版(prerelease)」Release —— 不占用 latest。
#
# 为什么是 .gitea/workflows/:本仓库是自建 Gitea,不是 GitHub。Gitea Actions 语法与
# GitHub Actions 基本一致,但工作流目录是 .gitea/workflows/,API 前缀是 /api/v1,
@@ -16,12 +16,8 @@
name: GC-UI Alpha
on:
schedule:
# 每天晚上 21:00,北京时间。
# Gitea 1.23 起 Actions 的 cron 默认按 UTC 解释,这里显式带 TZ= 前缀(robfig/cron 支持的
# 时区前缀语法),这样不依赖服务器自身时区设置。
# 如果所在实例不认 TZ= 前缀,改用等效的 UTC 写法 '0 13 * * *'。
- cron: 'TZ=Asia/Shanghai 0 21 * * *'
# 定时触发已取消:夜间构建会绕开 build.sh,产出不含后端/前端的空壳包,
# 且 cron 的 TZ= 前缀在部分 Gitea 版本上非法。需要时手动 dispatch。
workflow_dispatch:
inputs:
note:
@@ -67,7 +63,7 @@ jobs:
exit 1
fi
# 北京时间当天日期,让产物名和 tag 与「每晚 9 点」对得上
# 北京时间当天日期,让同一天的多次手动构建落在同一个日期前缀下
DATE=$(TZ=Asia/Shanghai date +%Y%m%d)
# 同一天重跑时用 run_number 区分,tag 不重复
VERSION="${BASE}-alpha.${DATE}.${{ github.run_number }}"
@@ -122,11 +118,11 @@ jobs:
tag, version, sha, server = sys.argv[1:5]
short = sha[:7]
body = (
"GC-UI 夜间 alpha 构建(自动生成,**预览版 / prerelease**)。\n\n"
"GC-UI alpha 构建(手动触发,**预览版 / prerelease**)。\n\n"
"- 版本:`%s`\n"
"- 提交:`%s`\n"
"- 构建来源:%s/commit/%s\n"
"- 通道:alpha —— 每晚 21:00(Asia/Shanghai)自动构建\n\n"
"- 通道:alpha —— 手动触发(定时任务已取消)\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/test/shots/
# GC.Tests 离屏渲染输出(dotnet run ... GC.Tests 默认写到仓库根 screenshots/)
screenshots/
+2 -2
View File
@@ -22,8 +22,8 @@
-->
<AvaloniaVersion>11.3.9</AvaloniaVersion>
<MvvmVersion>8.2.2</MvvmVersion>
<Version>1.0.7</Version>
<Company>NeoRF</Company>
<Version>1.0.11</Version>
<Company>Morris</Company>
<Product>GC</Product>
<NeutralLanguage>zh-Hans</NeutralLanguage>
</PropertyGroup>
+187
View File
@@ -0,0 +1,187 @@
using System;
using System.Diagnostics;
using System.IO;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using GC.UI.Server;
using Microsoft.AspNetCore.Builder;
namespace GC;
/// <summary>
/// 新界面启动壳。
///
/// 发布包带 <c>GC-UI</c>(Flutter 前端)时,启动器只做三件事:
/// 1. 在自己的进程里起后端(本地 HTTP API + 模型窗口宿主),等 <c>/api/health</c> 就绪;
/// 2. 拉起 Flutter 窗口;
/// 3. 界面退出后关掉后端。
///
/// 后端跑在进程内而不是单独一个 exe:两者用的是同一套 .NET 运行时,
/// 拆成两个自包含进程等于把 60MB 运行时复制两份,发布包会白白大一倍。
///
/// 缺 Flutter 前端时返回 <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 WebApplication? _backend;
public static bool TryRun(string[] args)
{
var dir = AppContext.BaseDirectory;
var uiPath = FindUi(dir);
if (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 app = TryStartBackend(args, candidate);
if (app == null) continue;
if (WaitHealthy(candidate, TimeSpan.FromSeconds(25)))
{
port = candidate;
_backend = app;
break;
}
StopBackend(app);
}
if (_backend == null) return false;
}
AppDomain.CurrentDomain.ProcessExit += (_, _) => StopBackend(_backend);
var ui = Start(uiPath, dir, port);
if (ui == null)
{
StopBackend(_backend);
_backend = null;
return false;
}
ui.WaitForExit();
StopBackend(_backend);
_backend = null;
return true;
}
// ---------------------------------------------------------------- 产物定位
/// <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;
}
// ---------------------------------------------------------------- 进程管理
/// <summary>在本进程内启动后端;端口被占用等失败情况返回 null。</summary>
private static WebApplication? TryStartBackend(string[] args, int port)
{
try
{
var app = BackendServer.Start(args, port);
app.StartAsync().GetAwaiter().GetResult();
return app;
}
catch (Exception ex)
{
Console.Error.WriteLine($"[shell] 后端启动失败(端口 {port}): {ex.Message}");
return null;
}
}
private static void StopBackend(WebApplication? app)
{
if (app == null) return;
try
{
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(3));
app.StopAsync(cts.Token).GetAwaiter().GetResult();
}
catch (Exception ex)
{
Console.Error.WriteLine($"[shell] 关闭后端失败: {ex.Message}");
}
}
private static Process Start(string fileName, string workingDirectory, int port)
{
var info = new ProcessStartInfo(fileName)
{
WorkingDirectory = workingDirectory,
UseShellExecute = false,
};
// 把实际端口传给前端:它读这个环境变量拼 baseUrl,换端口不需要重新编译界面。
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)!;
}
// ---------------------------------------------------------------- 健康检查
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, TimeSpan timeout)
{
var deadline = DateTime.UtcNow + timeout;
while (DateTime.UtcNow < deadline)
{
if (IsHealthy(port)) return true;
Thread.Sleep(250);
}
return false;
}
}
+6
View File
@@ -17,9 +17,15 @@
<PackageReference Include="Avalonia.Desktop" Version="$(AvaloniaVersion)" />
</ItemGroup>
<ItemGroup>
<!-- 后端以库的方式编进启动器:发布包只需要一个 exe,不用再带一份运行时 -->
<FrameworkReference Include="Microsoft.AspNetCore.App" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\GC\src\GC.Core.csproj" />
<ProjectReference Include="..\GC-DOWNLOAD\GC-DOWNLOAD.csproj" />
<ProjectReference Include="..\GC-UI\backend\GC.UI.Server\GC.UI.Server.csproj" />
</ItemGroup>
</Project>
+6
View File
@@ -15,9 +15,15 @@ internal static class Program
var paths = AppPaths.Discover();
paths.EnsureCreated();
// 目录约定 + 双语日志 + 把包里的守护进程落到 .GC/safedog
RuntimeLayout.Ensure(paths);
// 上次下载的启动器新版,到这次启动才应用
if (DownloadModuleHost.Factory.TryApplyPending(paths)) return;
// 发布包带 Flutter 前端时,界面交给它;没带则回退到内置 Avalonia 界面。
if (FlutterShell.TryRun(args)) return;
BuildAvaloniaApp().StartWithClassicDesktopLifetime(args);
}
+8 -4
View File
@@ -29,7 +29,8 @@ public static class LauncherArtifacts
"win-arm64" => "win-arm64",
"osx-arm64" => "mac-arm64",
"osx-x64" => "mac-x64",
"linux-x64" => "linux-amd64",
"linux-x64" => "linux-amd64", // 旧产物目录名,仍能读
"linux-arm64" => "linux-arm64",
_ => rid
};
@@ -46,9 +47,9 @@ public static class LauncherArtifacts
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)
=> $"GC-{version.Trim().TrimStart('v', 'V')}-{LabelOf(rid)}.zip";
=> $"GCL-{version.Trim().TrimStart('v', 'V')}-{LabelOf(rid)}.zip";
/// <summary>
/// 判断某个 zip 名是不是「这个版本 + 这个平台」的启动器包。
@@ -57,7 +58,10 @@ public static class LauncherArtifacts
public static bool LooksLikePackage(string fileName, string version, string rid)
{
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');
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))
File.Delete(manifestCopy);
// 包名:GC-<版本>-<平台标签>.app/.exe(SAVEDOG 找不到时会自行扫描包内顶层)
var packageName = $"GC-{latest}-{PlatformLabel}" + (OperatingSystem.IsMacOS() ? ".app" : ".exe");
// 包名:GCL-<版本>-<平台标签>.app/.exe(SAVEDOG 找不到时会自行扫描包内顶层)。
// Linux 的启动器没有扩展名,别硬加 .exe —— 那会让按包名查找永远落空。
var packageName = $"GCL-{latest}-{PlatformLabel}" +
(OperatingSystem.IsMacOS() ? ".app"
: OperatingSystem.IsWindows() ? ".exe"
: "");
var request = new SavedogRequest
{
@@ -447,7 +451,8 @@ public static class LauncherUpdater
/// 找不到 SAVEDOG 时退回旧脚本流程(只用于从老版本升级的过渡)。
/// 返回 true 表示调用方应立即退出进程。
/// </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")))
@@ -484,6 +489,8 @@ public static class LauncherUpdater
catch { }
}
if (!execute) return true;
var psi = isWin
? new System.Diagnostics.ProcessStartInfo("cmd.exe")
{ UseShellExecute = false, CreateNoWindow = true }
@@ -576,7 +583,10 @@ public static class LauncherUpdater
s.AppendLine();
s.AppendLine("# delete old GC-* files: SAME platform only, version != latest");
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(" [ \"$item\" = \"$NEW\" ] && continue");
s.AppendLine(" base=$(basename \"$item\")");
@@ -584,6 +594,10 @@ public static class LauncherUpdater
s.AppendLine(" case \"$base\" in");
s.AppendLine(" *.app) stem=${stem%.app} ;;");
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(" esac");
s.AppendLine(" ver=${stem%%-*}");
@@ -711,6 +725,17 @@ public static class LauncherUpdater
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)
@@ -720,6 +745,22 @@ public static class LauncherUpdater
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)
{
try
+12
View File
@@ -20,9 +20,21 @@ public static class SavedogLauncher
var name = SavedogFiles.ExecutableName;
var install = paths.InstallDirectory;
// 首选 .GC/safedog:更新时整目录替换不会碰这里,正在运行的守护进程也安全。
var home = Path.Combine(paths.SafedogRoot, name);
if (File.Exists(home)) return home;
// 包内 payload:非本体文件统一收在 .GC/bin
var payload = Path.Combine(install, ".GC", "bin", name);
if (File.Exists(payload)) return payload;
var direct = Path.Combine(install, name);
if (File.Exists(direct)) return direct;
// 1.0.10 及更早的包把守护进程放在 safedog/ 子目录
var packaged = Path.Combine(install, "safedog", name);
if (File.Exists(packaged)) return packaged;
// macOS:可能放在 .app 内部
try
{
+12 -3
View File
@@ -40,7 +40,8 @@ public sealed class SourceSelector : ISourceSelector
/// <summary>
/// 探测两个源并返回最快的。force=true 时忽略缓存。
/// 两个都失败时返回 GitCode(默认源)。
/// 两个都失败时退回主源(Xhmcl):GitCode 镜像已停更,用它兜底只会拿到过期的
/// version.json —— 反而让人以为「没有更新」。
/// </summary>
public async Task<SourcePreset> PickFastestAsync(bool force = false, CancellationToken ct = default)
{
@@ -64,12 +65,20 @@ public sealed class SourceSelector : ISourceSelector
LastLatency = latencies;
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)
{
_cached = chosen;
_cachedAt = DateTime.UtcNow;
// 全部探测失败的结果不缓存:网络刚恢复时应该立刻重新测速,
// 而不是被一次失败的探测锁住 3 分钟。
_cachedAt = usable.Count > 0 ? DateTime.UtcNow : DateTime.MinValue;
}
Console.WriteLine("[selector] 测速:" + string.Join(" ",
+4 -3
View File
@@ -4,7 +4,7 @@ using System.Globalization;
namespace GC.Services;
/// <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 再排序,挑**版本号最高**的那个。
/// </summary>
public static class VersionUtil
@@ -15,8 +15,9 @@ public static class VersionUtil
if (string.IsNullOrWhiteSpace(tag)) return "";
var s = tag!.Trim();
// 去掉前缀:v / V / GC- / release-
if (s.StartsWith("GC-", StringComparison.OrdinalIgnoreCase)) s = s[3..];
// 去掉前缀:v / V / GC- / GCL- / release-
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..];
s = s.TrimStart('v', 'V');
+389 -112
View File
@@ -26,13 +26,14 @@ internal sealed class ApplyOptions
/// </summary>
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 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)
{
_options = options;
@@ -45,20 +46,24 @@ internal sealed class Applier
var requestPath = Path.Combine(updateDir, SavedogFiles.ApplyRequest);
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);
if (request == null || string.IsNullOrWhiteSpace(request.Version))
return Fail(updateDir, "更新申请内容不完整", 3);
return Fail(updateDir, "更新申请内容不完整", 3, "The update request is incomplete");
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 上文件还被占用)
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. 安装目录定位与安全检查
var installDir = string.IsNullOrWhiteSpace(_options.InstallDir)
@@ -66,10 +71,12 @@ internal sealed class Applier
: Path.GetFullPath(_options.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")))
return Fail(updateDir, "检测到源码目录,拒绝在源码树里替换程序", 4);
return Fail(updateDir, "检测到源码目录,拒绝在源码树里替换程序", 4,
"Source tree detected; refusing to replace files inside it");
// 3. 二次验签:不信任「启动器说它验过了」
var require = request.RequireSignature && SignatureKeyring.Enforced;
@@ -79,40 +86,50 @@ internal sealed class Applier
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);
}
_log.Info($"清单可信度:{verification.Trust}" +
(verification.KeyId != null ? $"({verification.KeyId})" : ""));
(verification.KeyId != null ? $"({verification.KeyId})" : ""),
$"Manifest trust: {verification.Trust}" +
(verification.KeyId != null ? $" ({verification.KeyId})" : ""));
// 4. 校验更新包
var zipPath = Path.Combine(updateDir, request.PackageZip);
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);
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);
if (!string.IsNullOrWhiteSpace(request.PackageSha256) &&
!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))
_log.Warn("清单没有提供 sha256,仅依赖签名与解压校验");
_log.Warn("清单没有提供 sha256,仅依赖签名与解压校验",
"Manifest has no sha256; relying on the signature and extraction checks only");
SafeArchive.Inspection inspection;
try
{
inspection = SafeArchive.Inspect(zipPath);
_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)
{
return Fail(updateDir, "更新包安全性检查失败: " + ex.Message, 5);
return Fail(updateDir, "更新包安全性检查失败: " + ex.Message, 5,
"Package safety check failed: " + ex.Message);
}
// 5. 解压到暂存区(与安装目录同卷,后续 rename 才是原子的)
@@ -126,30 +143,39 @@ internal sealed class Applier
catch (Exception ex)
{
ClearDirectory(stage);
return Fail(updateDir, "解压失败: " + ex.Message, 6);
return Fail(updateDir, "解压失败: " + ex.Message, 6, "Extraction failed: " + ex.Message);
}
var artifact = FindArtifact(stage, request.PackageName);
if (artifact == null)
{
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)
{
_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);
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);
TryDelete(zipPath);
TryDelete(requestPath);
@@ -157,40 +183,38 @@ internal sealed class Applier
{
Status = "applied",
Version = request.Version,
PackageName = Path.GetFileName(artifact),
PackageName = mainName,
Verified = true,
Message = "目标版本已存在,无需替换"
});
return 0;
}
// 6. 移入安装目录(不覆盖任何已有文件)
try
{
Directory.CreateDirectory(installDir);
if (Directory.Exists(artifact)) Directory.Move(artifact, target);
else File.Move(artifact, target);
_log.Info("新版已就位: " + Path.GetFileName(target));
}
catch (Exception ex)
// 6. 整目录替换:旧内容先搬到 backup,新内容就位;失败可原样还原。
// 只动程序文件,.GC(模型库 / 设置 / 更新目录)永远不碰。
var replaced = new List<(string Name, string? BackupPath)>();
if (!ReplaceInstallDirectory(stage, installDir, updateDir, replaced, out var replaceError))
{
RestoreFromBackup(installDir, replaced);
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. 启动并看护
var previous = ReadLastGood(updateDir);
StartupHealth.Clear(updateDir);
Process? child;
try
{
child = Launch(target);
child = Launch(mainTarget);
}
catch (Exception ex)
{
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,
@@ -198,15 +222,16 @@ internal sealed class Applier
if (healthy)
{
_log.Info($"v{request.Version} 启动正常,更新完成");
CleanupOldVersions(installDir, Path.GetFileName(target), request.PlatformLabel);
WriteLastGood(updateDir, request.Version, Path.GetFileName(target));
_log.Info($"v{request.Version} 启动正常,更新完成",
$"v{request.Version} started successfully; update complete");
CleanupBackup(updateDir);
WriteLastGood(updateDir, request.Version, mainName);
WriteState(updateDir, new SavedogState
{
Status = "applied",
Version = request.Version,
PreviousVersion = previous?.Version,
PackageName = Path.GetFileName(target),
PackageName = mainName,
Verified = true,
Message = "更新已应用"
});
@@ -216,21 +241,23 @@ internal sealed class Applier
return 0;
}
// 8. 回滚
_log.Error($"v{request.Version} 启动后未通过健康检查({_options.TimeoutSeconds}s),开始回滚");
// 8. 回滚:撤掉新装的文件,把备份原样搬回
_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);
var removed = RemoveNewVersion(target);
_log.Info(removed ? "已移除未通过检查的新版" : "新版文件被占用,未能完全移除");
var restored = RestoreFromBackup(installDir, replaced);
_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
{
Status = "rolledback",
Version = request.Version,
PreviousVersion = previous?.Version,
PackageName = Path.GetFileName(target),
PackageName = mainName,
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)
=> name.Length > 0 && name.Length < 200 &&
name.IndexOfAny(new[] { '/', '\\', ':', '\0' }) < 0 &&
(name.EndsWith(".app", StringComparison.OrdinalIgnoreCase) ||
name.EndsWith(".exe", StringComparison.OrdinalIgnoreCase));
=> SafeNamePattern.IsMatch(name);
private static readonly Regex SafeNamePattern = new(
@"^[A-Za-z0-9][A-Za-z0-9._-]{0,198}$",
RegexOptions.CultureInvariant | RegexOptions.Compiled);
private static bool WaitForExit(int pid, TimeSpan timeout)
{
@@ -280,22 +314,64 @@ internal sealed class Applier
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)
{
var direct = Path.Combine(stage, packageName);
if (File.Exists(direct) || Directory.Exists(direct)) return direct;
foreach (var entry in Directory.GetFileSystemEntries(stage))
if (!string.IsNullOrWhiteSpace(packageName))
{
var name = Path.GetFileName(entry);
if (name.EndsWith(".app", StringComparison.OrdinalIgnoreCase) && Directory.Exists(entry))
return entry;
if (name.EndsWith(".exe", StringComparison.OrdinalIgnoreCase) && File.Exists(entry))
var named = Path.Combine(stage, packageName);
if (File.Exists(named) || Directory.Exists(named)) return named;
}
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 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)
@@ -362,13 +438,14 @@ internal sealed class Applier
var health = StartupHealth.Read(updateDir);
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;
}
if (child.HasExited)
{
_log.Error($"新版进程已退出(退出码 {child.ExitCode})");
_log.Error($"新版进程已退出(退出码 {child.ExitCode})",
$"The new process exited (code {child.ExitCode})");
return false;
}
Thread.Sleep(250);
@@ -377,7 +454,8 @@ internal sealed class Applier
// 超时但进程还活着:可能是尚未写入健康标记的旧构建,谨慎放行
if (!child.HasExited)
{
_log.Warn("未收到健康标记,但进程仍在运行,按成功处理");
_log.Warn("未收到健康标记,但进程仍在运行,按成功处理",
"No health marker, but the process is still running; treating as success");
return true;
}
return false;
@@ -410,57 +488,254 @@ internal sealed class Applier
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` 只合并 `bin/`(非本体文件),其余子目录与更新目录自身一律跳过。
///
/// 返回 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))
{
var name = Path.GetFileName(entry);
if (string.Equals(name, keepName, StringComparison.OrdinalIgnoreCase)) continue;
error = null;
var backupDir = Path.Combine(updateDir, "backup");
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
{
if (Directory.Exists(target)) Directory.Delete(target, true);
else if (File.Exists(target)) File.Delete(target);
Directory.CreateDirectory(installDir);
ClearDirectory(backupDir);
Directory.CreateDirectory(backupDir);
var incoming = new List<string>();
foreach (var entry in Directory.GetFileSystemEntries(stage))
{
var name = Path.GetFileName(entry);
if (string.Equals(name, ".GC", StringComparison.OrdinalIgnoreCase))
{
// .GC 里只有 bin/ 属于程序本体(守护进程这类「非本体」文件),
// 其余(config / model / cache / update / logs / safedog)是用户数据,
// 整目录替换时必须原地不动。
MergeGcBin(entry, installDir, backupDir, replaced);
continue;
}
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;
}
catch (Exception ex)
{
_log.Warn("移除新版失败: " + ex.Message);
error = ex.Message;
return false;
}
}
/// <summary>
/// 合并新包里的 <c>.GC/bin</c>:只搬这一层文件,不动 .GC 下的用户数据。
///
/// 守护进程放在这里(而不是安装目录根)是为了「非本体文件全部收进 .GC/bin」;
/// 但正在运行的是 <c>.GC/safedog</c> 里的副本,所以这里的文件可以安全替换。
/// </summary>
private void MergeGcBin(string stageGc, string installDir, string backupDir,
List<(string Name, string? BackupPath)> replaced)
{
try
{
var bin = Path.Combine(stageGc, "bin");
if (!Directory.Exists(bin)) return;
var relBin = Path.Combine(".GC", "bin");
var targetBin = Path.Combine(installDir, relBin);
Directory.CreateDirectory(targetBin);
foreach (var file in Directory.GetFiles(bin))
{
var name = Path.GetFileName(file);
var rel = Path.Combine(relBin, name);
var target = Path.Combine(targetBin, name);
var backup = Path.Combine(backupDir, ".GC-bin", name);
if (File.Exists(target))
{
MoveEntry(target, backup);
replaced.Add((rel, backup));
}
else
{
replaced.Add((rel, null));
}
MoveEntry(file, target);
_log.Info("已更新非本体文件: " + rel, "Updated non-core file: " + rel);
}
}
catch (Exception ex)
{
_log.Warn($"合并 .GC/bin 失败(继续使用已有版本):{ex.Message}",
$"Failed to merge .GC/bin (keeping the existing one): {ex.Message}");
}
}
/// <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 —— 模型库、设置、日志、更新目录本身都在这里(只有 bin/ 由 MergeGcBin 单独处理);
/// · 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,
string platformLabel)
{
// 优先用上次成功的版本;否则挑一个同平台的其它版本
// 优先用上次成功启动的主程序;否则按优先级在安装目录里找
var candidates = new List<string>();
if (lastGood != null && !string.IsNullOrWhiteSpace(lastGood.PackageName))
candidates.Add(Path.Combine(installDir, lastGood.PackageName));
@@ -468,25 +743,27 @@ internal sealed class Applier
foreach (var entry in Directory.GetFileSystemEntries(installDir))
{
var name = Path.GetFileName(entry);
var match = ArtifactPattern.Match(name);
if (!match.Success) continue;
if (!string.Equals(match.Groups["plat"].Value, platformLabel, StringComparison.OrdinalIgnoreCase))
continue;
candidates.Add(entry);
if (IsProtected(name)) continue;
if (MainExecutablePriority(name) > 0) candidates.Add(entry);
else if (Directory.Exists(entry) &&
name.EndsWith(".app", StringComparison.OrdinalIgnoreCase))
candidates.Add(entry);
}
foreach (var candidate in candidates)
foreach (var candidate in candidates.Distinct(StringComparer.OrdinalIgnoreCase))
{
if (!File.Exists(candidate) && !Directory.Exists(candidate)) continue;
try
{
Launch(candidate);
_log.Info("已回滚启动: " + Path.GetFileName(candidate));
_log.Info("已回滚启动: " + Path.GetFileName(candidate),
"Rolled back and started: " + Path.GetFileName(candidate));
return true;
}
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;
@@ -497,12 +774,12 @@ internal sealed class Applier
private void WriteState(string updateDir, SavedogState 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 });
return code;
}
+2
View File
@@ -42,6 +42,8 @@
ManifestLoader 依赖启动器的 RepoVersion 模型,守护进程不需要,排除。 -->
<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" />
<!-- 与启动器共用同一份双语日志实现,保证 .GC/logs 里格式一致 -->
<Compile Include="..\GC\src\Services\GcLog.cs" Link="Shared\GcLog.cs" />
</ItemGroup>
</Project>
+13 -25
View File
@@ -1,34 +1,22 @@
using System;
using System.IO;
using GC.Services;
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
{
private readonly string? _path;
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)
public Log(string? dir)
{
var line = $"{DateTime.Now:yyyy-MM-dd HH:mm:ss} [{level}] {message}";
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 { /* 日志失败不能影响更新 */ }
if (!string.IsNullOrWhiteSpace(dir)) GcLog.Init(dir);
}
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>
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 static int Main(string[] args)
@@ -67,7 +67,10 @@ internal static class Program
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
{
UpdateDir = updateDir,
+73 -3
View File
@@ -1,6 +1,9 @@
# 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 基本一致,
差异集中在 **runner 标签** 和 **API 前缀** 两处。
@@ -64,9 +67,76 @@ Windows 还需要 **VS Build Tools 的「使用 C++ 的桌面开发」工作负
## 本地构建(不经 CI)
```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
# Windows
# Windows 主机原生构建
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。
+9 -1
View File
@@ -55,6 +55,10 @@ Windows 与 macOS 用**同一套 Flutter 代码 + 各自的原生 runner**:
### 1. 启动后端
发布版里后端不走独立进程:`GC-BOOT` 直接引用本工程,调用
`BackendServer.Start(args, port)` 在自己进程内托管,发布包因此只有一个 exe
(两个自包含进程会把 60MB 运行时复制两份)。下面的独立运行方式只用于开发调试。
```bash
# 仓库根目录
dotnet run --project GC-UI/backend/GC.UI.Server
@@ -65,7 +69,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-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. 启动前端
+11
View File
@@ -74,6 +74,7 @@ public sealed record LanguageDto(string Code, string Label);
public sealed record SettingsDto(
string Language,
string Theme,
string AccentColor,
int RenderFps,
int MemoryMb,
bool MemoryAuto,
@@ -96,6 +97,7 @@ public sealed record SettingsDto(
public sealed record SettingsPatch(
string? Language,
string? Theme,
string? AccentColor,
int? RenderFps,
int? MemoryMb,
bool? MemoryAuto,
@@ -131,6 +133,15 @@ public sealed record AboutDto(
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 PathRequest(string Path);
+29 -3
View File
@@ -28,7 +28,7 @@ public sealed class AvaloniaHost
{
private readonly AppServices _services;
private readonly object _gate = new();
private readonly List<PlayerWindow> _windows = new();
private readonly Dictionary<string, PlayerWindow> _windows = new(StringComparer.OrdinalIgnoreCase);
private Task<bool>? _startTask;
public AvaloniaHost(AppServices services) => _services = services;
@@ -98,6 +98,27 @@ public sealed class AvaloniaHost
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;
LoadedModel? loaded = null;
try
@@ -111,13 +132,18 @@ public sealed class AvaloniaHost
window = new PlayerWindow(package, loaded);
var captured = loaded;
var id = package.Id;
window.Closed += (_, _) =>
{
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();
return $"已启动模型 {package.Id}";
}
+664
View File
@@ -0,0 +1,664 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
using GC.Download;
using GC.Models;
using GC.Services;
using GC.UI.Server;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
namespace GC.UI.Server;
/// <summary>
/// GC-UI 后端(本地 HTTP 服务:模型扫描 / 下载 / 更新 / 设置 / 模型窗口宿主)。
///
/// 两种跑法共用同一份代码:
/// · 独立进程:<c>GC.UI.Server</c> 可执行文件(开发调试 / 旧包兼容);
/// · 进程内:启动器直接调用 <see cref="Start"/>,把后端跑在自己的进程里 ——
/// 发布包因此只需要一个 exe,不必再复制一份完整的 .NET 运行时。
/// </summary>
public static class BackendServer
{
/// <summary>按命令行 / GC_UI_PORT 解析端口并构建(未启动)的后端。</summary>
public static WebApplication StartFromCommandLine(string[] args)
=> Start(args, ResolvePort(args));
/// <summary>
/// 构建后端。返回的 <see cref="WebApplication"/> 尚未启动:
/// 独立进程直接 <c>Run()</c>,启动器用 <c>StartAsync()</c> 之后继续拉起界面。
/// </summary>
public static WebApplication Start(string[] args, int port)
{
// 下载模块(GC-DOWNLOAD)通过宿主钩子注入,和 GC-BOOT 的做法一致。
DownloadModuleHost.Factory = new DownloadModuleFactory();
var services = AppServices.Create();
var uiHost = new AvaloniaHost(services);
var builder = WebApplication.CreateBuilder(new WebApplicationOptions { Args = args });
builder.Logging.ClearProviders();
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;
// 这里放开本机回环来源,方便用 `flutter run -d chrome` 调试界面。
builder.Services.AddCors(options => options.AddDefaultPolicy(policy => policy
.SetIsOriginAllowed(origin =>
Uri.TryCreate(origin, UriKind.Absolute, out var uri) &&
(uri.Host == "127.0.0.1" || uri.Host == "localhost" || uri.Host == "::1"))
.AllowAnyHeader()
.AllowAnyMethod()));
var app = builder.Build();
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(
true,
LauncherRuntimeInfo.CurrentLauncherVersion,
LauncherRuntimeInfo.CurrentRid,
uiHost.IsAvailable,
uiHost.LastError)));
// ---- 已安装模型 -----------------------------------------------------------
app.MapGet("/api/models", () =>
Results.Ok(services.Models.Scan().Select(ToModelDto).ToList()));
app.MapGet("/api/models/{id}/preview", (string id, HttpResponse response) =>
{
if (!IsSafeId(id)) return Results.BadRequest(ErrorDto.Of("模型标识无效"));
var package = services.Models.Find(id);
if (package == null || !File.Exists(package.PreviewPath)) return Results.NotFound();
// 封面是静态图,允许前端缓存:默认全局中间件写的 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) =>
{
if (!IsSafeId(id)) return Results.BadRequest(new LaunchResultDto(false, "模型标识无效"));
var package = services.Models.Find(id);
if (package == null) return Results.NotFound(new LaunchResultDto(false, $"没有找到模型 {id}"));
try
{
services.Memory.Refresh();
var message = await uiHost.LaunchAsync(package);
return Results.Ok(new LaunchResultDto(true, message));
}
catch (Exception ex)
{
// 细节只写日志,不回显给调用方,避免泄漏本机路径等内部信息。
Console.Error.WriteLine($"[launch] 启动模型 {id} 失败: {ex}");
return Results.Json(new LaunchResultDto(false, "模型启动失败,请查看后端日志"), statusCode: 503);
}
});
app.MapDelete("/api/models/{id}", (string id) =>
{
if (!IsSafeId(id)) return Results.BadRequest(ErrorDto.Of("模型标识无效"));
var ok = services.Models.Delete(id);
if (ok) services.Models.NotifyChanged();
return ok
? Results.Ok(new LaunchResultDto(true, $"已删除模型 {id}"))
: Results.NotFound(ErrorDto.Of($"没有找到模型 {id}"));
});
// ---- 设置 -----------------------------------------------------------------
app.MapGet("/api/settings", () => Results.Ok(ToSettingsDto()));
app.MapPost("/api/settings", (SettingsPatch? patch) =>
{
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 =>
{
if (patch.Language != null) s.Language = patch.Language;
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.MemoryMb.HasValue) s.MemoryMb = Math.Clamp(patch.MemoryMb.Value, 256, 16384);
if (patch.MemoryAuto.HasValue) s.MemoryAuto = patch.MemoryAuto.Value;
if (patch.AutoUpdateOnStartup.HasValue) s.AutoUpdateOnStartup = patch.AutoUpdateOnStartup.Value;
if (patch.RequireSignedManifest.HasValue) s.RequireSignedManifest = patch.RequireSignedManifest.Value;
if (patch.UpdateRepository != null) s.UpdateRepository = patch.UpdateRepository;
if (patch.UpdateLocalRoot != null) s.UpdateLocalRoot = patch.UpdateLocalRoot;
if (patch.ModelRootOverride != null) s.ModelRootOverride = patch.ModelRootOverride;
});
if (patch.Language != null) L.I.SetLanguage(patch.Language);
if (patch.MemoryMb.HasValue || patch.MemoryAuto.HasValue)
services.Memory.ApplyAuto(services.Settings.Current.MemoryAuto, services.Settings.Current.MemoryMb);
return Results.Ok(ToSettingsDto());
});
// ---- 模型源 ---------------------------------------------------------------
app.MapGet("/api/sources", () =>
Results.Ok(services.Settings.Current.Sources.Select(ToSourceDto).ToList()));
app.MapPost("/api/sources/select", async (ForceRequest? request) =>
{
var force = request?.Force ?? false;
try
{
var fastest = await services.Selector.PickFastestAsync(force, CancellationToken.None);
services.Updates.UseRemote(services.DownloadModule.CreateRemote(fastest));
return Results.Ok(new LatencyDto(
fastest.Id, fastest.Name,
services.Selector.LastLatency.TryGetValue(fastest.Id, out var ms) ? ms : 0));
}
catch (Exception ex)
{
Console.Error.WriteLine($"[sources] 切换模型源失败: {ex}");
return Results.Json(ErrorDto.Of("模型源切换失败"), statusCode: 503);
}
});
app.MapGet("/api/remote/models", async (string? sourceId, bool force) =>
{
var source = ResolveSource(sourceId);
if (source == null) return Results.NotFound(ErrorDto.Of("没有可用的模型源"));
var index = await services.Sources.FetchAsync(source, force, null, CancellationToken.None);
var installed = services.Models.Scan()
.ToDictionary(p => p.Id, p => p.Manifest.Version, StringComparer.OrdinalIgnoreCase);
return Results.Ok(new SourceIndexDto(
index.SourceId,
index.Root,
index.FromCache,
index.Error,
index.ResolvedFrom,
index.Models.Select(m => new RemoteModelDto(
m.Id,
m.LocalizedName,
m.LocalizedDescription,
m.Manifest.Version,
m.SizeBytes,
ModelScanner.HumanSize(m.SizeBytes),
m.SourceId,
installed.ContainsKey(m.Id),
installed.TryGetValue(m.Id, out var v) ? v : null)).ToList()));
});
// ---- 下载 -----------------------------------------------------------------
app.MapPost("/api/download", async (DownloadRequest? request) =>
{
if (request == null || string.IsNullOrWhiteSpace(request.ModelId))
return Results.BadRequest(ErrorDto.Of("缺少 modelId"));
var source = ResolveSource(request.SourceId);
if (source == null) return Results.NotFound(ErrorDto.Of("没有可用的模型源"));
var index = await services.Sources.FetchAsync(source, false, null, CancellationToken.None);
var model = index.Models.FirstOrDefault(m =>
m.Id.Equals(request.ModelId, StringComparison.OrdinalIgnoreCase));
if (model == null)
return Results.NotFound(ErrorDto.Of($"源里没有模型 {request.ModelId}"));
var job = services.Downloads.Enqueue(model);
return Results.Ok(ToJobDto(job));
});
app.MapGet("/api/download/jobs", () =>
Results.Ok(services.Downloads.Jobs.Select(ToJobDto).ToList()));
app.MapPost("/api/download/{id}/cancel", (string id) =>
ActOnJob(id, job => services.Downloads.Cancel(job)));
app.MapPost("/api/download/{id}/retry", (string id) =>
ActOnJob(id, job => services.Downloads.Retry(job)));
app.MapPost("/api/download/{id}/remove", (string id) =>
ActOnJob(id, job => services.Downloads.Remove(job)));
app.MapPost("/api/download/clear-finished", () =>
{
services.Downloads.ClearFinished();
return Results.Ok(new LaunchResultDto(true, "已清除完成的任务"));
});
// ---- 更新 -----------------------------------------------------------------
app.MapPost("/api/update/check", async (ForceRequest? request) =>
{
var force = request?.Force ?? true;
var messages = new List<string>();
try
{
var fastest = await services.Selector.PickFastestAsync(force, CancellationToken.None);
services.Updates.UseRemote(services.DownloadModule.CreateRemote(fastest));
}
catch (Exception ex)
{
Console.Error.WriteLine($"[update] 测速失败,沿用当前源: {ex.Message}");
}
string? launcherLatest = null;
try
{
launcherLatest = await services.LauncherUpdates.CheckAsync(
services.Updates.Remote, CancellationToken.None);
}
catch (Exception ex)
{
Console.Error.WriteLine($"[update] 启动器版本检查失败: {ex.Message}");
}
var progress = new Progress<UpdateProgress>(p =>
{
if (!string.IsNullOrWhiteSpace(p.Message)) messages.Add(p.Message);
});
var result = await services.Updates.RunAsync(force, progress, CancellationToken.None);
return Results.Ok(new UpdateCheckDto(
result.Outcome.ToString(),
result.Message,
result.UpdatedModels,
result.ModelNames,
result.LauncherMessage,
result.Error,
launcherLatest,
services.Updates.Remote.DisplayName,
services.Selector.LastLatency
.Select(kv => new LatencyDto(
kv.Key,
SourcePreset.Find(kv.Key)?.Name ?? kv.Key,
kv.Value))
.ToList()));
});
// ---- 关于 -----------------------------------------------------------------
app.MapGet("/api/about", async () =>
{
var repository = services.Settings.Current.UpdateRepository;
var contributors = new List<ContributorDto>();
try
{
foreach (var c in await ContributorsService.FetchAsync(repository, CancellationToken.None))
contributors.Add(new ContributorDto(c.DisplayName, c.Contributions, c.AvatarUrl));
}
catch (Exception ex)
{
Console.Error.WriteLine($"[about] 读取贡献者失败: {ex.Message}");
}
return Results.Ok(new AboutDto(
"Morris GC",
LauncherRuntimeInfo.CurrentLauncherVersion,
LauncherRuntimeInfo.CurrentRid,
repository,
contributors,
// 「关于」页展示的技术栈信息:源码语言与前端框架。
SourceLanguage: "C#",
Frontend: "Flutter"));
});
// ---- 系统集成 -------------------------------------------------------------
app.MapPost("/api/shell/open-folder", (PathRequest? request) =>
{
var path = request?.Path;
if (string.IsNullOrWhiteSpace(path))
return Results.BadRequest(ErrorDto.Of("缺少 path"));
// 只允许打开启动器自己的目录,避免前端被当成任意路径执行器
if (!IsInsideKnownRoot(path!))
return Results.BadRequest(ErrorDto.Of("只允许打开启动器自己的目录"));
Shell.OpenFolder(path!);
return Results.Ok(new LaunchResultDto(true, "已打开目录"));
});
app.MapPost("/api/shell/open-url", (UrlRequest? request) =>
{
var url = request?.Url;
if (string.IsNullOrWhiteSpace(url) || url.Length > 2048 ||
!Uri.TryCreate(url, UriKind.Absolute, out var uri))
return Results.BadRequest(ErrorDto.Of("URL 无效"));
if (uri.Scheme != Uri.UriSchemeHttp && uri.Scheme != Uri.UriSchemeHttps)
return Results.BadRequest(ErrorDto.Of("只允许 http/https 链接"));
if (!string.IsNullOrEmpty(uri.UserInfo))
return Results.BadRequest(ErrorDto.Of("URL 不允许携带账号密码"));
Shell.OpenUrl(url!);
return Results.Ok(new LaunchResultDto(true, "已打开链接"));
});
// ---- 启动 -----------------------------------------------------------------
WriteEndpointFile(services, port);
Console.WriteLine($"[GC-UI] 后端已启动: http://127.0.0.1:{port}");
Console.WriteLine($"[GC-UI] 模型库: {services.Paths.ModelRoot}");
return app;
// ---------------------------------------------------------------------------
// 局部辅助
// ---------------------------------------------------------------------------
static void WriteEndpointFile(AppServices services, int port)
{
try
{
var file = Path.Combine(services.Paths.HomeRoot, "ui-backend.json");
var payload = JsonSerializer.Serialize(new
{
port,
pid = Environment.ProcessId,
url = $"http://127.0.0.1:{port}",
version = LauncherRuntimeInfo.CurrentLauncherVersion,
platform = LauncherRuntimeInfo.CurrentRid,
startedAt = DateTimeOffset.UtcNow.ToString("o")
}, new JsonSerializerOptions { WriteIndented = true });
File.WriteAllText(file, payload);
}
catch (Exception ex)
{
Console.Error.WriteLine($"[GC-UI] 写入端点文件失败: {ex.Message}");
}
}
/// <summary>按扩展名推断图片 MIME;模型封面允许 png / jpg / webp / gif。</summary>
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.LocalizedDescription,
package.Manifest.Version,
package.Manifest.Author,
package.SizeBytes,
ModelScanner.HumanSize(package.SizeBytes),
package.Manifest.Tags ?? new List<string>(),
File.Exists(package.PreviewPath),
$"/api/models/{package.Id}/preview",
package.Directory,
package.DataDirectory);
SourceDto ToSourceDto(ModelSource source) => new(
source.Id,
string.IsNullOrWhiteSpace(source.Name) ? source.Id : source.Name,
source.Url,
source.Enabled,
source.BuiltIn,
source.DisplayHost);
SettingsDto ToSettingsDto() => new(
services.Settings.Current.Language,
services.Settings.Current.Theme,
services.Settings.Current.AccentColor,
services.Settings.Current.RenderFps,
services.Settings.Current.MemoryMb,
services.Settings.Current.MemoryAuto,
services.Settings.Current.AutoUpdateOnStartup,
services.Settings.Current.RequireSignedManifest,
services.Settings.Current.UpdateRepository,
services.Settings.Current.UpdateLocalRoot,
services.Settings.Current.ModelRootOverride,
services.Memory.BudgetMb,
services.Memory.UsageText,
services.Paths.ModelRoot,
services.Paths.DataRoot,
services.Paths.SettingsFile,
LauncherRuntimeInfo.CurrentLauncherVersion,
LauncherRuntimeInfo.CurrentRid,
services.Settings.Current.Sources.Select(ToSourceDto).ToList(),
L.Supported.Select(s => new LanguageDto(s.Code, s.Label)).ToList());
JobDto ToJobDto(IDownloadJob job) => new(
job.Id,
job.Model.Id,
job.Name,
job.Version,
job.State.ToString(),
job.Progress,
job.StatusText,
job.DetailText,
job.Error,
job.IsActive,
job.CanRetry,
job.IsDone);
ModelSource? ResolveSource(string? sourceId)
{
var sources = services.Settings.Current.Sources;
if (!string.IsNullOrWhiteSpace(sourceId))
{
var exact = sources.FirstOrDefault(s =>
s.Id.Equals(sourceId, StringComparison.OrdinalIgnoreCase));
if (exact != null) return exact;
}
return sources.FirstOrDefault(s => s.Enabled && !string.IsNullOrWhiteSpace(s.Url))
?? sources.FirstOrDefault();
}
IResult ActOnJob(string id, Action<IDownloadJob> action)
{
if (!IsSafeId(id)) return Results.BadRequest(ErrorDto.Of("任务标识无效"));
var job = services.Downloads.Jobs.FirstOrDefault(j =>
j.Id.Equals(id, StringComparison.OrdinalIgnoreCase));
if (job == null) return Results.NotFound(ErrorDto.Of($"没有找到任务 {id}"));
action(job);
return Results.Ok(ToJobDto(job));
}
bool IsInsideKnownRoot(string path)
{
try
{
var full = Path.GetFullPath(path);
var roots = new[]
{
services.Paths.ModelRoot,
services.Paths.DataRoot,
services.Paths.HomeRoot,
services.Paths.AppRoot
};
foreach (var root in roots)
{
if (string.IsNullOrWhiteSpace(root)) continue;
var rootFull = Path.GetFullPath(root);
if (full.Equals(rootFull, StringComparison.OrdinalIgnoreCase)) return true;
if (full.StartsWith(rootFull + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase))
return true;
}
}
catch
{
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);
}
}
public static int ResolvePort(string[] args)
{
// 优先用启动器传来的端口(GC_UI_PORT),保证前端拼出来的 baseUrl 和这里一致。
var env = Environment.GetEnvironmentVariable(GcUiContract.PortEnvVar);
if (int.TryParse(env, out var fromEnv) && fromEnv > 0 && fromEnv < 65536) return fromEnv;
for (var i = 0; i < args.Length; i++)
{
if (args[i] == "--port" && i + 1 < args.Length &&
int.TryParse(args[i + 1], out var next) && next > 0 && next < 65536)
return next;
const string prefix = "--port=";
if (args[i].StartsWith(prefix, StringComparison.Ordinal) &&
int.TryParse(args[i][prefix.Length..], out var inline) && inline > 0 && inline < 65536)
return inline;
}
return GcUiContract.DefaultPort;
}
}
+3 -500
View File
@@ -1,503 +1,6 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
using GC.Download;
using GC.Models;
using GC.Services;
using GC.UI.Server;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
// ---------------------------------------------------------------------------
// GC-UI 后端:本地 HTTP 服务(只监听 127.0.0.1)。
//
// 它把原来 GC 启动器里的服务层原样复用(GC.Core / GC-DOWNLOAD),
// 只是把「界面」从 Avalonia 换成 Flutter —— 前端通过下面这些接口驱动后端。
//
// GET /api/health 健康检查 + 图形环境是否可用
// GET /api/models 已安装模型
// GET /api/models/{id}/preview 模型封面图
// POST /api/models/{id}/launch 启动模型(打开模型自己的窗口)
// DELETE /api/models/{id} 删除模型
// GET /api/settings 读取设置
// POST /api/settings 修改设置(补丁式)
// GET /api/sources 模型源列表
// POST /api/sources/select 双源测速并切到最快
// GET /api/remote/models 远端可下载模型
// POST /api/download 入队下载
// GET /api/download/jobs 下载任务
// POST /api/download/{id}/cancel|retry|remove
// POST /api/download/clear-finished 清除已完成
// POST /api/update/check 检查模型 / 启动器更新
// GET /api/about 版本 + 贡献者
// POST /api/shell/open-folder|open-url 打开目录 / 链接
// ---------------------------------------------------------------------------
var port = ResolvePort(args);
// 下载模块(GC-DOWNLOAD)通过宿主钩子注入,和 GC-BOOT 的做法一致。
DownloadModuleHost.Factory = new DownloadModuleFactory();
var services = AppServices.Create();
var uiHost = new AvaloniaHost(services);
var builder = WebApplication.CreateBuilder(new WebApplicationOptions { Args = args });
builder.Logging.ClearProviders();
builder.WebHost.UseUrls($"http://127.0.0.1:{port}");
// 桌面端(Windows/macOS)走原生 HTTP,不需要 CORS;
// 这里放开本机回环来源,方便用 `flutter run -d chrome` 调试界面。
builder.Services.AddCors(options => options.AddDefaultPolicy(policy => policy
.SetIsOriginAllowed(origin =>
Uri.TryCreate(origin, UriKind.Absolute, out var uri) &&
(uri.Host == "127.0.0.1" || uri.Host == "localhost"))
.AllowAnyHeader()
.AllowAnyMethod()));
var app = builder.Build();
app.UseCors();
// ---- 健康检查 -------------------------------------------------------------
app.MapGet("/api/health", () => Results.Ok(new HealthDto(
true,
LauncherRuntimeInfo.CurrentLauncherVersion,
LauncherRuntimeInfo.CurrentRid,
uiHost.IsAvailable,
uiHost.LastError)));
// ---- 已安装模型 -----------------------------------------------------------
app.MapGet("/api/models", () =>
Results.Ok(services.Models.Scan().Select(ToModelDto).ToList()));
app.MapGet("/api/models/{id}/preview", (string id) =>
{
var package = services.Models.Find(id);
if (package == null || !File.Exists(package.PreviewPath)) return Results.NotFound();
return Results.File(package.PreviewPath, "image/png");
});
app.MapPost("/api/models/{id}/launch", async (string id) =>
{
var package = services.Models.Find(id);
if (package == null) return Results.NotFound(new LaunchResultDto(false, $"没有找到模型 {id}"));
try
{
services.Memory.Refresh();
var message = await uiHost.LaunchAsync(package);
return Results.Ok(new LaunchResultDto(true, message));
}
catch (Exception ex)
{
return Results.Json(new LaunchResultDto(false, ex.Message), statusCode: 503);
}
});
app.MapDelete("/api/models/{id}", (string id) =>
{
var ok = services.Models.Delete(id);
if (ok) services.Models.NotifyChanged();
return ok
? Results.Ok(new LaunchResultDto(true, $"已删除模型 {id}"))
: Results.NotFound(new LaunchResultDto(false, $"没有找到模型 {id}"));
});
// ---- 设置 -----------------------------------------------------------------
app.MapGet("/api/settings", () => Results.Ok(ToSettingsDto()));
app.MapPost("/api/settings", (SettingsPatch? patch) =>
{
if (patch == null) return Results.BadRequest(new LaunchResultDto(false, "缺少设置内容"));
services.Settings.Apply(s =>
{
if (patch.Language != null) s.Language = patch.Language;
if (patch.Theme != null) s.Theme = patch.Theme;
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.MemoryAuto.HasValue) s.MemoryAuto = patch.MemoryAuto.Value;
if (patch.AutoUpdateOnStartup.HasValue) s.AutoUpdateOnStartup = patch.AutoUpdateOnStartup.Value;
if (patch.RequireSignedManifest.HasValue) s.RequireSignedManifest = patch.RequireSignedManifest.Value;
if (patch.UpdateRepository != null) s.UpdateRepository = patch.UpdateRepository;
if (patch.UpdateLocalRoot != null) s.UpdateLocalRoot = patch.UpdateLocalRoot;
if (patch.ModelRootOverride != null) s.ModelRootOverride = patch.ModelRootOverride;
});
if (patch.Language != null) L.I.SetLanguage(patch.Language);
if (patch.MemoryMb.HasValue || patch.MemoryAuto.HasValue)
services.Memory.ApplyAuto(services.Settings.Current.MemoryAuto, services.Settings.Current.MemoryMb);
return Results.Ok(ToSettingsDto());
});
// ---- 模型源 ---------------------------------------------------------------
app.MapGet("/api/sources", () =>
Results.Ok(services.Settings.Current.Sources.Select(ToSourceDto).ToList()));
app.MapPost("/api/sources/select", async (ForceRequest? request) =>
{
var force = request?.Force ?? false;
try
{
var fastest = await services.Selector.PickFastestAsync(force, CancellationToken.None);
services.Updates.UseRemote(services.DownloadModule.CreateRemote(fastest));
return Results.Ok(new LatencyDto(
fastest.Id, fastest.Name,
services.Selector.LastLatency.TryGetValue(fastest.Id, out var ms) ? ms : 0));
}
catch (Exception ex)
{
return Results.Json(new LaunchResultDto(false, ex.Message), statusCode: 503);
}
});
app.MapGet("/api/remote/models", async (string? sourceId, bool force) =>
{
var source = ResolveSource(sourceId);
if (source == null) return Results.NotFound(new LaunchResultDto(false, "没有可用的模型源"));
var index = await services.Sources.FetchAsync(source, force, null, CancellationToken.None);
var installed = services.Models.Scan()
.ToDictionary(p => p.Id, p => p.Manifest.Version, StringComparer.OrdinalIgnoreCase);
return Results.Ok(new SourceIndexDto(
index.SourceId,
index.Root,
index.FromCache,
index.Error,
index.ResolvedFrom,
index.Models.Select(m => new RemoteModelDto(
m.Id,
m.LocalizedName,
m.LocalizedDescription,
m.Manifest.Version,
m.SizeBytes,
ModelScanner.HumanSize(m.SizeBytes),
m.SourceId,
installed.ContainsKey(m.Id),
installed.TryGetValue(m.Id, out var v) ? v : null)).ToList()));
});
// ---- 下载 -----------------------------------------------------------------
app.MapPost("/api/download", async (DownloadRequest? request) =>
{
if (request == null || string.IsNullOrWhiteSpace(request.ModelId))
return Results.BadRequest(new LaunchResultDto(false, "缺少 modelId"));
var source = ResolveSource(request.SourceId);
if (source == null) return Results.NotFound(new LaunchResultDto(false, "没有可用的模型源"));
var index = await services.Sources.FetchAsync(source, false, null, CancellationToken.None);
var model = index.Models.FirstOrDefault(m =>
m.Id.Equals(request.ModelId, StringComparison.OrdinalIgnoreCase));
if (model == null)
return Results.NotFound(new LaunchResultDto(false, $"源里没有模型 {request.ModelId}"));
var job = services.Downloads.Enqueue(model);
return Results.Ok(ToJobDto(job));
});
app.MapGet("/api/download/jobs", () =>
Results.Ok(services.Downloads.Jobs.Select(ToJobDto).ToList()));
app.MapPost("/api/download/{id}/cancel", (string id) =>
ActOnJob(id, job => services.Downloads.Cancel(job)));
app.MapPost("/api/download/{id}/retry", (string id) =>
ActOnJob(id, job => services.Downloads.Retry(job)));
app.MapPost("/api/download/{id}/remove", (string id) =>
ActOnJob(id, job => services.Downloads.Remove(job)));
app.MapPost("/api/download/clear-finished", () =>
{
services.Downloads.ClearFinished();
return Results.Ok(new LaunchResultDto(true, "已清除完成的任务"));
});
// ---- 更新 -----------------------------------------------------------------
app.MapPost("/api/update/check", async (ForceRequest? request) =>
{
var force = request?.Force ?? true;
var messages = new List<string>();
try
{
var fastest = await services.Selector.PickFastestAsync(force, CancellationToken.None);
services.Updates.UseRemote(services.DownloadModule.CreateRemote(fastest));
}
catch (Exception ex)
{
Console.Error.WriteLine($"[update] 测速失败,沿用当前源: {ex.Message}");
}
string? launcherLatest = null;
try
{
launcherLatest = await services.LauncherUpdates.CheckAsync(
services.Updates.Remote, CancellationToken.None);
}
catch (Exception ex)
{
Console.Error.WriteLine($"[update] 启动器版本检查失败: {ex.Message}");
}
var progress = new Progress<UpdateProgress>(p =>
{
if (!string.IsNullOrWhiteSpace(p.Message)) messages.Add(p.Message);
});
var result = await services.Updates.RunAsync(force, progress, CancellationToken.None);
return Results.Ok(new UpdateCheckDto(
result.Outcome.ToString(),
result.Message,
result.UpdatedModels,
result.ModelNames,
result.LauncherMessage,
result.Error,
launcherLatest,
services.Updates.Remote.DisplayName,
services.Selector.LastLatency
.Select(kv => new LatencyDto(
kv.Key,
SourcePreset.Find(kv.Key)?.Name ?? kv.Key,
kv.Value))
.ToList()));
});
// ---- 关于 -----------------------------------------------------------------
app.MapGet("/api/about", async () =>
{
var repository = services.Settings.Current.UpdateRepository;
var contributors = new List<ContributorDto>();
try
{
foreach (var c in await ContributorsService.FetchAsync(repository, CancellationToken.None))
contributors.Add(new ContributorDto(c.DisplayName, c.Contributions, c.AvatarUrl));
}
catch (Exception ex)
{
Console.Error.WriteLine($"[about] 读取贡献者失败: {ex.Message}");
}
return Results.Ok(new AboutDto(
"Morris GC",
LauncherRuntimeInfo.CurrentLauncherVersion,
LauncherRuntimeInfo.CurrentRid,
repository,
contributors,
// 「关于」页展示的技术栈信息:源码语言与前端框架。
SourceLanguage: "C#",
Frontend: "Flutter"));
});
// ---- 系统集成 -------------------------------------------------------------
app.MapPost("/api/shell/open-folder", (PathRequest? request) =>
{
var path = request?.Path;
if (string.IsNullOrWhiteSpace(path))
return Results.BadRequest(new LaunchResultDto(false, "缺少 path"));
// 只允许打开启动器自己的目录,避免前端被当成任意路径执行器
if (!IsInsideKnownRoot(path!))
return Results.BadRequest(new LaunchResultDto(false, "只允许打开启动器自己的目录"));
Shell.OpenFolder(path!);
return Results.Ok(new LaunchResultDto(true, "已打开目录"));
});
app.MapPost("/api/shell/open-url", (UrlRequest? request) =>
{
var url = request?.Url;
if (string.IsNullOrWhiteSpace(url) || !Uri.TryCreate(url, UriKind.Absolute, out var uri))
return Results.BadRequest(new LaunchResultDto(false, "URL 无效"));
if (uri.Scheme != Uri.UriSchemeHttp && uri.Scheme != Uri.UriSchemeHttps)
return Results.BadRequest(new LaunchResultDto(false, "只允许 http/https 链接"));
Shell.OpenUrl(url!);
return Results.Ok(new LaunchResultDto(true, "已打开链接"));
});
// ---- 启动 -----------------------------------------------------------------
WriteEndpointFile(services, port);
Console.WriteLine($"[GC-UI] 后端已启动: http://127.0.0.1:{port}");
Console.WriteLine($"[GC-UI] 模型库: {services.Paths.ModelRoot}");
// 独立进程入口:`GC.UI.Server --port 17890`
// 启动器在进程内直接调用 BackendServer.Start,不会走到这里。
var app = BackendServer.StartFromCommandLine(args);
app.Run();
// ---------------------------------------------------------------------------
// 局部辅助
// ---------------------------------------------------------------------------
static int ResolvePort(string[] args)
{
var env = Environment.GetEnvironmentVariable("GC_UI_PORT");
if (int.TryParse(env, out var fromEnv) && fromEnv > 0 && fromEnv < 65536) return fromEnv;
for (var i = 0; i < args.Length; i++)
{
if (args[i] == "--port" && i + 1 < args.Length &&
int.TryParse(args[i + 1], out var next) && next > 0 && next < 65536)
return next;
const string prefix = "--port=";
if (args[i].StartsWith(prefix, StringComparison.Ordinal) &&
int.TryParse(args[i][prefix.Length..], out var inline) && inline > 0 && inline < 65536)
return inline;
}
return 17890;
}
static void WriteEndpointFile(AppServices services, int port)
{
try
{
var file = Path.Combine(services.Paths.HomeRoot, "ui-backend.json");
var payload = JsonSerializer.Serialize(new
{
port,
pid = Environment.ProcessId,
url = $"http://127.0.0.1:{port}",
version = LauncherRuntimeInfo.CurrentLauncherVersion,
platform = LauncherRuntimeInfo.CurrentRid,
startedAt = DateTimeOffset.UtcNow.ToString("o")
}, new JsonSerializerOptions { WriteIndented = true });
File.WriteAllText(file, payload);
}
catch (Exception ex)
{
Console.Error.WriteLine($"[GC-UI] 写入端点文件失败: {ex.Message}");
}
}
ModelDto ToModelDto(ModelPackage package) => new(
package.Id,
package.LocalizedName,
package.LocalizedDescription,
package.Manifest.Version,
package.Manifest.Author,
package.SizeBytes,
ModelScanner.HumanSize(package.SizeBytes),
package.Manifest.Tags ?? new List<string>(),
File.Exists(package.PreviewPath),
$"/api/models/{package.Id}/preview",
package.Directory,
package.DataDirectory);
SourceDto ToSourceDto(ModelSource source) => new(
source.Id,
string.IsNullOrWhiteSpace(source.Name) ? source.Id : source.Name,
source.Url,
source.Enabled,
source.BuiltIn,
source.DisplayHost);
SettingsDto ToSettingsDto() => new(
services.Settings.Current.Language,
services.Settings.Current.Theme,
services.Settings.Current.RenderFps,
services.Settings.Current.MemoryMb,
services.Settings.Current.MemoryAuto,
services.Settings.Current.AutoUpdateOnStartup,
services.Settings.Current.RequireSignedManifest,
services.Settings.Current.UpdateRepository,
services.Settings.Current.UpdateLocalRoot,
services.Settings.Current.ModelRootOverride,
services.Memory.BudgetMb,
services.Memory.UsageText,
services.Paths.ModelRoot,
services.Paths.DataRoot,
services.Paths.SettingsFile,
LauncherRuntimeInfo.CurrentLauncherVersion,
LauncherRuntimeInfo.CurrentRid,
services.Settings.Current.Sources.Select(ToSourceDto).ToList(),
L.Supported.Select(s => new LanguageDto(s.Code, s.Label)).ToList());
JobDto ToJobDto(IDownloadJob job) => new(
job.Id,
job.Model.Id,
job.Name,
job.Version,
job.State.ToString(),
job.Progress,
job.StatusText,
job.DetailText,
job.Error,
job.IsActive,
job.CanRetry,
job.IsDone);
ModelSource? ResolveSource(string? sourceId)
{
var sources = services.Settings.Current.Sources;
if (!string.IsNullOrWhiteSpace(sourceId))
{
var exact = sources.FirstOrDefault(s =>
s.Id.Equals(sourceId, StringComparison.OrdinalIgnoreCase));
if (exact != null) return exact;
}
return sources.FirstOrDefault(s => s.Enabled && !string.IsNullOrWhiteSpace(s.Url))
?? sources.FirstOrDefault();
}
IResult ActOnJob(string id, Action<IDownloadJob> action)
{
var job = services.Downloads.Jobs.FirstOrDefault(j =>
j.Id.Equals(id, StringComparison.OrdinalIgnoreCase));
if (job == null) return Results.NotFound(new LaunchResultDto(false, $"没有找到任务 {id}"));
action(job);
return Results.Ok(ToJobDto(job));
}
bool IsInsideKnownRoot(string path)
{
try
{
var full = Path.GetFullPath(path);
var roots = new[]
{
services.Paths.ModelRoot,
services.Paths.DataRoot,
services.Paths.HomeRoot,
services.Paths.AppRoot
};
foreach (var root in roots)
{
if (string.IsNullOrWhiteSpace(root)) continue;
var rootFull = Path.GetFullPath(root);
if (full.Equals(rootFull, StringComparison.OrdinalIgnoreCase)) return true;
if (full.StartsWith(rootFull + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase))
return true;
}
}
catch
{
return false;
}
return false;
}
+3
View File
@@ -15,6 +15,9 @@ migration:
- platform: root
create_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668
base_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668
- platform: linux
create_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668
base_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668
- platform: macos
create_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668
base_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668
+64 -9
View File
@@ -1,4 +1,5 @@
import 'dart:convert';
import 'dart:io';
import 'package:http/http.dart' as http;
@@ -152,6 +153,7 @@ class SettingsInfo {
SettingsInfo.fromJson(Map<String, dynamic> json)
: language = json['language'] as String? ?? 'auto',
theme = json['theme'] as String? ?? 'light',
accentColor = json['accentColor'] as String? ?? '#8FB6FF',
renderFps = (json['renderFps'] as num?)?.toInt() ?? 120,
memoryMb = (json['memoryMb'] as num?)?.toInt() ?? 2048,
memoryAuto = json['memoryAuto'] as bool? ?? true,
@@ -176,6 +178,7 @@ class SettingsInfo {
final String language;
final String theme;
final String accentColor;
final int renderFps;
final int memoryMb;
final bool memoryAuto;
@@ -200,6 +203,7 @@ class SettingsPatch {
const SettingsPatch({
this.language,
this.theme,
this.accentColor,
this.renderFps,
this.memoryMb,
this.memoryAuto,
@@ -212,6 +216,7 @@ class SettingsPatch {
final String? language;
final String? theme;
final String? accentColor;
final int? renderFps;
final int? memoryMb;
final bool? memoryAuto;
@@ -225,6 +230,7 @@ class SettingsPatch {
final map = <String, dynamic>{};
if (language != null) map['language'] = language;
if (theme != null) map['theme'] = theme;
if (accentColor != null) map['accentColor'] = accentColor;
if (renderFps != null) map['renderFps'] = renderFps;
if (memoryMb != null) map['memoryMb'] = memoryMb;
if (memoryAuto != null) map['memoryAuto'] = memoryAuto;
@@ -329,16 +335,65 @@ List<String> _stringList(dynamic value) =>
/// GC-UI 后端客户端。
///
/// 后端是本地伴随进程,默认监听 127.0.0.1:17890;端口可用
/// `--dart-define=GC_UI_BASE_URL=http://127.0.0.1:12345` 覆盖。
/// 后端是本地伴随进程,端口由启动器(GC-BOOT)选定后通过 `GC_UI_PORT`
/// 环境变量传进来 —— 这样端口被占用时换端口不用重新编译前端。
/// 也可用 `--dart-define=GC_UI_BASE_URL=http://127.0.0.1:12345` 强制指定。
class GcApi {
GcApi({String? baseUrl})
: baseUrl = baseUrl ?? defaultBaseUrl;
static const String defaultBaseUrl = String.fromEnvironment(
'GC_UI_BASE_URL',
defaultValue: 'http://127.0.0.1:17890',
);
/// 复用同一个 HTTP 连接:轮询(下载任务每秒一次)时每次都新建连接
/// 会不断握手,桌面端也能明显看到延迟抖动。
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;
@@ -352,17 +407,17 @@ class GcApi {
try {
switch (method) {
case 'GET':
response = await http.get(uri).timeout(const Duration(seconds: 30));
response = await _client.get(uri).timeout(const Duration(seconds: 30));
break;
case 'POST':
response = await http
response = await _client
.post(uri,
headers: const {'Content-Type': 'application/json'},
body: body == null ? null : jsonEncode(body))
.timeout(const Duration(seconds: 120));
break;
case 'DELETE':
response = await http.delete(uri).timeout(const Duration(seconds: 30));
response = await _client.delete(uri).timeout(const Duration(seconds: 30));
break;
default:
throw ApiException('不支持的方法 $method');
+82 -9
View File
@@ -1,7 +1,10 @@
import 'dart:async';
import 'package:flutter/foundation.dart';
import 'api_client.dart';
import 'i18n.dart';
import 'theme.dart';
/// 外壳状态:后端客户端 + 设置 + 健康状态 + 更新状态条。
///
@@ -23,31 +26,94 @@ class ShellController extends ChangeNotifier {
String updateDetail = '';
String launcherNotice = '';
/// 模型库版本号:安装 / 删除 / 下载完成后自增,首页据此重新拉列表。
///
/// 首页被 `Offstage` 保活,切走再切回不会重建;没有这个信号时,
/// 下载完模型回到首页仍然显示旧的空列表。
int modelsRevision = 0;
Timer? _retryTimer;
int _retryAttempt = 0;
bool get backendReady => settings != null;
Future<void> bootstrap() async {
try {
health = await api.health();
settings = await api.settings();
loadError = null;
I18n.setLanguage(settings!.language);
} catch (error) {
loadError = error.toString();
_retryTimer?.cancel();
HealthInfo? healthResult;
SettingsInfo? settingsResult;
Object? firstError;
// 两个请求互不依赖,并行发;各自捕获异常,避免一方失败时
// 另一个的 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();
}
/// 后端没起来时自动重试(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) {
if (index == value) return;
index = value;
notifyListeners();
}
/// 模型库有变化(安装 / 删除 / 下载完成):通知首页刷新。
void modelsChanged() {
modelsRevision++;
notifyListeners();
}
Future<void> reloadSettings() async {
try {
settings = await api.settings();
loadError = null;
I18n.setLanguage(settings!.language);
_applySettings(settings!);
} catch (error) {
loadError = error.toString();
}
@@ -58,7 +124,7 @@ class ShellController extends ChangeNotifier {
try {
settings = await api.saveSettings(patch);
loadError = null;
I18n.setLanguage(settings!.language);
_applySettings(settings!);
} catch (error) {
loadError = error.toString();
}
@@ -103,6 +169,7 @@ class ShellController extends ChangeNotifier {
detail: result.error ?? '',
notice: result.launcherMessage ?? '',
);
if (result.updatedModels > 0) modelsChanged();
} catch (error) {
setUpdateStatus(
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.installed': '已安装模型',
'home.count': '{0} 个模型',
'home.noDescription': '暂无简介',
'home.empty': '模型库还是空的',
'home.emptyHint': '启动时会自动检查并下载模型。若当前断网:可把模型文件夹放进 .GC/model/ 后重新打开,或联网后在「下载」页点重试。',
'home.emptyAction': '去下载模型',
@@ -62,6 +63,17 @@ class I18n {
'set.title': '设置',
'set.subtitle': '模型源、启动时内存分配与本地存储。',
'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.auto': '跟随系统',
'set.fps': '渲染帧率',
@@ -117,6 +129,7 @@ class I18n {
'common.error': '出错了',
'common.refresh': '刷新',
'about.developers': '开发者',
'about.contributorsHint': '来自仓库提交记录',
'about.repository': '仓库',
'about.openRepository': '打开仓库',
'about.contributions': '{0} 次提交',
@@ -140,6 +153,7 @@ class I18n {
'home.settings': 'Settings',
'home.installed': 'Installed models',
'home.count': '{0} models',
'home.noDescription': 'No description',
'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.emptyAction': 'Get models',
@@ -179,6 +193,17 @@ class I18n {
'set.title': 'Settings',
'set.subtitle': 'Model sources, startup memory allocation and local storage.',
'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.auto': 'System',
'set.fps': 'Render frame rate',
@@ -234,6 +259,7 @@ class I18n {
'common.error': 'Something went wrong',
'common.refresh': 'Refresh',
'about.developers': 'Developers',
'about.contributorsHint': 'From repository commits',
'about.repository': 'Repository',
'about.openRepository': 'Open repository',
'about.contributions': '{0} commits',
+33 -6
View File
@@ -6,10 +6,13 @@ import 'shell.dart';
import 'theme.dart';
void main() {
// 桌面端无需异步初始化外部插件:尽早绑定并直接渲染首帧,
// 让窗口在引擎就绪后立刻出现,后端探测在外壳里异步进行。
WidgetsFlutterBinding.ensureInitialized();
runApp(const GcUiApp());
}
/// GC-UI 前端:Flutter 桌面应用(Windows / macOS)。
/// GC-UI 前端:Flutter 桌面应用(Windows / macOS / Linux)。
///
/// 界面全部在这里;模型扫描、下载、更新、设置、模型窗口宿主都在后端
/// (GC-UI/backend/GC.UI.Server,本地 HTTP 服务)。
@@ -25,14 +28,38 @@ class _GcUiAppState extends State<GcUiApp> {
@override
Widget build(BuildContext context) {
// 语言、强调色、主题模式都会触发重建:只重建 MaterialApp 的主题层,
// 不触碰页面状态(页面由 ShellPage 自己持有)。
return ValueListenableBuilder<String>(
valueListenable: I18n.language,
builder: (context, language, _) {
return MaterialApp(
title: 'Morris GC',
debugShowCheckedModeBanner: false,
theme: buildGcTheme(),
home: ShellPage(controller: _controller),
return ValueListenableBuilder<Color>(
valueListenable: GcPalette.accent,
builder: (context, accent, _) {
return ValueListenableBuilder<ThemeMode>(
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;
String? _error;
String? _notice;
int _lastRevision = 0;
@override
void initState() {
super.initState();
widget.controller.addListener(_onControllerChanged);
_lastRevision = widget.controller.modelsRevision;
final preset = widget.initialModels;
if (preset != null) {
_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 {
setState(() {
_loading = true;
@@ -128,7 +148,7 @@ class _HomePageViewState extends State<HomePageView> {
Expanded(
child: Text(
T('home.installed'),
style: const TextStyle(
style: TextStyle(
fontSize: 15,
fontWeight: FontWeight.w600,
color: GcColors.ink,
@@ -151,7 +171,7 @@ class _HomePageViewState extends State<HomePageView> {
padding: const EdgeInsets.all(12),
child: Text(
_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,
children: <Widget>[
Text(T('common.error'),
style: const TextStyle(color: GcColors.danger)),
style: TextStyle(color: GcColors.danger)),
const SizedBox(height: 8),
GcHint(_error!),
],
@@ -314,7 +334,7 @@ class _HomePageViewState extends State<HomePageView> {
children: <Widget>[
Text(
T('home.empty'),
style: const TextStyle(
style: TextStyle(
fontSize: 15,
fontWeight: FontWeight.w600,
color: GcColors.ink,
@@ -326,7 +346,7 @@ class _HomePageViewState extends State<HomePageView> {
child: Text(
T('home.emptyHint'),
textAlign: TextAlign.center,
style: const TextStyle(
style: TextStyle(
fontSize: 12,
color: GcColors.faint,
height: 1.5,
@@ -344,7 +364,7 @@ class _HomePageViewState extends State<HomePageView> {
}
}
class _ModelCard extends StatelessWidget {
class _ModelCard extends StatefulWidget {
const _ModelCard({
required this.model,
required this.previewUrl,
@@ -359,110 +379,249 @@ class _ModelCard extends StatelessWidget {
final VoidCallback onOpenFolder;
final VoidCallback onDelete;
@override
State<_ModelCard> createState() => _ModelCardState();
}
class _ModelCardState extends State<_ModelCard> {
bool _hover = false;
@override
Widget build(BuildContext context) {
return SizedBox(
width: 336,
child: GcCard(
padding: EdgeInsets.zero,
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
ClipRRect(
borderRadius: const BorderRadius.vertical(top: Radius.circular(13)),
child: SizedBox(
height: 138,
width: double.infinity,
child: Container(
color: const Color(0xFF0B1226),
child: model.hasPreview
? Image.network(
previewUrl,
fit: BoxFit.cover,
errorBuilder: (context, error, stack) =>
const _PreviewFallback(),
)
: const _PreviewFallback(),
),
),
final model = widget.model;
return MouseRegion(
onEnter: (_) => setState(() => _hover = true),
onExit: (_) => setState(() => _hover = false),
cursor: SystemMouseCursors.click,
child: AnimatedContainer(
duration: const Duration(milliseconds: 160),
curve: Curves.easeOut,
width: 336,
transform: Matrix4.translationValues(0, _hover ? -3 : 0, 0),
decoration: BoxDecoration(
borderRadius: BorderRadius.circular(16),
boxShadow: <BoxShadow>[
BoxShadow(
color: Colors.black.withOpacity(_hover ? 0.42 : 0.22),
blurRadius: _hover ? 26 : 14,
offset: Offset(0, _hover ? 10 : 6),
),
Padding(
padding: const EdgeInsets.fromLTRB(16, 13, 16, 15),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
Row(
],
),
child: GcCard(
padding: EdgeInsets.zero,
child: Column(
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>[
Expanded(
child: Text(
model.name,
overflow: TextOverflow.ellipsis,
style: const TextStyle(
fontSize: 14,
fontWeight: FontWeight.w600,
color: GcColors.ink,
Container(
color: const Color(0xFF0B1226),
child: model.hasPreview
? Image.network(
widget.previewUrl,
fit: BoxFit.cover,
// 只按展示尺寸解码,避免大图占用内存、拖慢首帧。
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),
Text(
model.metaText,
style: const TextStyle(
fontSize: 10.5,
color: GcColors.faint,
Positioned(
left: 14,
right: 14,
bottom: 11,
child: Row(
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,
child: Text(
model.description,
maxLines: 2,
overflow: TextOverflow.ellipsis,
style: const TextStyle(
fontSize: 12,
color: GcColors.muted,
height: 1.4,
),
),
Padding(
padding: const EdgeInsets.fromLTRB(16, 13, 16, 15),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
Row(
children: <Widget>[
Expanded(
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>[
const SizedBox(height: 6),
Text(
model.tags.join(' · '),
style: const TextStyle(
fontSize: 10.5,
color: GcColors.faint,
if (model.tags.isNotEmpty) ...<Widget>[
const SizedBox(height: 8),
Wrap(
spacing: 6,
runSpacing: 4,
children: <Widget>[
for (final tag in model.tags.take(3))
_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();
@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(
'◎',
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;
Timer? _poll;
/// 页面是否可见(被切走后仍保活,但没必要继续请求后端)。
bool _visible = true;
/// 上一次轮询时是否有活跃任务,用来判断「刚刚全部结束」。
bool _hadActive = false;
@override
void initState() {
super.initState();
@@ -527,7 +703,14 @@ class _DownloadPageViewState extends State<DownloadPageView> {
return;
}
_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
@@ -536,6 +719,35 @@ class _DownloadPageViewState extends State<DownloadPageView> {
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 {
setState(() {
_loading = true;
@@ -668,7 +880,7 @@ class _DownloadPageViewState extends State<DownloadPageView> {
Expanded(
child: Text(
source.name,
style: const TextStyle(
style: TextStyle(
fontSize: 12.5,
fontWeight: FontWeight.w600,
color: GcColors.ink,
@@ -676,7 +888,7 @@ class _DownloadPageViewState extends State<DownloadPageView> {
),
),
if (!source.enabled)
const Text(
Text(
'off',
style: TextStyle(
fontSize: 10, color: GcColors.faint),
@@ -686,7 +898,7 @@ class _DownloadPageViewState extends State<DownloadPageView> {
const SizedBox(height: 2),
Text(
source.host,
style: const TextStyle(
style: TextStyle(
fontSize: 10.5, color: GcColors.faint),
),
],
@@ -717,7 +929,7 @@ class _DownloadPageViewState extends State<DownloadPageView> {
Expanded(
child: Text(
T('dl.available'),
style: const TextStyle(
style: TextStyle(
fontSize: 15,
fontWeight: FontWeight.w600,
color: GcColors.ink,
@@ -746,7 +958,7 @@ class _DownloadPageViewState extends State<DownloadPageView> {
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
Text(T('common.error'),
style: const TextStyle(color: GcColors.danger)),
style: TextStyle(color: GcColors.danger)),
const SizedBox(height: 8),
GcHint(_error!),
],
@@ -758,7 +970,7 @@ class _DownloadPageViewState extends State<DownloadPageView> {
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
Text(T('dl.empty'),
style: const TextStyle(color: GcColors.ink)),
style: TextStyle(color: GcColors.ink)),
const SizedBox(height: 8),
GcHint(T('dl.emptyHint')),
],
@@ -780,7 +992,7 @@ class _DownloadPageViewState extends State<DownloadPageView> {
children: <Widget>[
Text(
model.name,
style: const TextStyle(
style: TextStyle(
fontSize: 13,
fontWeight: FontWeight.w600,
color: GcColors.ink,
@@ -789,7 +1001,7 @@ class _DownloadPageViewState extends State<DownloadPageView> {
const SizedBox(width: 8),
Text(
'v${model.version} · ${model.sizeText}',
style: const TextStyle(
style: TextStyle(
fontSize: 10.5,
color: GcColors.faint),
),
@@ -806,7 +1018,7 @@ class _DownloadPageViewState extends State<DownloadPageView> {
),
child: Text(
T('dl.installed'),
style: const TextStyle(
style: TextStyle(
fontSize: 10,
color: GcColors.ok),
),
@@ -819,7 +1031,7 @@ class _DownloadPageViewState extends State<DownloadPageView> {
model.description,
maxLines: 2,
overflow: TextOverflow.ellipsis,
style: const TextStyle(
style: TextStyle(
fontSize: 11.5,
color: GcColors.muted,
height: 1.4,
@@ -882,7 +1094,7 @@ class _DownloadPageViewState extends State<DownloadPageView> {
Expanded(
child: Text(
'${job.name} v${job.version}',
style: const TextStyle(
style: TextStyle(
fontSize: 12.5,
fontWeight: FontWeight.w600,
color: GcColors.ink,
@@ -929,7 +1141,7 @@ class _DownloadPageViewState extends State<DownloadPageView> {
const SizedBox(height: 4),
Text(
job.error ?? job.detailText,
style: const TextStyle(
style: TextStyle(
fontSize: 10.5, color: GcColors.faint),
),
],
@@ -977,7 +1189,11 @@ class _SettingsPageViewState extends State<SettingsPageView> {
int _fps = 120;
bool _autoUpdate = true;
String _language = 'auto';
bool _synced = false;
ThemeMode _themeMode = ThemeMode.dark;
/// 上一次同步所用的设置对象。以前用的是 `bool _synced` —— 只同步一次,
/// 之后外部(更新状态条、其它页面)改了设置,本页仍显示旧值。
SettingsInfo? _syncedFrom;
String? _status;
@override
@@ -987,13 +1203,14 @@ class _SettingsPageViewState extends State<SettingsPageView> {
}
void _syncFrom(SettingsInfo settings) {
if (_synced) return;
if (identical(_syncedFrom, settings)) return;
_syncedFrom = settings;
_memory = settings.memoryMb.toDouble();
_memoryAuto = settings.memoryAuto;
_fps = settings.renderFps;
_autoUpdate = settings.autoUpdateOnStartup;
_language = settings.language;
_synced = true;
_themeMode = GcPalette.parseMode(settings.theme);
}
@override
@@ -1009,7 +1226,7 @@ class _SettingsPageViewState extends State<SettingsPageView> {
children: <Widget>[
Text(
T('set.title'),
style: const TextStyle(
style: TextStyle(
fontSize: 20,
fontWeight: FontWeight.w700,
color: GcColors.ink,
@@ -1020,6 +1237,8 @@ class _SettingsPageViewState extends State<SettingsPageView> {
const SizedBox(height: 18),
_generalCard(settings),
const SizedBox(height: 16),
_appearanceCard(settings),
const SizedBox(height: 16),
_memoryCard(settings),
const SizedBox(height: 16),
_sourcesCard(settings),
@@ -1047,7 +1266,7 @@ class _SettingsPageViewState extends State<SettingsPageView> {
Row(
children: <Widget>[
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>(
value: _language,
dropdownColor: GcColors.surfaceAlt,
@@ -1076,7 +1295,7 @@ class _SettingsPageViewState extends State<SettingsPageView> {
Row(
children: <Widget>[
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(
child: Slider(
value: _fps.toDouble(),
@@ -1095,7 +1314,7 @@ class _SettingsPageViewState extends State<SettingsPageView> {
SizedBox(
width: 46,
child: Text('$_fps',
style: const TextStyle(
style: TextStyle(
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) {
return GcCard(
child: Column(
@@ -1129,7 +1523,7 @@ class _SettingsPageViewState extends State<SettingsPageView> {
Expanded(
child: Text(
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,
child: Text(
'${_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>[
Text(
'${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>[
Text(
source.name,
style: const TextStyle(
style: TextStyle(
fontSize: 12.5,
fontWeight: FontWeight.w600,
color: GcColors.ink,
@@ -1208,7 +1602,7 @@ class _SettingsPageViewState extends State<SettingsPageView> {
const SizedBox(height: 2),
Text(
source.url,
style: const TextStyle(
style: TextStyle(
fontSize: 10.5, color: GcColors.faint),
),
],
@@ -1216,7 +1610,7 @@ class _SettingsPageViewState extends State<SettingsPageView> {
),
Text(
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(
width: 160,
child: Text(label,
style: const TextStyle(fontSize: 12.5, color: GcColors.muted)),
style: TextStyle(fontSize: 12.5, color: GcColors.muted)),
),
Expanded(
child: SelectableText(
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(
child: Text(
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>[
Text(
T('nav.about'),
style: const TextStyle(
style: TextStyle(
fontSize: 20,
fontWeight: FontWeight.w700,
color: GcColors.ink,
@@ -1432,7 +1826,7 @@ class _AboutPageViewState extends State<AboutPageView> {
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
Text(T('common.error'),
style: const TextStyle(color: GcColors.danger)),
style: TextStyle(color: GcColors.danger)),
const SizedBox(height: 8),
GcHint(_error!),
const SizedBox(height: 12),
@@ -1450,7 +1844,7 @@ class _AboutPageViewState extends State<AboutPageView> {
children: <Widget>[
Text(
_about?.appName ?? 'Morris GC',
style: const TextStyle(
style: TextStyle(
fontSize: 18,
fontWeight: FontWeight.w700,
color: GcColors.ink,
@@ -1491,7 +1885,10 @@ class _AboutPageViewState extends State<AboutPageView> {
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
GcSectionTitle(T('about.developers')),
GcSectionTitle(
T('about.developers'),
trailing: GcHint(T('about.contributorsHint')),
),
const SizedBox(height: 12),
if ((_about?.contributors ?? const <ContributorInfo>[]).isEmpty)
GcHint(T('about.noContributors'))
@@ -1508,7 +1905,7 @@ class _AboutPageViewState extends State<AboutPageView> {
? null
: NetworkImage(contributor.avatarUrl!),
child: contributor.avatarUrl == null
? const Text('◎',
? Text('◎',
style: TextStyle(
fontSize: 12, color: GcColors.accent))
: null,
@@ -1517,7 +1914,7 @@ class _AboutPageViewState extends State<AboutPageView> {
Expanded(
child: Text(
contributor.name,
style: const TextStyle(
style: TextStyle(
fontSize: 12.5,
fontWeight: FontWeight.w600,
color: GcColors.ink,
@@ -1527,7 +1924,7 @@ class _AboutPageViewState extends State<AboutPageView> {
Text(
T('about.contributions',
<Object?>[contributor.contributions]),
style: const TextStyle(
style: TextStyle(
fontSize: 11, color: GcColors.faint),
),
],
@@ -1548,12 +1945,12 @@ class _AboutPageViewState extends State<AboutPageView> {
SizedBox(
width: 160,
child: Text(label,
style: const TextStyle(fontSize: 12.5, color: GcColors.muted)),
style: TextStyle(fontSize: 12.5, color: GcColors.muted)),
),
Expanded(
child: SelectableText(
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> {
/// 页面缓存:键为「索引:语言」。同一个页面只构建一次,切走时用
/// [Offstage] 保活(不参与布局/绘制),切回来无需重建、状态也不丢。
final Map<String, Widget> _pages = <String, Widget>{};
@override
void 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:
return DownloadPageView(controller: controller);
case 2:
@@ -116,13 +140,13 @@ class _Sidebar extends StatelessWidget {
borderRadius: BorderRadius.circular(8),
),
alignment: Alignment.center,
child: const Text(
child: Text(
'◎',
style: TextStyle(fontSize: 14, color: GcColors.accent),
),
),
const SizedBox(width: 10),
const Expanded(
Expanded(
child: Text(
'Morris GC',
style: TextStyle(
@@ -162,7 +186,7 @@ class _Sidebar extends StatelessWidget {
padding: const EdgeInsets.only(left: 14),
child: Text(
'v${settings?.version ?? '—'}',
style: const TextStyle(fontSize: 10.5, color: GcColors.faint),
style: TextStyle(fontSize: 10.5, color: GcColors.faint),
),
),
Padding(
@@ -234,14 +258,15 @@ class _UpdateBar extends StatelessWidget {
@override
Widget build(BuildContext context) {
return Container(
decoration: const BoxDecoration(
decoration: BoxDecoration(
color: GcColors.surface,
border: Border(top: BorderSide(color: GcColors.line)),
),
padding: const EdgeInsets.symmetric(horizontal: 20, vertical: 9),
child: Row(
children: <Widget>[
const Text('⟳', style: TextStyle(fontSize: 16, color: GcColors.accent)),
Text('⟳',
style: TextStyle(fontSize: 16, color: GcColors.accent)),
const SizedBox(width: 12),
Expanded(
child: Column(
@@ -249,7 +274,7 @@ class _UpdateBar extends StatelessWidget {
children: <Widget>[
Text(
controller.updateStatus,
style: const TextStyle(
style: TextStyle(
fontSize: 12.5,
fontWeight: FontWeight.w600,
color: GcColors.ink,
@@ -259,13 +284,13 @@ class _UpdateBar extends StatelessWidget {
if (controller.updateDetail.isNotEmpty)
Text(
controller.updateDetail,
style: const TextStyle(fontSize: 11, color: GcColors.faint),
style: TextStyle(fontSize: 11, color: GcColors.faint),
overflow: TextOverflow.ellipsis,
),
if (controller.launcherNotice.isNotEmpty)
Text(
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>[
Text(
T('common.error'),
style: const TextStyle(
style: TextStyle(
fontSize: 17,
fontWeight: FontWeight.w600,
color: GcColors.ink,
+182 -43
View File
@@ -1,71 +1,210 @@
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 {
GcColors._();
static const Color appBg = Color(0xFF0A1226);
static const Color sideBg = Color(0xFF0C1529);
static const Color surface = Color(0xFF111C33);
static const Color surfaceAlt = Color(0xFF16233C);
static const Color line = Color(0xFF1B2740);
static const Color accent = Color(0xFF8FB6FF);
static const Color accentStrong = Color(0xFF4C7DFF);
static const Color ink = Color(0xFFF2F6FF);
static const Color muted = Color(0xFFA9B8D4);
static const Color faint = Color(0xFF7C90B4);
static const Color warn = Color(0xFFFFC46B);
static const Color danger = Color(0xFFFF7A7A);
static const Color ok = Color(0xFF6BE3A2);
static bool _dark = true;
static bool get isDark => _dark;
/// 由 `MaterialApp.builder` 在每次构建前按实际亮度绑定。
static void bind(Brightness brightness) => _dark = brightness == Brightness.dark;
static Color _pick(int dark, int light) => Color(_dark ? dark : light);
static Color get appBg => _pick(0xFF0A1226, 0xFFF3F6FB);
static Color get sideBg => _pick(0xFF0C1529, 0xFFFFFFFF);
static Color get surface => _pick(0xFF111C33, 0xFFFFFFFF);
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(
scaffoldBackgroundColor: GcColors.appBg,
scaffoldBackgroundColor: appBg,
colorScheme: base.colorScheme.copyWith(
primary: GcColors.accentStrong,
secondary: GcColors.accent,
surface: GcColors.surface,
error: GcColors.danger,
brightness: brightness,
primary: accentStrong,
secondary: accent,
surface: surface,
error: danger,
),
textTheme: base.textTheme.apply(
bodyColor: GcColors.ink,
displayColor: GcColors.ink,
bodyColor: ink,
displayColor: ink,
),
dividerColor: GcColors.line,
cardTheme: const CardTheme(
color: GcColors.surface,
dividerColor: line,
cardTheme: CardTheme(
color: surface,
elevation: 0,
margin: EdgeInsets.zero,
),
sliderTheme: base.sliderTheme.copyWith(
activeTrackColor: GcColors.accentStrong,
thumbColor: GcColors.accent,
inactiveTrackColor: GcColors.line,
activeTrackColor: accentStrong,
thumbColor: accent,
inactiveTrackColor: line,
),
switchTheme: SwitchThemeData(
thumbColor: WidgetStateProperty.resolveWith(
(states) => states.contains(WidgetState.selected)
? GcColors.accent
: GcColors.faint,
(states) => states.contains(WidgetState.selected) ? accent : GcColors.faint,
),
trackColor: WidgetStateProperty.resolveWith(
(states) => states.contains(WidgetState.selected)
? GcColors.accentStrong.withOpacity(0.45)
: GcColors.line,
? accentStrong.withOpacity(0.45)
: line,
),
),
progressIndicatorTheme: const ProgressIndicatorThemeData(
color: GcColors.accent,
linearTrackColor: GcColors.line,
progressIndicatorTheme: ProgressIndicatorThemeData(
color: accent,
linearTrackColor: line,
),
tooltipTheme: const TooltipThemeData(
tooltipTheme: TooltipThemeData(
decoration: BoxDecoration(
color: GcColors.surfaceAlt,
borderRadius: BorderRadius.all(Radius.circular(6)),
color: surfaceAlt,
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(
child: Text(
text,
style: const TextStyle(
style: TextStyle(
fontSize: 15,
fontWeight: FontWeight.w600,
color: GcColors.ink,
@@ -129,6 +268,6 @@ class GcHint extends StatelessWidget {
@override
Widget build(BuildContext context) => 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.
// 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
PRODUCT_BUNDLE_IDENTIFIER = com.morris.gc.gcUi
// 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 {
await tester.pumpWidget(
MaterialApp(
theme: buildGcTheme(),
theme: buildGcTheme(Brightness.dark),
home: const Scaffold(
body: GcCard(child: Text('hello')),
),
+27 -3
View File
@@ -123,17 +123,21 @@ void main() {
'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.devicePixelRatio = 1.0;
addTearDown(tester.view.reset);
// GcColors 是静态取值,截图前先按目标亮度绑定,否则浅色截图仍是深色配色。
GcColors.bind(brightness);
final key = GlobalKey();
await tester.pumpWidget(
MaterialApp(
debugShowCheckedModeBanner: false,
theme: buildGcTheme().copyWith(
textTheme: buildGcTheme().textTheme.apply(
theme: buildGcTheme(brightness).copyWith(
textTheme: buildGcTheme(brightness).textTheme.apply(
fontFamily: 'Noto Sans CJK SC',
),
),
@@ -290,4 +294,24 @@ void main() {
I18n.language.value = 'zh-CN';
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 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
# versions of CMake.
+6 -6
View File
@@ -89,13 +89,13 @@ BEGIN
BEGIN
BLOCK "040904e4"
BEGIN
VALUE "CompanyName", "com.morris.gc" "\0"
VALUE "FileDescription", "gc_ui" "\0"
VALUE "CompanyName", "Morris" "\0"
VALUE "FileDescription", "GC UI" "\0"
VALUE "FileVersion", VERSION_AS_STRING "\0"
VALUE "InternalName", "gc_ui" "\0"
VALUE "LegalCopyright", "Copyright (C) 2026 com.morris.gc. All rights reserved." "\0"
VALUE "OriginalFilename", "gc_ui.exe" "\0"
VALUE "ProductName", "gc_ui" "\0"
VALUE "InternalName", "GC-UI" "\0"
VALUE "LegalCopyright", "Copyright (C) 2026 Morris. All rights reserved." "\0"
VALUE "OriginalFilename", "GC-UI.exe" "\0"
VALUE "ProductName", "Morris GC" "\0"
VALUE "ProductVersion", VERSION_AS_STRING "\0"
END
END
+1 -1
View File
@@ -27,7 +27,7 @@ int APIENTRY wWinMain(_In_ HINSTANCE instance, _In_opt_ HINSTANCE prev,
FlutterWindow window(project);
Win32Window::Point origin(10, 10);
Win32Window::Size size(1280, 720);
if (!window.Create(L"gc_ui", origin, size)) {
if (!window.Create(L"Morris GC", origin, size)) {
return EXIT_FAILURE;
}
window.SetQuitOnClose(true);
+5 -2
View File
@@ -13,6 +13,9 @@ public sealed class AppSettings
/// <summary>light | dark</summary>
public string Theme { get; set; } = "light";
/// <summary>主题强调色(#RRGGBB),由设置页自定义并持久化。</summary>
public string AccentColor { get; set; } = "#8FB6FF";
/// <summary>渲染帧率:24 / 30 / 60 / 90 / 120(上限 120,关闭 VSync 同步)</summary>
public int RenderFps { get; set; } = 120;
@@ -37,8 +40,8 @@ public sealed class AppSettings
/// <summary>启动时检查模型 / 启动器是否为最新版。</summary>
public bool AutoUpdateOnStartup { get; set; } = true;
/// <summary>默认更新仓库地址。</summary>
public string UpdateRepository { get; set; } = "https://gitcode.com/Morris_1/GC";
/// <summary>默认更新仓库地址(暂时只使用 Xhmcl,GitCode 实现保留但不再调用)。</summary>
public string UpdateRepository { get; set; } = "https://git.xhmcl.com/Morris/GC";
/// <summary>版本清单地址覆盖(留空则按 UpdateRepository 拼接)。</summary>
public string? UpdateManifestUrl { get; set; }
+11 -2
View File
@@ -20,12 +20,21 @@ public static class SignatureKeyring
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(
"gc-2026-11",
"MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEny5YKVBZUzOyRcSiuutlGmBb4+xm" +
"PrNDGshilBlpmFyWu5Atq+FGP2tn+8Or8V7OH+/7lhCmXu8jZuC5/5CWSw==",
"GC 主发布密钥")
"已停用:私钥遗失")
};
static SignatureKeyring() => LoadFromEnvironment();
+13 -2
View File
@@ -8,12 +8,15 @@ namespace GC.Services;
/// 运行目录约定(可执行文件旁边,不内置任何模型):
/// <code>
/// &lt;安装目录&gt;/
/// GC(.exe | .app/...)
/// GCL(.exe | .app/...)
/// .GC/
/// settings.json 设置与已安装版本记录
/// bin/ 非本体文件(守护进程等,随包分发,更新时整目录替换)
/// config/ 设置与已安装版本记录(settings.json)
/// model/ 模型(启动时下载)
/// cache/ 下载缓存 / 原子替换暂存
/// update/ 待下次启动应用的启动器更新包
/// safedog/ 更新守护进程的运行副本(首次启动从 .GC/bin 复制过来)
/// logs/ 日志,按天分中英两份:gc-YYYYMMDD.log / .en.log
/// </code>
/// 开发态同样使用仓库根 .GC/model,并自动同步仓库 model/ 的可分发部分。
/// EMS_MODELS / EMS_DATA / EMS_HOME 可显式覆盖。
@@ -40,6 +43,12 @@ public sealed class AppPaths
public string CacheRoot => Path.Combine(HomeRoot, "cache");
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>
public string ConfigRoot => Path.Combine(HomeRoot, "config");
@@ -255,6 +264,8 @@ public sealed class AppPaths
Directory.CreateDirectory(CacheRoot);
Directory.CreateDirectory(ModelRoot);
Directory.CreateDirectory(UpdateRoot);
Directory.CreateDirectory(LogsRoot);
Directory.CreateDirectory(SafedogRoot);
MigrateLegacySettings();
+191 -46
View File
@@ -1,5 +1,6 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Text.Json;
using System.Threading;
@@ -7,50 +8,70 @@ using System.Threading.Tasks;
namespace GC.Services;
/// <summary>GitCode 仓库的一位贡献者。</summary>
/// <summary>仓库的一位贡献者(按人归并后的结果)。</summary>
public sealed class Contributor
{
public string Name { get; set; } = "";
public string? Email { get; set; }
/// <summary>提交次数(API 里的 contributions)。</summary>
/// <summary>提交次数。</summary>
public int Contributions { get; set; }
/// <summary>
/// 登录名 -> 展示名。GitCode 的 contributors 接口只返回账号登录名,
/// 不返回真实姓名,这里做一层映射,让关于页显示作者想展示的名字。
/// </summary>
private static readonly Dictionary<string, string> DisplayNames = new(StringComparer.OrdinalIgnoreCase)
{
["Morris_1"] = "Morris"
};
/// <summary>接口直接返回的头像地址(Gitea 的 avatar_url);为空时按邮箱哈希生成。</summary>
public string? Avatar { get; set; }
/// <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 =>
string.IsNullOrWhiteSpace(Email)
? null
: $"https://cdn-img.gitcode.com/avatar/{Convert.ToHexString(
System.Security.Cryptography.MD5.HashData(
System.Text.Encoding.UTF8.GetBytes(Email!.Trim().ToLowerInvariant())))
.ToLowerInvariant()}";
public string DisplayName
{
get
{
if (string.IsNullOrWhiteSpace(Name)) return "匿名";
return DisplayNames.TryGetValue(Name.Trim(), out var mapped) ? mapped : Name;
}
}
!string.IsNullOrWhiteSpace(Avatar)
? Avatar
: string.IsNullOrWhiteSpace(Email)
? null
: $"https://cdn-img.gitcode.com/avatar/{Convert.ToHexString(
System.Security.Cryptography.MD5.HashData(
System.Text.Encoding.UTF8.GetBytes(Email!.Trim().ToLowerInvariant())))
.ToLowerInvariant()}";
}
/// <summary>
/// 读取 GitCode 仓库的贡献者列表(用于「关于」页面展示开发者)。
/// 失败时静默返回空列表,不影响关于页其它内容。
/// 读取仓库的真实贡献者:翻页拉提交记录,按作者归并统计。
///
/// 为什么不用 /collaborators:Gitea 的协同者列表要求登录,且只包含被显式
/// 添加的协作者,和「谁真的写了代码」是两回事。这里直接读 /commits,
/// 统计每个人真实的提交数,失败时静默返回空列表,不影响关于页其它内容。
/// </summary>
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();
/// <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()
{
var c = new HttpClient { Timeout = TimeSpan.FromSeconds(10) };
@@ -59,48 +80,172 @@ public static class ContributorsService
return c;
}
/// <summary>默认仓库的 contributors 接口地址。</summary>
/// <summary>按仓库地址推导接口:Xhmcl(Gitea) 与 GitCode 结构不同。</summary>
public static string BuildUrl(string 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))
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);
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)
? 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)
{
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
{
using var timeout = CancellationTokenSource.CreateLinkedTokenSource(ct);
timeout.CancelAfter(TimeSpan.FromSeconds(10));
timeout.CancelAfter(TimeSpan.FromSeconds(15));
var text = await Http.GetStringAsync(url, timeout.Token);
var trimmed = text.TrimStart();
if (trimmed.Length == 0 || trimmed[0] != '[') return new List<Contributor>();
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;
list = url.Contains("api.gitcode.com", StringComparison.OrdinalIgnoreCase)
? await FetchFromGitCodeAsync(url, timeout.Token)
: await FetchFromCommitsAsync(url, timeout.Token);
}
catch (Exception ex)
{
Console.Error.WriteLine($"读取贡献者失败: {ex.Message}");
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
{
private static string? _versionOverride;
public static string CurrentLauncherVersion
{
get
@@ -155,3 +154,30 @@ public static class LauncherRuntimeInfo
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>
/// 本地模型库。启动器只**扫描 / 删除**模型包,不再解析或缓存任何场景数据 ——
/// 场景、贴图、界面都由模型自己的程序集负责。
///
/// 扫描结果与目录体积都做短时缓存:前端(首页 / 下载页)会频繁轮询
/// <c>/api/models</c>,而每个模型的体积要递归遍历整棵目录。没有缓存时
/// 一次刷新就是成千上万次 stat,低配机器上会明显卡顿。
/// </summary>
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 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;
@@ -20,7 +36,13 @@ public sealed class ModelRepository
public IReadOnlyList<ModelPackage> Scan()
{
lock (_gate)
{
if (_cache != null && DateTime.UtcNow - _cacheAt < ScanTtl) return _cache;
}
_paths.WaitForDevelopmentModels();
var result = new List<ModelPackage>();
foreach (var (manifest, dir) in ModelScanner.Scan(_paths.ModelRoot))
{
@@ -28,13 +50,20 @@ public sealed class ModelRepository
{
Manifest = manifest,
Directory = dir,
SizeBytes = ModelScanner.DirectorySize(dir)
SizeBytes = SizeOf(dir)
});
}
lock (_gate)
{
_cache = result;
_cacheAt = DateTime.UtcNow;
}
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)
{
@@ -43,6 +72,7 @@ public sealed class ModelRepository
try
{
Directory.Delete(package.Directory, true);
Invalidate();
Changed?.Invoke();
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);
private static readonly string[] VersionPrefixes =
{ "v", "V", "GC-", "gc-", "release-", "Release-" };
{ "v", "V", "GCL-", "gcl-", "GC-", "gc-", "release-", "Release-" };
private static readonly string[] PrereleaseTags =
{ "alpha", "beta", "rc", "pre", "dev", "snapshot" };
@@ -31,7 +31,7 @@ public sealed class ReleaseInfo
var raw = !string.IsNullOrWhiteSpace(tag) ? tag : name;
if (string.IsNullOrWhiteSpace(raw)) return "";
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)
if (raw.StartsWith(prefix, StringComparison.Ordinal)) { raw = raw[prefix.Length..]; break; }
// 形如 GC-1.0.1-Win-amd64 时只取版本段;但 2.3.0-beta 这类预发布串要保留完整。
+124
View File
@@ -0,0 +1,124 @@
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/bin</c> 里的守护进程复制到 <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/bin</c> 的守护进程同步到 <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)
{
// 包内非本体文件统一收在 .GC/bin;后面几项兼容 1.0.10 及更早的包布局
var candidates = new[]
{
Path.Combine(paths.HomeRoot, "bin", name),
Path.Combine(paths.InstallDirectory, ".GC", "bin", name),
Path.Combine(paths.InstallDirectory, "safedog", name),
Path.Combine(paths.InstallDirectory, name),
Path.Combine(paths.AppRoot, ".GC", "bin", 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()
{
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(
"2509_92447106", "Morris_1", StringComparison.OrdinalIgnoreCase);
Current.UpdateRepository = SourcePreset.Xhmcl.HomeUrl;
Save();
}
SeedDefaultSource();
@@ -29,12 +30,11 @@ public sealed class SettingsService
}
/// <summary>
/// 只允许两个内置源:Xhmcl 与 GitCode(同一份仓库的两个镜像)。
/// 不再支持用户自定义源 —— 每次加载都把 Sources 规整成这两条,
/// 老配置里的自定义源会被清理掉。
/// 当前只启用 Xhmcl 一个内置源。GitCode 的定义与下载实现保留在代码里,
/// 但不再参与测速 / 下载 / 更新;恢复时把 GitCode 加回 <see cref="SourcePreset.All"/> 即可。
/// </summary>
public const string DefaultSourceId = "gitcode";
public const string DefaultSourceUrl = "https://gitcode.com/Morris_1/GC";
public const string DefaultSourceId = "xhmcl";
public const string DefaultSourceUrl = "https://git.xhmcl.com/Morris/GC";
private void SeedDefaultSource()
{
+16 -9
View File
@@ -5,10 +5,11 @@ using System.Linq;
namespace GC.Services;
/// <summary>
/// 内置下载源。只允许这两个,不再支持用户自定义源。
/// 内置下载源。
///
/// 两个源的内容是同一份仓库(同一个 version.json、同一批模型),
/// 区别只是**托管在哪台服务器**上;启动时探测两者延迟,取快的那个下载。
/// 目前只启用 Xhmcl;GitCode 的 preset 与下载实现仍保留在代码中,
/// 但不参与测速 / 下载 / 更新。两个源本来指向同一份仓库内容,
/// 区别只是托管服务器;恢复双源时把 GitCode 加回 <see cref="All"/>。
/// </summary>
public sealed class SourcePreset
{
@@ -63,17 +64,23 @@ public sealed class SourcePreset
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) =>
All.FirstOrDefault(p => string.Equals(p.Id, id, StringComparison.OrdinalIgnoreCase));
/// <summary>把任意仓库地址映射到这两个内置源之一(用于兼容旧配置)。</summary>
/// <summary>把任意仓库地址映射到启用的内置源(用于兼容旧配置)。</summary>
public static SourcePreset Detect(string? url)
{
if (string.IsNullOrWhiteSpace(url)) return GitCode;
var u = url!.ToLowerInvariant();
if (u.Contains("xhmcl.com")) return Xhmcl;
return GitCode;
if (!string.IsNullOrWhiteSpace(url) &&
url!.Contains("xhmcl.com", StringComparison.OrdinalIgnoreCase))
return Xhmcl;
// 旧配置里的 GitCode 地址不再作为下载源,统一落到 Xhmcl。
return Xhmcl;
}
}
+11 -6
View File
@@ -193,7 +193,9 @@ internal static class Program
Console.WriteLine($"当前平台: {rid},启动器版本: {LauncherRuntimeInfo.CurrentLauncherVersion}");
var stage = Path.Combine(tmp, "launcher-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");
var zip = Path.Combine(tmp, "GC-" + rid + ".zip");
ZipFile.CreateFromDirectory(stage, zip);
@@ -207,7 +209,7 @@ internal static class Program
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");
var dl = Task.Run(() => LauncherUpdater.DownloadAsync(paths, updater.Remote, null))
@@ -227,7 +229,8 @@ internal static class Program
// 5) 校验标记文件与替换脚本(相对路径,无绝对路径)
var marker = Path.Combine(paths.UpdateRoot, "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,
OperatingSystem.IsWindows() ? "apply.bat" : "apply.sh");
Check(scheduled && File.Exists(scriptPath), "替换脚本可生成");
@@ -235,14 +238,14 @@ internal static class Program
{
var script = File.ReadAllText(scriptPath);
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/<系统>-<架构>/ 目录里。
// 清单不写 url、不写 path,只给 dir + name + sha256,客户端要能自己找过去。
var distDir = Path.Combine(remote, "dist", LauncherUpdater.PlatformLabel);
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);
File.Copy(zip, distZip, true);
@@ -310,8 +313,10 @@ internal static class Program
/// <summary>序列化清单并用私钥签名(测试里模拟一次正式发布)。</summary>
private static void WriteSigned(string path, RepoVersion version, ECDsa key)
{
// keyId 必须与 .signing/ 里的私钥对应的公钥条目一致,否则客户端按 keyId
// 查不到受信任公钥,会判成 Invalid 而不是 Verified。
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)
+62 -25
View File
@@ -11,8 +11,8 @@
- UI:C# + .NET 8(可切 .NET 10)+ Avalonia,跨平台
- 模型加载:`AssemblyLoadContext` 加载模型自带 dll,契约与 Avalonia 走默认上下文,关窗即卸载
- 目标平台:**macOS arm64 / Windows x64 / Windows arm64**(Linux 可自行编译,未列入发布矩阵)
- 更新仓库:<https://gitcode.com/Morris_1/GC>,模型目录 <https://gitcode.com/Morris_1/GC/tree/main/model>
- 目标平台:**Windows x64 / Windows arm64 / macOS arm64 / Linux x64**
- 更新仓库:<https://git.xhmcl.com/Morris/GC>,模型目录 <https://git.xhmcl.com/Morris/GC/src/branch/main/model>
## GC-UI:前后端分离版(Flutter 前端)
@@ -59,16 +59,36 @@ Windows 用 `.\build.ps1`,参数相同(`build / check / models / stamp / run
## 运行目录(发布包里就长这样)
```
<安装目录>/
GC.exe | GC.app/
GC-SAVEDOG[.exe] 更新守护进程(与主程序同目录,macOS 在 .app/Contents/MacOS 内)
.GC/
config/settings.json 用户设置(与缓存分开:删 cache 不会丢配置)
model/ 启动时下载的模型
cache/ 下载暂存 / 原子替换
update/ 待应用的启动器更新(apply-request.json + package.zip)
<解压出来的目录>/ ← 压缩包里只有这一个文件夹
GCL-<版本>-<平台>.exe 启动器(单文件:服务层 + 本地后端 + .NET 运行时都在里面)
GC-UI.exe Flutter 前端
flutter_windows.dll Flutter 引擎(引擎自带,不在 .NET 单文件里)
data/app.so, data/flutter_assets/ Flutter 资源与 AOT 快照
.GC/bin/GC-SAVEDOG[.exe] 非本体文件:更新守护进程
```
就这些,没有一屏 dll。安装目录根只放 GC 本体,非本体文件(守护进程)一律收在 `.GC/bin`。
macOS 是同一个单文件启动器,只是被放进 `GCL-<版本>-mac-arm64.app/Contents/MacOS/`,
Flutter 前端作为 `GC-UI.app` 放在同一层。
首次启动后 `.GC` 补齐成:
```
.GC/
bin/ 非本体文件(随包分发,更新时按文件替换)
config/settings.json 用户设置(与缓存分开:删 cache 不会丢配置)
model/ 启动时下载的模型
cache/ 下载暂存 / 原子替换
update/ 待应用的启动器更新(apply-request.json + package.zip)
safedog/GC-SAVEDOG[.exe] 守护进程的运行副本(首次启动从 .GC/bin 复制)
logs/gc-YYYYMMDD.log 日志(中文)
logs/gc-YYYYMMDD.en.log 日志(English)
```
`.GC` 紧挨着主程序,装在哪都便携 —— 整个目录复制走,模型、设置、日志跟着走。
守护进程「`.GC/bin` 放源、`.GC/safedog` 放运行副本」是因为更新要整目录替换:
正在运行的 exe 在 Windows 上换不掉,所以跑副本、换源文件,下次启动再同步。
**发布包不含任何模型**。首次启动联网检查后把模型下载到 `.GC/model/` 并立刻显示;
安装目录不可写时自动退回用户数据目录。`.GC/cache` 与 `.GC/model` 随时可删,程序会重新下载;
`.GC/config/settings.json` 删掉等于恢复出厂设置。
@@ -83,18 +103,23 @@ 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/update/backup,新文件就位
(.GC 只合并 bin/,config/model/cache/update/logs/safedog 原地不动)
-> 启动新版,等 .GC/update/health.json
-> 收到:删同平台旧版本,写 last-good.json
-> 没收到/进程退出:删新版、重启旧版,写 state.json = rolledback
-> 收到:删备份、写 last-good.json
-> 没收到/进程退出:撤掉新文件、把备份搬回、重启旧版,写 state.json = rolledback
```
发布包是**整目录**(启动器 + 后端运行时 + Flutter 前端资源),所以更新必须整目录替换:
只替换一个 exe 会留下旧后端 / 旧界面,新前端调不通接口。替换只动程序文件,
`.GC`(模型库、设置、日志、更新目录)和正在运行的 `GC-SAVEDOG.exe` 一律跳过。
也就是说:**新版本起不来,用户不会被卡死**。找不到 `GC-SAVEDOG` 的旧安装会退回脚本流程(过渡用)。
- 默认更新仓库写在 `.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`、下载失败:**一律保留本地模型,绝不清空模型库**,底部状态条说明原因
- 首次启动断网且本地无模型:状态条会明确提示「去下载页重试 / 手动放入 `.GC/model/`」,不会白屏干等
- 离线教室:把仓库(含 `version.json` + `model/`)拷到 U 盘,在 `settings.json` 填
@@ -135,12 +160,23 @@ Windows 用 `.\build.ps1`,参数相同(`build / check / models / stamp / run
### 签名密钥
- 私钥:`.signing/gc-signing.pem`(**已在 `.gitignore`,永不入库**;请自行备份)
- 公钥:硬编码在 `GC/src/Security/SignatureKeyring.cs`,指纹 `b41b1dd6259ea9ed`
- 生成新密钥:`dotnet run --project GC-SAVEDOG -- keygen`
- 轮换:把新公钥追加进 `SignatureKeyring.Keys`(保留旧公钥一个版本周期),再重新签名清单
- 公钥:硬编码在 `GC/src/Security/SignatureKeyring.cs`
- 当前生效:`gc-2026-12`,指纹 `ee6083be47a87907`
- 已停用:`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`
`build.sh` 在刷新清单后自动调用 `sign_manifest` 签名并同步 `model/version.json`;
`.signing/gc-signing.pem` 不存在时只告警,清单不带签名(客户端会拒绝更新)。
> 换钥匙的代价:老客户端只认识编译进去的那份公钥,所以**用新密钥签出的清单
> 在旧版本上会判成「签名无效」**。密钥一旦丢失,只能靠发一个新版本把新公钥带出去,
> 中间这段时间老客户端无法自动更新 —— 私钥务必备份两处以上。
### zip 解压加固
更新包和模型源 zip 一律当成不可信输入:拒绝 `../`、绝对路径、盘符、UNC、符号链接;
@@ -202,8 +238,8 @@ Repository/
| 方式 | 清单字段 | 说明 |
| --- | --- | --- |
| Release 附件(推荐) | `url` | `.../releases/download/v<版本>/GC-<版本>-<系统>-<架构>.zip` |
| 仓库编译产物 | `path` / `dir` / `name` | `dist/<系统>-<架构>/GC-<版本>-<系统>-<架构>.zip` |
| Release 附件(推荐) | `url` | `.../releases/download/<版本>/GCL-<版本>-<系统>-<架构>.zip` |
| 仓库编译产物 | `path` / `dir` / `name` | `dist/<系统>-<架构>/GCL-<版本>-<系统>-<架构>.zip` |
下载端按 `url` → `path` → `dist/<系统>-<架构>/` 目录扫描的顺序尝试,
**每个候选都必须与清单里的 `sha256` 一致**(`sha256` 由签名保护),
@@ -229,15 +265,16 @@ Repository/
| 产物 | 平台 |
| --- | --- |
| `dist/mac-arm64/GC-<版本>-mac-arm64.zip` | macOS Apple Silicon 应用包(含 GC-SAVEDOG) |
| `dist/win-amd64/GC-<版本>-win-amd64.zip` | Windows x64 单文件启动器 + `GC-SAVEDOG.exe` |
| `dist/win-arm64/GC-<版本>-win-arm64.zip` | Windows on ARM 同上 |
| `dist/mac-arm64/GCL-<版本>-mac-arm64.zip` | macOS Apple Silicon(单顶层 `GCL-….app`) |
| `dist/win-amd64/GCL-<版本>-win-amd64.zip` | Windows x64(单顶层 `GCL-…/`,含 Flutter 前端,非本体文件在 `.GC/bin/`) |
| `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`
会被挪到 `build/trash/`,下次构建时移出,不做递归删除)。
发新版:`./build.sh build -version=1.0.8` → 把 `dist/<平台>/GC-1.0.8-<平台>.zip`
上传到 gitcode Release(tag `v1.0.8`),**或者**直接提交/上传到仓库的
发新版:`./build.sh build` → 把 `dist/<平台>/GCL-<版本>-<平台>.zip`
上传到 Gitea Release(tag `v1.0.8`),**或者**直接提交/上传到仓库的
`dist/<平台>/` 目录 → 提交并推送 `version.json` / `model/version.json`。
两种都能被客户端识别,客户端下次启动就会看到更新。
+3 -1
View File
@@ -3,6 +3,7 @@
# GC 构建入口(薄封装)
#
# ./build.sh build 完整发布(原 publish),带 apt 风格进度条
# 默认要求每个平台都带 Flutter 前端;--allow-no-ui 允许降级
# ./build.sh check 验证:编译 + 自检 + 离屏渲染 + 产物
# ./build.sh models 编译模型 dll + 封面 + 版本戳
# ./build.sh stamp 重新生成 version.json
@@ -33,11 +34,12 @@ VERSION=$(sed -n 's/.*<Version>\(.*\)<\/Version>.*/\1/p' Directory.Build.props |
TASK="${1:-build}"
shift 2>/dev/null || true
# 解析 -version=<版本号>(也接受 --version=)
# 解析 -version=<版本号>(也接受 --version=)与 --allow-no-ui
CLI_VERSION=""
for arg in "$@"; do
case "$arg" in
-version=*|--version=*) CLI_VERSION="${arg#*=}" ;;
-allow-no-ui|--allow-no-ui) export GC_ALLOW_NO_UI=1 ;;
esac
done
if [ -n "$CLI_VERSION" ]; then
+3 -3
View File
@@ -275,7 +275,7 @@ function New-MacAppBundle {
<plist version="1.0"><dict>
<key>CFBundleName</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>CFBundleShortVersionString</key><string>$script:BuildVersion</string>
<key>CFBundlePackageType</key><string>APPL</string>
@@ -324,8 +324,8 @@ function Invoke-FullBuild {
Start-BuildStep '版本戳'; Invoke-VersionStamp; 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-arm64'; Publish-Rid 'win-arm64' 'dist/win-arm64' $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' $false; Complete-BuildStep
Start-BuildStep '运行骨架'
New-MacAppBundle
+98 -8
View File
@@ -1,13 +1,66 @@
#!/bin/sh
# 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() {
ROOT_DIR="$1"
: "${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
rm -rf "$ROOT_DIR/dist"; mkdir -p "$ROOT_DIR/dist"
@@ -37,8 +90,19 @@ bs_build() {
progress_tick 100
}
progress_step "编译 Mac"
_run_publish mac 90 publish_rid "osx-arm64" "dist/mac-arm64" false || return 1
if [ "$BUILD_MAC" = 1 ]; then
progress_step "编译 Mac"
_run_publish mac 90 publish_rid "osx-arm64" "dist/mac-arm64" true || 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" true || return 1
echo "!! --allow-no-ui:macOS 包内不含 Flutter 前端,启动器将回退 Avalonia"
fi
progress_step "编译 Win-x64"
_run_publish winx64 70 publish_rid "win-x64" "dist/win-amd64" true || return 1
@@ -46,11 +110,37 @@ bs_build() {
progress_step "编译 Win-arm64"
_run_publish winarm 70 publish_rid "win-arm64" "dist/win-arm64" true || return 1
if [ "$BUILD_LINUX" = 1 ]; then
progress_step "编译 Linux"
_run_publish linux 70 publish_rid "linux-arm64" "dist/linux-arm64" true || 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
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-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
pack_launcher
@@ -58,5 +148,5 @@ bs_build() {
progress_step "收尾"; progress_tick 100
progress_done
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++")
+235 -67
View File
@@ -24,7 +24,7 @@ stamp_launcher_only() {
# 没有私钥时只警告:清单不带 signature,客户端会按「未签名」处理。
sign_manifest() {
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
echo "!! 未找到签名私钥 ${KEY},本次 version.json 未签名(客户端会拒绝更新)"
echo " 生成密钥:dotnet run --project GC-SAVEDOG -- keygen"
@@ -65,48 +65,56 @@ build_models() {
stamp_versions
}
# 发布目录只放启动器 + 空的 .GC 运行骨架,绝不放模型
# 发布目录只放程序本体:不预置 .GC,也不放模型。
# .GC(config / model / cache / update / safedog / logs)一律在首次启动时
# 由 AppPaths.EnsureCreated + RuntimeLayout 创建,压缩包里只有 GC 本体。
prepare_runtime_layout() {
REL="$1"
DEST="$ROOT_DIR/$REL"
[ -d "$DEST" ] || return 0
rm -rf "$DEST/model" "$DEST/examples"
mkdir -p "$DEST/.GC/model" "$DEST/.GC/cache" "$DEST/.GC/update" "$DEST/.GC/config"
cat > "$DEST/.GC/model/README.txt" <<'TXT'
模型库目录(.GC/model/)
启动时程序会读取 GitCode 仓库的 version.json,把最新版模型下载到这里。
离线使用也可以手动放入 <模型id>/<模型id>.json + <模型id>/<模型id>.model/。
运行目录:
<可执行文件>
GC-SAVEDOG 更新守护进程(验签 + 原子替换 + 失败回滚)
.GC/config/settings.json 用户设置(删 .GC/cache 不会丢配置)
.GC/model/ 本目录(下载的模型)
.GC/cache/ 下载暂存
.GC/update/ 待下次启动应用的启动器更新
TXT
if [ ! -f "$DEST/.GC/config/settings.json" ]; then
cat > "$DEST/.GC/config/settings.json" <<'JSON'
{
"language": "auto",
"theme": "light",
"renderFps": 30,
"memoryMb": 2048,
"autoUpdateOnStartup": true,
"requireSignedManifest": true,
"updateRepository": "https://gitcode.com/Morris_1/GC",
"updateManifestUrl": "",
"updateLocalRoot": "",
"installedModelVersions": {},
"launcherVersion": "",
"pendingLauncherVersion": "",
"lastUpdateCheck": "",
"sources": [],
"recentModels": []
rm -rf "$DEST/model" "$DEST/examples" "$DEST/.GC"
echo " 运行目录 -> $REL(首次启动后生成 .GC/:config model cache update safedog logs)"
}
JSON
fi
echo " 运行目录 -> $REL/.GC (config/settings.json + model/ + cache/ + update/)"
# 剔除与目标平台无关 / 只在调试诊断时才会加载的组件。
# 判定依据:Windows 包用 Kestrel 自托管,不经过 IIS/HttpSys;Avalonia 在 Windows
# 上只用 Win32 后端;DAC/DBI/DiaSymReader 只有调试器与读 PDB 时才需要,
# 而发布包 DebugType=none、不带 PDB。全都不在启动与正常运行路径上。
prune_package() {
DEST="$1"; PLAT="$2"
[ -d "$DEST" ] || return 0
case "$PLAT" in
win)
# ProjectReference 会把后端 exe 的 runtimeconfig 一起拷过来;后端已编入启动器,
# 这些残留没有用。
rm -f "$DEST"/GC.UI.Server.exe "$DEST"/GC.UI.Server.dll \
"$DEST"/GC.UI.Server.deps.json "$DEST"/GC.UI.Server.runtimeconfig.json
rm -f "$DEST"/mscordaccore*.dll \
"$DEST"/mscordbi.dll \
"$DEST"/Microsoft.DiaSymReader.Native*.dll \
"$DEST"/web.config \
"$DEST"/aspnetcorev2_inprocess.dll \
"$DEST"/Microsoft.AspNetCore.Server.IIS.dll \
"$DEST"/Microsoft.AspNetCore.Server.IISIntegration.dll \
"$DEST"/Microsoft.AspNetCore.Server.HttpSys.dll \
"$DEST"/Avalonia.X11.dll \
"$DEST"/Avalonia.Native.dll \
"$DEST"/Avalonia.FreeDesktop.dll \
"$DEST"/Tmds.DBus.Protocol.dll
;;
linux)
rm -f "$DEST"/mscordaccore*.dll \
"$DEST"/mscordbi.dll \
"$DEST"/Microsoft.DiaSymReader.Native*.dll \
"$DEST"/web.config \
"$DEST"/aspnetcorev2_inprocess.dll \
"$DEST"/Microsoft.AspNetCore.Server.IIS.dll \
"$DEST"/Microsoft.AspNetCore.Server.IISIntegration.dll \
"$DEST"/Microsoft.AspNetCore.Server.HttpSys.dll \
"$DEST"/Avalonia.Win32.dll \
"$DEST"/Avalonia.Win32.Automation.dll
;;
esac
}
# $1=RID $2=输出目录 $3=singlefile(true/false)
@@ -124,15 +132,18 @@ publish_rid() {
-p:DebugType=none \
-p:PublishSingleFile="$SINGLE" \
-p:IncludeNativeLibrariesForSelfExtract="$SINGLE" \
-p:EnableCompressionInSingleFile="$SINGLE" \
-p:PublishTrimmed=false \
-o "$ROOT_DIR/$OUT"
-o "$ROOT_DIR/$OUT" || return 1
# 更新守护进程:与主程序同目录(macOS 打包时会被一起移入 Contents/MacOS)
if [ -n "${SAVEDOG_PROJ:-}" ] && [ -f "$ROOT_DIR/$SAVEDOG_PROJ" ]; then
echo "==> 编译 GC-SAVEDOG (${RID}) -> ${OUT}(裁剪单文件)"
echo "==> 编译 GC-SAVEDOG (${RID}) -> ${OUT}(裁剪 + 压缩单文件)"
# 守护进程不引用 Avalonia,可以安全裁剪:70MB -> 14MB。
# 前提是 JSON 全部走源生成上下文(GC-SAVEDOG/SavedogJson.cs),新增 JSON 类型
# 忘了注册只会在发布产物里炸,所以 update-test 会跑一次真实 apply 兜底。
# EnableCompressionInSingleFile:运行时不常驻,启动时解压一次即可,
# 换来包内少 4MB 左右,对「下载一次、只在更新时跑」的守护进程很划算。
dotnet publish "$SAVEDOG_PROJ" \
-c Release \
-r "$RID" \
@@ -141,6 +152,7 @@ publish_rid() {
-p:DebugType=none \
-p:PublishSingleFile=true \
-p:IncludeNativeLibrariesForSelfExtract=true \
-p:EnableCompressionInSingleFile=true \
-p:PublishTrimmed=true \
-p:TrimMode=full \
-p:JsonSerializerIsReflectionEnabledByDefault=false \
@@ -161,12 +173,14 @@ pack_models() {
du -sh "$ZIP"
}
# 启动器更新包:只包含程序文件,排除 .GC(否则会覆盖用户已下载的模型与设置)
# 启动器更新包:安装目录根只放 GC 本体;非本体文件(守护进程等)收进 .GC/bin。
# .GC 下的用户数据(config / model / cache / update / logs / safedog)不进包。
#
# 产物落点遵循「仓库 dist/<系统>-<架构>/」布局:
# dist/mac-arm64/GC-<版本>-mac-arm64.zip
# dist/win-amd64/GC-<版本>-win-amd64.zip
# dist/win-arm64/GC-<版本>-win-arm64.zip
# dist/mac-arm64/GCL-<版本>-mac-arm64.zip
# dist/win-amd64/GCL-<版本>-win-amd64.zip
# dist/win-arm64/GCL-<版本>-win-arm64.zip
# dist/linux-arm64/GCL-<版本>-linux-arm64.zip
# 启动器更新时既可以从 Release 附件下载,也会到这些目录里找编译产物
# (见 GC-DOWNLOAD/LauncherArtifacts.cs),所以两种发布方式都能用。
#
@@ -174,40 +188,194 @@ pack_models() {
# macOS: .app 必须打成 zip 才能作为单文件分发;文件名用 .app.zip,
# 这样 macOS 双击会用归档工具解压出可运行的 .app。
# 若直接命名 .app,系统会把 zip 当成应用包解析 => 报「已损坏/打不开」。
pack_launcher() {
echo "==> 生成启动器产物(GC-<版本>-<系统>-<架构>)"
# 发布本地 UI 后端(GC.UI.Server)。启动器会拉起它并等待 /api/health,
# 模型窗口也由它承载,所以必须和启动器放在同一目录。
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=true \
-p:IncludeNativeLibrariesForSelfExtract=true \
-p:EnableCompressionInSingleFile=true \
-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
RID="${pair%%:*}"; LABEL="${pair##*:}"
SRC="$ROOT_DIR/dist/$LABEL"
[ -d "$SRC" ] || SRC="$ROOT_DIR/dist/$RID" # 兼容旧布局
[ -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
# 包内只有一个顶层目录(GCL-<版本>-<平台>),解压后不会散落一屏 dll。
TMP="$ROOT_DIR/dist/.winpkg-$LABEL"
rm -rf "$TMP"; mkdir -p "$TMP"
cp "$EXE" "$TMP/GC-${VERSION}-${LABEL}.exe"
chmod +x "$TMP/GC-${VERSION}-${LABEL}.exe" 2>/dev/null || true
if [ -f "$SRC/GC-SAVEDOG.exe" ]; then
cp "$SRC/GC-SAVEDOG.exe" "$TMP/GC-SAVEDOG.exe"
else
PKGNAME="GCL-${VERSION}-${LABEL}"
PKG="$TMP/$PKGNAME"
rm -rf "$TMP"; mkdir -p "$PKG"
cp -R "$SRC"/. "$PKG"/
rm -f "$PKG"/*.zip
prune_package "$PKG" win
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,该平台将退回旧脚本更新"
else
# 非本体文件统一收进 .GC/bin:安装目录根只留 GC 本体。
# 首次启动复制到 .GC/safedog 再运行,所以这里的源文件更新时可安全替换。
mkdir -p "$PKG/.GC/bin"
mv "$PKG/GC-SAVEDOG.exe" "$PKG/.GC/bin/"
fi
if [ ! -f "$PKG/GC-UI.exe" ]; then
echo " !! 包内没有 Flutter 前端,启动器将使用内置 Avalonia 界面"
fi
ZIP="$ROOT_DIR/dist/$LABEL/GC-${VERSION}-${LABEL}.zip"
ZIP="$ROOT_DIR/dist/$LABEL/$PKGNAME.zip"
rm -f "$ZIP"
( cd "$TMP" && zip -q "$ZIP" ./* )
( cd "$TMP" && zip -qr "$ZIP" "$PKGNAME" )
rm -rf "$TMP"
echo " -> dist/$LABEL/GC-${VERSION}-${LABEL}.zip"
echo " -> dist/$LABEL/$PKGNAME.zip"
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
prune_package "$PKG" linux
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/.GC/bin"
mv "$PKG/GC-SAVEDOG" "$PKG/.GC/bin/"
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)---
MACAPP="$ROOT_DIR/dist/mac-arm64/GC.app"
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"
mv "$MACAPP" "$FINAL"
chmod +x "$FINAL/Contents/MacOS/GC" 2>/dev/null || true
@@ -221,14 +389,14 @@ pack_launcher() {
fi
# --- 统一压缩:每个产物都打成同名 .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」取包,再解压回原名。
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
base=$(basename "$art")
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"
mkdir -p "$ROOT_DIR/dist/${label}"
rm -f "$ZIP"
@@ -250,7 +418,7 @@ pack_launcher() {
# 一次性删除又慢又不可逆,先挪走更安全(暂存区在下次构建开始时挪出 dist)。
TRASH="$ROOT_DIR/build/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
mv "$leftover" "$TRASH/$(basename "$leftover")-$(date +%s)" 2>/dev/null || true
done
@@ -259,15 +427,15 @@ pack_launcher() {
stamp_launcher_only
echo ""
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
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
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
find "$ROOT_DIR/dist" -name ".DS_Store" -delete 2>/dev/null || true
}
@@ -284,7 +452,7 @@ package_mac_app() {
<dict>
<key>CFBundleName</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>CFBundleShortVersionString</key><string>${VERSION}</string>
<key>CFBundlePackageType</key><string>APPL</string>
+2 -2
View File
@@ -74,10 +74,10 @@ dll / json 的哈希 —— 本地文件被替换会直接拒绝加载。
"descriptionI18n": { "zh-CN": "……", "en": "……" },
"version": "1.6",
"updatedAt": "2026-11-14T08:00:00Z",
"author": "NeoRF",
"author": "Morris",
"tags": ["astronomy", "geography"],
"assembly": "EarthRotationModel.dll",
"type": "NeoRF.EarthModels.RotationModelFactory",
"type": "GC.EarthModels.RotationModelFactory",
"preview": "preview.png",
"apiVersion": 1,
"minAppVersion": "1.0.7"
+1 -1
View File
@@ -5,7 +5,7 @@
<TargetFramework>net8.0</TargetFramework>
<Nullable>enable</Nullable>
<ImplicitUsings>disable</ImplicitUsings>
<RootNamespace>NeoRF.EarthModels</RootNamespace>
<RootNamespace>GC.EarthModels</RootNamespace>
<AssemblyName>EarthModelPreview</AssemblyName>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
</PropertyGroup>
+2 -2
View File
@@ -10,9 +10,9 @@ using Avalonia.Headless;
using Avalonia.Media.Imaging;
using Avalonia.Platform;
using GC.ModelSdk;
using NeoRF.EarthModels;
using GC.EarthModels;
namespace NeoRF.EarthModels.Preview;
namespace GC.EarthModels.Preview;
/// <summary>
/// 封面生成工具:给每个模型画一张 preview.png。
+3 -3
View File
@@ -11,7 +11,7 @@ using GC.Services;
// 仓库根 version.json 与 model/version.json(内容相同,便于两种源地址读取)。
// 仓库地址(编译产物的 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.packages(构建脚本在打完 zip 之后再调一次),
@@ -150,8 +150,8 @@ var packages = new Dictionary<string, Dictionary<string, object>>();
// 2) 仓库里的编译产物 dist/<系统>-<架构>/GC-<版本>-<系统>-<架构>.zip ——
// 不发 Release、只提交产物也能更新(用户明确要求支持这种布局)。
// 两种都写:url 只是「去哪儿找」,真正的完整性凭据是下面的 sha256(受签名保护)。
var releaseBase = $"{Repository}/releases/download/v{launcherVersion}";
foreach (var rid in new[] { "win-x64", "win-arm64", "osx-arm64", "osx-x64", "linux-x64" })
var releaseBase = $"{Repository}/releases/download/{launcherVersion}";
foreach (var rid in new[] { "win-x64", "win-arm64", "osx-arm64", "osx-x64", "linux-arm64" })
{
var label = LauncherArtifacts.LabelOf(rid);
var fileName = LauncherArtifacts.PackageFileName(launcherVersion, rid);
+1 -1
View File
@@ -12,7 +12,7 @@ using Avalonia.Media.Imaging;
using Avalonia.Platform;
using Avalonia.Threading;
namespace NeoRF.EarthModels;
namespace GC.EarthModels;
public enum SceneView
{
+1 -1
View File
@@ -11,7 +11,7 @@ using Avalonia.Media;
using Avalonia.Threading;
using GC.ModelSdk;
namespace NeoRF.EarthModels;
namespace GC.EarthModels;
/// <summary>
/// 模型自己的界面:画布 + 触控友好工具栏 + 课堂演示卡 + 节气定格与步进。
+1 -1
View File
@@ -2,7 +2,7 @@ using System;
using Avalonia.Controls;
using GC.ModelSdk;
namespace NeoRF.EarthModels;
namespace GC.EarthModels;
/// <summary>
/// 地球模型共享运行时:读自己目录下的 scene.json / land.json / i18n,
+1 -1
View File
@@ -2,7 +2,7 @@ using System;
using System.Collections.Generic;
using System.Numerics;
namespace NeoRF.EarthModels;
namespace GC.EarthModels;
/// <summary>
/// 地理模型的球面几何工具:经纬度 ↔ 单位球坐标、正交投影到屏幕、
+1 -1
View File
@@ -4,7 +4,7 @@ using System.IO;
using System.Text.Json;
using System.Text.Json.Serialization;
namespace NeoRF.EarthModels;
namespace GC.EarthModels;
/// <summary>&lt;id&gt;.model/land.json —— 简化的大陆轮廓(经纬度多边形)。</summary>
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.Serialization;
namespace NeoRF.EarthModels;
namespace GC.EarthModels;
/// <summary>模型自己的 JSON 读写(不依赖启动器)。</summary>
public static class ModelJson
+1 -1
View File
@@ -4,7 +4,7 @@ using System.Globalization;
using System.IO;
using System.Text.Json;
namespace NeoRF.EarthModels;
namespace GC.EarthModels;
/// <summary>
/// 模型自己的一份文案。优先读模型数据目录里的 <c>i18n/&lt;language&gt;.json</c>,
+1 -1
View File
@@ -1,6 +1,6 @@
using System.Collections.Generic;
namespace NeoRF.EarthModels;
namespace GC.EarthModels;
/// <summary>&lt;id&gt;.model/scene.json —— 模型数据(可视化场景描述)。</summary>
public sealed class SceneDefinition
+1 -1
View File
@@ -2,7 +2,7 @@ using System;
using System.IO;
using Avalonia.Media;
namespace NeoRF.EarthModels;
namespace GC.EarthModels;
/// <summary>
/// 模型自己的场景运行时:场景描述 + 预烘焙地表纹理 + 调色板。
+1 -1
View File
@@ -3,7 +3,7 @@ using System.Collections.Generic;
using System.Threading.Tasks;
using Avalonia.Media;
namespace NeoRF.EarthModels;
namespace GC.EarthModels;
/// <summary>
/// 预烘焙的等经纬度地表贴图:反照率 + 高度 + 冰盖 + 云层 + 夜间灯光。
+1 -1
View File
@@ -3,7 +3,7 @@ using System.Numerics;
using System.Threading.Tasks;
using Avalonia.Media.Imaging;
namespace NeoRF.EarthModels;
namespace GC.EarthModels;
/// <summary>
/// 球体像素级渲染:正交投影 + 预烘焙地表纹理 + 地形光照 + 云层 + 夜灯 + 大气边缘光。
+4 -4
View File
@@ -16,8 +16,8 @@
"terrain"
],
"assembly": "ContourMapModel.dll",
"type": "NeoRF.ContourMap.ContourMapFactory",
"version": "1.0",
"type": "GC.ContourMap.ContourMapFactory",
"version": "1.1",
"chrome": {
"titleBar": "#0C1828",
"titleBorder": "#1B2740",
@@ -25,6 +25,6 @@
"button": "#9FB4D4",
"frame": "#0A1524"
},
"build": "e4b3f2b87e",
"updatedAt": "2026-11-14T11:34:35Z"
"build": "773ab2161d",
"updatedAt": "2026-11-18T10:16:41Z"
}
+1 -1
View File
@@ -4,7 +4,7 @@
<TargetFramework>net8.0</TargetFramework>
<Nullable>enable</Nullable>
<ImplicitUsings>disable</ImplicitUsings>
<RootNamespace>NeoRF.ContourMap</RootNamespace>
<RootNamespace>GC.ContourMap</RootNamespace>
<AssemblyName>ContourMapModel</AssemblyName>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<IsPackable>false</IsPackable>
+1 -1
View File
@@ -6,7 +6,7 @@ using Avalonia.Layout;
using Avalonia.Media;
using GC.ModelSdk;
namespace NeoRF.ContourMap;
namespace GC.ContourMap;
/// <summary>等高线模型入口(清单里的 type 指向这里)。</summary>
public sealed class ContourMapFactory : IModelFactory
+1 -1
View File
@@ -5,7 +5,7 @@ using Avalonia.Controls;
using Avalonia.Layout;
using Avalonia.Media;
namespace NeoRF.ContourMap;
namespace GC.ContourMap;
/// <summary>等高线模型的界面:顶部标题、中间双图联动、右侧判读要点、底部实时读数。</summary>
public sealed class ContourPage
+1 -1
View File
@@ -6,7 +6,7 @@ using Avalonia;
using Avalonia.Controls;
using Avalonia.Media;
namespace NeoRF.ContourMap;
namespace GC.ContourMap;
/// <summary>
/// 等高线教学画布,左右两块:
+1 -1
View File
@@ -1,6 +1,6 @@
using System.Collections.Generic;
namespace NeoRF.ContourMap;
namespace GC.ContourMap;
/// <summary>内置全量文案兜底:没有语言包也能完整显示。</summary>
internal static class DefaultTexts
+1 -1
View File
@@ -1,7 +1,7 @@
using System;
using System.Collections.Generic;
namespace NeoRF.ContourMap;
namespace GC.ContourMap;
/// <summary>地形部位识别结果:课本要求学生能在等高线图上认出这五种部位。</summary>
public enum TerrainFeature
+1 -1
View File
@@ -1,7 +1,7 @@
using System;
using System.Collections.Generic;
namespace NeoRF.ContourMap;
namespace GC.ContourMap;
/// <summary>五种基本地形类型(教科书分类)。</summary>
public enum TerrainKind
+4 -4
View File
@@ -9,7 +9,7 @@
"en": "Climate zones, continent/ocean outlines, plates and borders — clean line art."
},
"assembly": "EarthGeographyModel.dll",
"type": "NeoRF.EarthModels.GeographyModelFactory",
"type": "GC.EarthModels.GeographyModelFactory",
"author": "Morris GC",
"tags": [
"geography",
@@ -17,7 +17,7 @@
"atlas"
],
"dataDir": "earth-geography.model",
"version": "1.8",
"version": "1.9",
"chrome": {
"titleBar": "#0C1828",
"titleBorder": "#1B2740",
@@ -25,6 +25,6 @@
"button": "#9FB4D4",
"frame": "#0A1524"
},
"build": "3b645c45c2",
"updatedAt": "2026-11-14T11:34:35Z"
"build": "cc68b8863b",
"updatedAt": "2026-11-18T10:16:41Z"
}
@@ -4,7 +4,7 @@
<TargetFramework>net8.0</TargetFramework>
<Nullable>enable</Nullable>
<ImplicitUsings>disable</ImplicitUsings>
<RootNamespace>NeoRF.EarthModels</RootNamespace>
<RootNamespace>GC.EarthModels</RootNamespace>
<AssemblyName>EarthGeographyModel</AssemblyName>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<IsPackable>false</IsPackable>
+1 -1
View File
@@ -1,7 +1,7 @@
using System.Collections.Generic;
using System.Text.Json.Serialization;
namespace NeoRF.EarthModels;
namespace GC.EarthModels;
/// <summary>地球地理模型的数据文件:全部是经纬度折线,只有轮廓没有填色。</summary>
public sealed class GeoData
@@ -7,7 +7,7 @@ using Avalonia.Layout;
using Avalonia.Media;
using GC.ModelSdk;
namespace NeoRF.EarthModels;
namespace GC.EarthModels;
/// <summary>
/// 地球地理模型:五带划分 + 七大洲四大洋轮廓 + 六大板块与洲界,纯线稿。
+1 -1
View File
@@ -8,7 +8,7 @@ using Avalonia.Input;
using Avalonia.Media;
using GC.ModelSdk;
namespace NeoRF.EarthModels;
namespace GC.EarthModels;
public enum GeoMode { Sphere3D, Flat2D }
+5 -5
View File
@@ -6,7 +6,7 @@
"zh-CN": "地球公转",
"en": "Earth Revolution"
},
"author": "NeoRF",
"author": "Morris",
"description": "四季更替、黄赤交角与二分二至",
"descriptionI18n": {
"zh-CN": "地球绕太阳公转一年:地轴指向不变,太阳直射点南北往返,形成四季。",
@@ -20,10 +20,10 @@
"entry": "scene.json",
"license": "MIT",
"assembly": "EarthRevolutionModel.dll",
"type": "NeoRF.EarthModels.RevolutionModelFactory",
"type": "GC.EarthModels.RevolutionModelFactory",
"preview": "preview.png",
"apiVersion": 1,
"version": "1.6",
"version": "1.7",
"chrome": {
"titleBar": "#0C1828",
"titleBorder": "#1B2740",
@@ -31,6 +31,6 @@
"button": "#9FB4D4",
"frame": "#0A1524"
},
"build": "947efa36bb",
"updatedAt": "2026-11-14T11:34:35Z"
"build": "53b7a0fbc3",
"updatedAt": "2026-11-18T10:16:41Z"
}
@@ -4,7 +4,7 @@
<TargetFramework>net8.0</TargetFramework>
<Nullable>enable</Nullable>
<ImplicitUsings>disable</ImplicitUsings>
<RootNamespace>NeoRF.EarthModels</RootNamespace>
<RootNamespace>GC.EarthModels</RootNamespace>
<AssemblyName>EarthRevolutionModel</AssemblyName>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<IsPackable>false</IsPackable>
@@ -1,6 +1,6 @@
using GC.ModelSdk;
namespace NeoRF.EarthModels;
namespace GC.EarthModels;
/// <summary>地球公转模型入口(清单里的 type 指向这里)。</summary>
public sealed class RevolutionModelFactory : IModelFactory
+5 -5
View File
@@ -6,7 +6,7 @@
"zh-CN": "地球自转",
"en": "Earth Rotation"
},
"author": "NeoRF",
"author": "Morris",
"description": "昼夜交替、晨昏线与太阳直射点",
"descriptionI18n": {
"zh-CN": "观察自转中的地球:昼夜半球、晨昏线与太阳直射点位置。",
@@ -20,10 +20,10 @@
"entry": "scene.json",
"license": "MIT",
"assembly": "EarthRotationModel.dll",
"type": "NeoRF.EarthModels.RotationModelFactory",
"type": "GC.EarthModels.RotationModelFactory",
"preview": "preview.png",
"apiVersion": 1,
"version": "1.6",
"version": "1.7",
"chrome": {
"titleBar": "#0C1828",
"titleBorder": "#1B2740",
@@ -31,6 +31,6 @@
"button": "#9FB4D4",
"frame": "#0A1524"
},
"build": "a803d9c020",
"updatedAt": "2026-11-14T11:34:35Z"
"build": "ecd52665f9",
"updatedAt": "2026-11-18T10:16:41Z"
}
@@ -4,7 +4,7 @@
<TargetFramework>net8.0</TargetFramework>
<Nullable>enable</Nullable>
<ImplicitUsings>disable</ImplicitUsings>
<RootNamespace>NeoRF.EarthModels</RootNamespace>
<RootNamespace>GC.EarthModels</RootNamespace>
<AssemblyName>EarthRotationModel</AssemblyName>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<IsPackable>false</IsPackable>
@@ -1,6 +1,6 @@
using GC.ModelSdk;
namespace NeoRF.EarthModels;
namespace GC.EarthModels;
/// <summary>地球自转模型入口(清单里的 type 指向这里)。</summary>
public sealed class RotationModelFactory : IModelFactory
Loaded 100 of 114 files, more files were not shown because too many files have changed in this diff. Show more