@yufengtadian/freedom-cli 1.12.16 → 1.12.18

package/README.md

@@ -1,13 +1,16 @@
 # freedom-cli
 
-Freedom 桌面壳打包工具：把你的 Web 前端一键打包成跨平台桌面应用（v1.12.15）。
+Freedom 桌面壳打包工具：把你的 Web 前端一键打包成跨平台桌面应用（v1.12.17）。
 
 基于自研 Freedom WebView 壳层（对标 Wails / Tauri）：前端完全自由、后端可任意语言、渲染复用系统 WebView（Windows WebView2 / macOS WKWebView / Linux WebKitGTK），产物为单个可执行文件 + resources 目录，前端页面内存加载，不占本地端口。
 
+**v1.12.17 安全模式全面落地**：三档安全模式 `freedom security <none|basic|high>` 正式随包分发——high 档把 resources 加密为 `app.bin`（AES-256-CTR + HMAC-SHA256 + PBKDF2 密钥派生），配合 `.integrity` 完整性校验、anti-debug 与进程隐藏，磁盘无明文、篡改即拒运行；三平台预编译壳经 CI 重建分发，补齐 v1.12.16 仅重编 win-x64 壳的缺口。
+
 **v1.12.16 自动更新 + 完整 CLI 模式 + 壳生命周期全面防御**：
 - **自动检测版本并自动更新**：`freedom update` / `freedom check-update` 检测到新版本即自动执行 `npm install -g @yufengtadian/freedom-cli@latest` 升级，**不再需要手动执行 npm 命令**；每次命令执行成功后静默自检，发现新版自动更新（6 小时频控防骚扰，非全局安装给出明确升级指引）；TUI 主菜单「检查 / 自动更新」同步接入；
 - **完整 CLI 模式**：无参数运行 `freedom` 直接进入交互式完整 CLI（打包 / 新建项目 / 配置 / 壳管理 / 教程 / 自动更新 / 退出）；管道与脚本环境自动降级打印帮助，不卡死；
-- **壳生命周期全面防御（B51-B58 闭环）**：webview 全方法销毁防护、user32 proc 去重、WebView2 缺失可操作提示；`webview_create` 失败（如缺 WebKitGTK）返回 nil 后新壳走明确失败提示而非空指针崩溃；用户 `Bind` 的方法不再被 config.json 进程后端静默覆盖失效；help 文案与自动更新实现对齐，清理死代码。
+- **壳生命周期全面防御（B51-B58 闭环）**：webview 全方法销毁防护、user32 proc 去重、WebView2 缺失可操作提示；`webview_create` 失败（如缺 WebKitGTK）返回 nil 后新壳走明确失败提示而非空指针崩溃；用户 `Bind` 的方法不再被 config.json 进程后端静默覆盖失效；help 文案与自动更新实现对齐，清理死代码；
+- **安全加固（新增 high 安全模式，B59-B62 闭环）**：`freedom security <none|basic|high>` 三档安全模式，high 档把 resources 整体加密为 `app.bin`（AES-256-CTR + HMAC-SHA256，密钥经 PBKDF2 按应用派生），磁盘无明文 HTML/配置，壳内存解密 + `.integrity` 完整性校验（防整体替换 / 篡改 / exe 改名），另含 anti-debug（检测调试器即退出）与进程隐藏；详见下文「安全模式」章节。
 
 **v1.12.15 补发壳生命周期稳定性修复**：v1.12.14 的 npm 上架时间早于修复提交，上架版预编译壳未包含悬垂指针修复（窗口操作 / 代理端口触发随机退出的根因）；本版正式把含 B50 修复的预编译壳随 npm 包分发——
 - 壳销毁生命周期修复：`webview.Destroy()` 后经 Emit / Quit / WindowHandle / binding 回调访问已释放 C 对象（悬垂指针）导致随机退出；新增 `destroyed` 原子标记，Dispatch / Eval / binding 回调销毁后一律跳过原生调用，`Run` 在 `Destroy` 前清空 `App.view`，事件与绑定回调加 `recover` 兜底；
@@ -94,6 +97,7 @@ freedom icon icon.ico
 
 # 4. 打包
 freedom build                        # 默认当前平台
+freedom build --security high        # 以 high 安全模式构建（resources 加密，见「安全模式」）
 freedom build --platform all         # 三平台全量（win + mac + linux）
 freedom build --platform win-x64     # 仅 Windows
 freedom build --platform darwin-arm64   # 仅 macOS Apple Silicon
@@ -152,6 +156,7 @@ export default {
   minHeight: 300,
   center: true,          // 启动居中
   debug: false,          // 开发者工具
+  security: 'none',      // 安全模式：'none'（明文）| 'basic'（明文+提示）| 'high'（resources 加密，见「安全模式」）
   titlebar: 'frameless', // frameless（默认，标题栏不存在，三按钮由前端自绘）| native
   icon: undefined,       // 应用图标：Windows 用 .ico（推荐多尺寸），macOS 用 .icns
   outDir: 'dist',        // 产物目录：'dist'（默认）| '.'（项目根目录）| 任意路径
@@ -164,6 +169,35 @@ export default {
 - macOS：`.icns` 在构建时放入 `.app/Contents/Resources` 并写入 Info.plist 的 `CFBundleIconFile`；
 - 未配置时使用壳默认图标。`freedom icon <path>` 可直接写入该配置。
 
+## 安全模式
+
+默认产物把前端 HTML 与配置以明文写入 `resources/`，任何人解包即可直接读取页面源码与配置。如需防止源码被轻易提取，提供三档安全模式：
+
+| 模式 | 资源形态 | 破解难度 | 适用场景 |
+| --- | --- | --- | --- |
+| `none` | 明文 `index.html` + `config.json`（默认，兼容历史产物） | 解包即读 | 公开页面 / 调试 / 快速分发 |
+| `basic` | 同上明文，构建时额外输出加固建议 | 低 | 需要提示、暂不加密 |
+| `high` | 整体加密为 `resources/app.bin` + `.integrity`，磁盘**无任何明文** HTML/配置 | 高（需逆向壳 + 还原派生密钥） | 防源码提取、防资源篡改的正式分发 |
+
+**切换方式**（二选一，`--security` 可临时覆盖配置文件）：
+
+```bash
+freedom security high                # 写入 freedom.config.js 持久生效
+freedom build --security high        # 单次构建生效（不改配置）
+freedom build                        # 读取配置中的 security 值
+```
+
+**high 模式原理**：
+- 构建时：前端 HTML + 配置序列化后，用 **AES-256-CTR** 加密为 `app.bin`（容器头 `FRDM1` + 16B IV + 16B 认证标签），并生成 `.integrity` 完整性清单（`app.bin` 与 `backend/**` 各文件的 HMAC-SHA256）；
+- 加密密钥由 **PBKDF2-HMAC-SHA256**（6 万次迭代）按「应用可执行文件名」派生，不同应用密钥不同，暴力破解成本高；
+- 壳启动时：先校验 `.integrity`（防整体替换 / 篡改 / exe 改名），再恒定时间比对 HMAC 认证标签（Encrypt-then-MAC），最后内存中解密加载——**磁盘始终无明文**；
+- 解密 / 校验失败即拒绝运行（不静默回退明文，防降级攻击）；
+- 另内置 **anti-debug**（`IsDebuggerPresent` / `CheckRemoteDebuggerPresent` 命中即退出）与进程隐藏加固。
+
+**加固上限说明**：`high` 大幅提高破解门槛，但**任何客户端可执行程序都无法做到绝对不可破解**——密钥最终存在于壳二进制与运行时内存中。更高强度建议：壳编译时设置 `-ldflags "-s -w"` 剥离符号表（CI 编译壳时已可选开启）、对核心业务保留服务端校验。若需"怎么都解不开"，请把真正敏感的密钥 / 逻辑放到你的后端。
+
+**互斥规则**：切换安全模式重新构建时，CLI 会自动清理另一模式的遗留产物（`app.bin`/`.integrity` 与明文 `index.html`/`config.json` 只能存其一），避免壳误加载旧资源。
+
 ## 前端
 
 前端是标准 Vite 项目，`vite build` 时通过 `vite-plugin-singlefile` 内联为单个 HTML。壳层注入全局对象 `window.freedom`：
@@ -186,8 +220,9 @@ window.freedom.window.minimize();                       // 窗口控制
 ```
 freedom tui                          # 交互式终端界面
 freedom init <目录> [--force]
-freedom build [--platform win-x64|darwin-arm64|linux-x64|all] [--no-cache]
+freedom build [--platform win-x64|darwin-arm64|linux-x64|all] [--no-cache] [--security none|basic|high]
 freedom titlebar <native|frameless>
+freedom security <none|basic|high>     # 设置安全模式（写入配置）
 freedom icon <path>                    # 设置应用图标（Windows 用 .ico，macOS 用 .icns）
 freedom config [get|set]
 freedom shell list|download <platform>|build <platform>

package/lib/build.js

@@ -35,6 +35,13 @@ const {
   localShellPath,
 } = require('./utils');
 const { hasShell, downloadShell, validateLocalShell } = require('./shell');
+const {
+  SECURITY_MODES,
+  resolveSecurity,
+  encryptApp,
+  buildIntegrity,
+  renderIntegrity,
+} = require('./security');
 
 function run(cmd, args, opts = {}) {
   // Windows 下 npm 是 .cmd 批处理，必须经 shell 执行
@@ -105,9 +112,13 @@ async function build(projectDir, opts = {}) {
   if (useCache && !viteNeedsRebuild(dir)) {
     process.stdout.write('[freedom] 前端源码无改动，复用构建缓存...\n');
   } else {
-    const vite = run('npm', ['run', 'build'], { cwd: dir });
+    process.stdout.write('[freedom] 前端打包中（npm run build）...\n');
+    // 全量构建时 npm/vite 输出必须实时透传（stdio: inherit），
+    // 此前 pipe 缓冲会吞掉构建全程输出，Node 主线程被 spawnSync 同步阻塞，
+    // 大前端全量构建时终端长时间零输出，表现如"未响应/卡死"。
+    const vite = run('npm', ['run', 'build'], { cwd: dir, stdio: 'inherit' });
     if (vite.status !== 0) {
-      throw new Error(`前端打包失败：\n${vite.stdout}\n${vite.stderr}`);
+      throw new Error(`前端打包失败（退出码 ${vite.status}），详见上方构建输出。`);
     }
     writeViteCacheMarker(dir);
   }
@@ -118,6 +129,11 @@ async function build(projectDir, opts = {}) {
   const html = fs.readFileSync(distHtml, 'utf8');
   warnIfNotSingleFile(html, distHtml);
   const configJSON = renderConfigJSON(cfg, name);
+  // 安全模式：--security 优先于 freedom.config.js 的 security 字段，默认 none。
+  //   none  = 明文资源（默认，兼容历史产物）
+  //   basic = 明文资源 + 构建期安全提示（剥符号 / 混淆，后续可用高模式加密）
+  //   high  = resources 整体加密为 app.bin（AES-256-CTR+HMAC）+ .integrity 完整性清单，磁盘无明文
+  const security = resolveSecurity(opts.security, cfg.security);
 
   // 2) 后端目录（若配置了 backend 进程）
   const backendDir = path.join(dir, cfg.backendDir || 'backend');
@@ -133,15 +149,42 @@ async function build(projectDir, opts = {}) {
   const results = await Promise.all(
     platforms.map(async (plat) => {
       const targetDir = multi ? path.join(outDirPath, plat) : outDirPath;
-      const outFile = await emitPlatform({ plat, name, version, targetDir, html, configJSON, backendDir, hasBackend, autoDownload, icon });
+      const outFile = await emitPlatform({ plat, name, version, targetDir, html, configJSON, backendDir, hasBackend, autoDownload, icon, security });
       return { plat, outFile };
     })
   );
 
+  // 5) 产物自检 + 形态树（消除"build 后形态未知 / 需实测"）：
+  //    build 完成后自动校验产物完整性，并打印产物结构；自检发现问题仅告警不阻断，
+  //    完整失败信息可用 freedom verify 复核（返回非零退出码，供 CI 使用）。
+  const { verifyProduct, renderTree, formatChecks } = require('./verify');
+  const v = await verifyProduct(dir);
+  if (v.error) {
+    process.stdout.write(`[freedom] 产物自检跳过：${v.error}\n`);
+  } else if (v.targets.length === 0) {
+    process.stdout.write('[freedom] 产物自检跳过：未在产物目录发现可执行文件。\n');
+  } else {
+    process.stdout.write('\n[freedom] 产物自检：\n');
+    for (const t of v.targets) {
+      process.stdout.write(`  [${t.plat}] ${t.dir}\n`);
+      for (const line of formatChecks(t.checks)) {
+        process.stdout.write(`    ${line}\n`);
+      }
+    }
+    process.stdout.write('\n[freedom] 产物结构：\n');
+    for (const line of renderTree(v.targets).split('\n')) {
+      process.stdout.write(`  ${line}\n`);
+    }
+    const failed = v.targets.some((t) => t.checks.some((c) => !c.pass));
+    if (failed) {
+      process.stdout.write(`\n[freedom] 警告：产物自检存在失败项，请运行 ${'freedom verify'} 复核。\n`);
+    }
+  }
+
   return { results };
 }
 
-async function emitPlatform({ plat, name, version, targetDir, html, configJSON, backendDir, hasBackend, autoDownload, icon }) {
+async function emitPlatform({ plat, name, version, targetDir, html, configJSON, backendDir, hasBackend, autoDownload, icon, security }) {
   // 取预编译壳二进制
   const shell = localShellPath(plat);
   if (!fs.existsSync(shell)) {
@@ -172,15 +215,47 @@ async function emitPlatform({ plat, name, version, targetDir, html, configJSON,
   }
 
   // 自定义 exe 图标（仅 Windows PE 支持嵌入 .ico 资源；mac 用 .icns 走 .app 分支）
+  // 修复：此前引用未传入 emitPlatform 作用域的 cfg 导致 ReferenceError（cfg is not defined），
+  // 配置 icon 后 Windows 构建必然失败；改用 emitPlatform 已解构的 name/version。
   if (isWinPlat(plat) && icon) {
-    await applyWindowsIcon(outFile, icon);
+    await applyWindowsIcon(outFile, icon, name, version);
   }
 
   // 写 resources：页面 + 配置 + 后端
+  // security=high 时整体加密为 app.bin（磁盘无明文 HTML/config），并生成 .integrity 完整性清单；
+  // none / basic 保持明文资源（兼容历史产物），basic 额外输出安全加固提示。
   const resDir = path.join(targetDir, 'resources');
   await fsp.mkdir(resDir, { recursive: true });
-  await fsp.writeFile(path.join(resDir, 'index.html'), html, 'utf8');
-  await fsp.writeFile(path.join(resDir, 'config.json'), configJSON, 'utf8');
+  // 互斥清理：切换安全模式时删除另一模式遗留产物，防止壳误加载旧资源
+  // （high 产物 app.bin/.integrity 与明文 index.html/config.json 只能存其一）。
+  if (security === 'high') {
+    for (const legacy of ['index.html', 'config.json']) {
+      const p = path.join(resDir, legacy);
+      if (fs.existsSync(p)) await fsp.rm(p, { force: true });
+    }
+    const appBin = encryptApp(name, html, configJSON);
+    await fsp.writeFile(path.join(resDir, 'app.bin'), appBin);
+    const backendRelMap = {};
+    if (hasBackend && fs.existsSync(backendDir)) {
+      collectDirFiles(backendDir, '', backendRelMap);
+    }
+    const integrityText = renderIntegrity(buildIntegrity(name, appBin, backendRelMap));
+    await fsp.writeFile(path.join(resDir, '.integrity'), integrityText, 'utf8');
+  } else {
+    for (const legacy of ['app.bin', '.integrity']) {
+      const p = path.join(resDir, legacy);
+      if (fs.existsSync(p)) await fsp.rm(p, { force: true });
+    }
+    await fsp.writeFile(path.join(resDir, 'index.html'), html, 'utf8');
+    await fsp.writeFile(path.join(resDir, 'config.json'), configJSON, 'utf8');
+    if (security === 'basic') {
+      process.stdout.write(
+        `[freedom] 安全模式 basic：资源仍为明文。加固建议：\n` +
+        `          1. 运行 ${'freedom security high'} 切换到高模式（resources 加密为 app.bin，磁盘无明文）；\n` +
+        `          2. 壳侧已内置 anti-debug / 进程隐藏，符号剥离需在 CI 编译壳时设置 ldflags -s -w（见 README 安全章节）。\n`
+      );
+    }
+  }
   if (hasBackend) {
     copyDir(backendDir, path.join(resDir, 'backend'));
   }
@@ -197,9 +272,11 @@ async function emitPlatform({ plat, name, version, targetDir, html, configJSON,
   return outFile;
 }
 
-// 把 .ico 图标注入到 Windows exe 的 PE 资源（RT_ICON + RT_GROUP_ICON）。
+// 把 .ico 图标注入到 Windows exe 的 PE 资源（RT_ICON + RT_GROUP_ICON），
+// 并设置版本信息（产品名 / 说明 / 版本），使资源管理器详情可读。
 // 依赖 rcedit（随 npm 包分发的预编译 rcedit-x64.exe，无需 Go/资源编译器）。
-async function applyWindowsIcon(exePath, iconPath) {
+// 产品名取自 cfg.name，版本取自 cfg.version —— 修复"产物无产品名 / 版本无法配置"。
+async function applyWindowsIcon(exePath, iconPath, name, version) {
   const ext = path.extname(iconPath).toLowerCase();
   if (ext !== '.ico') {
     process.stdout.write(
@@ -214,8 +291,24 @@ async function applyWindowsIcon(exePath, iconPath) {
     return;
   }
   const rcedit = require('rcedit'); // 惰性加载，避免未配置 icon 时增加启动开销
-  await rcedit(exePath, { icon: iconPath });
-  process.stdout.write(`[freedom] 已注入 exe 图标：${iconPath}\n`);
+  const info = { icon: iconPath };
+  // rcedit 4.x 参数结构：FileDescription/ProductName 等字符串必须走
+  // version-string（--set-version-string 键值对），file-version/product-version
+  // 才是独立的 --set-* 单值参数。旧版平铺的 file-description/product-name 会被静默忽略。
+  const versionString = {};
+  if (name) {
+    versionString['FileDescription'] = name;
+    versionString['ProductName'] = name;
+  }
+  if (Object.keys(versionString).length > 0) {
+    info['version-string'] = versionString;
+  }
+  if (version) {
+    info['file-version'] = version;
+    info['product-version'] = version;
+  }
+  await rcedit(exePath, info);
+  process.stdout.write(`[freedom] 已注入 exe 图标与版本信息：${iconPath} (${name || '?'} ${version || '?'})\n`);
 }
 
 // 解析 cfg.icon：相对项目根或绝对路径 -> 绝对路径；未配置返回 null。
@@ -455,7 +548,11 @@ function intVal(v, dft) {
 // 导致页面 JS/CSS 丢失静默空白。检测到此类引用时明确告警，避免用户无感知翻车。
 function warnIfNotSingleFile(html, distHtml) {
   const refs = [];
-  const re = /<(?:script|link)\b[^>]*(?:src|href)\s*=\s*["']([^"']+)["']/gi;
+  // M4：此前只检查 script/link，漏掉了 img/iframe/video/audio/source/object/embed/track 等
+  // 一切带 URL 引用的标签。壳只 SetHtml 单页内存加载，任何相对路径 / 根路径 / 协议相对的
+  // 外部引用（JS、CSS、图片、子页面、音视频、内嵌对象）在无服务器环境下都会失效，
+  // 需一并告警，避免"脚本内联了但图片仍空白"这类半翻车。
+  const re = /<(?:script|link|img|iframe|video|audio|source|object|embed|track)\b[^>]*(?:src|href|data)\s*=\s*["']([^"']+)["']/gi;
   let m;
   while ((m = re.exec(html)) !== null) {
     const url = m[1];
@@ -463,6 +560,16 @@ function warnIfNotSingleFile(html, distHtml) {
     if (/^(?:data:|blob:|https?:|file:)/i.test(url)) continue;
     refs.push(url);
   }
+  // img 的 srcset（逗号分隔多候选 URL）单独扫描
+  const srcsetRe = /<img\b[^>]*\bsrcset\s*=\s*["']([^"']+)["']/gi;
+  while ((m = srcsetRe.exec(html)) !== null) {
+    for (const part of m[1].split(',')) {
+      const url = part.trim().split(/\s+/)[0];
+      if (!url) continue;
+      if (/^(?:data:|blob:|https?:|file:)/i.test(url)) continue;
+      refs.push(url);
+    }
+  }
   if (refs.length > 0) {
     console.warn(
       `[freedom] 警告：${path.basename(distHtml)} 引用了外部资源（${refs.join(', ')}）。` +
@@ -472,4 +579,17 @@ function warnIfNotSingleFile(html, distHtml) {
   }
 }
 
+// 递归收集目录内所有文件：relPath（POSIX 相对路径）-> Buffer 内容，供 .integrity 完整性清单使用。
+function collectDirFiles(dir, prefix, out) {
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const abs = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      collectDirFiles(abs, prefix + entry.name + '/', out);
+    } else {
+      out[(prefix + entry.name).replace(/\\/g, '/')] = fs.readFileSync(abs);
+    }
+  }
+  return out;
+}
+
 module.exports = { build, parsePlatforms };

package/lib/cli.js

@@ -22,12 +22,13 @@ function help() {
   L.push(`  ${paint('freedom', C.fg.cyan, C.bold)}                  ${dim('进入完整 CLI 模式（交互式菜单，新建 / 打包 / 配置 / 壳管理）')}`);
   L.push(`  ${paint('freedom tui', C.fg.cyan, C.bold)}              ${dim('同上（兼容写法，显式进入交互式模式）')}`);
   L.push(section('项目'));
-  L.push(`  ${paint('freedom init [目录] [--force]', C.fg.cyan)}    ${dim('在当前 / 指定目录新建项目模板')}`);
+  L.push(`  ${paint('freedom init [目录] [--force] [--template full|minimal]', C.fg.cyan)}  ${dim('新建项目模板（默认 full：含自绘标题栏示例；minimal：极简无自绘标题栏）')}`);
   L.push(`  ${paint('freedom tutorial', C.fg.cyan)}                 ${dim('再次打开安装教程')}`);
   L.push(section('打包'));
   L.push(`  ${paint('freedom build [--platform <p>]', C.fg.cyan)}   ${dim('前端打包并分发桌面应用（默认当前平台）')}`);
   L.push(`      ${dim('--platform win|mac|linux|all')}    ${dim('指定目标平台（all = 三平台全量）')}`);
   L.push(`      ${dim('--no-cache')}                      ${dim('忽略前端构建缓存，强制重新打包')}`);
+  L.push(`  ${paint('freedom verify [--platform <p>]', C.fg.cyan)}   ${dim('校验已构建产物完整性并打印产物结构（CI 可依赖退出码）')}`);
   L.push(`  ${paint('freedom dmg [--platform <plat>]', C.fg.cyan)}  ${dim('将已构建的 .app 打包为 .dmg（需 macOS）')}`);
   L.push(section('外观'));
   L.push(`  ${paint('freedom titlebar <native|frameless>', C.fg.cyan)} ${dim('一键切换标题栏策略')}`);
@@ -113,9 +114,25 @@ async function run(argv) {
 
     case 'init': {
       const force = rest.includes('--force');
-      const dirArg = rest.filter((a) => a !== '--force')[0];
-      const dir = init(dirArg || '.', { force });
+      const tmplArg = rest.find((a) => a.startsWith('--template'));
+      let template;
+      if (tmplArg) {
+        template = tmplArg.includes('=') ? tmplArg.split('=')[1] : rest[rest.indexOf(tmplArg) + 1];
+        if (!template || template.startsWith('--')) {
+          console.error(`${err('--template 缺少取值。')} ${dim('用法：')}${paint('freedom init <目录> --template <full|minimal>', C.fg.cyan)}`);
+          return 1;
+        }
+      }
+      const dirArg = rest.filter((a) => a !== '--force' && !a.startsWith('--template'))[0];
+      let dir;
+      try {
+        dir = init(dirArg || '.', { force, template });
+      } catch (e) {
+        console.error(`${err(e.message)}`);
+        return 1;
+      }
       console.log(`${ok('项目已创建：')}${paint(dir, C.fg.cyan, C.bold)}`);
+      console.log(`  ${dim(`模板：${template === 'minimal' ? 'minimal（极简，无自绘标题栏）' : 'full（完整，含自绘标题栏示例）'}`)}`);
       console.log(`  ${dim('下一步：')}`);
       console.log(`    ${paint(`cd ${dir}`, C.fg.white)}`);
       console.log(`    ${paint('npm install', C.fg.white)}`);
@@ -139,13 +156,69 @@ async function run(argv) {
           return 1;
         }
       }
-      const { results } = await build(process.cwd(), { platform, noCache: rest.includes('--no-cache') });
+      // 安全模式：--security <none|basic|high>（可选，默认取 freedom.config.js 的 security 字段）
+      const secArg = rest.find((a) => a.startsWith('--security'));
+      let security;
+      if (secArg) {
+        const inline = secArg.includes('=') ? secArg.split('=')[1] : undefined;
+        security = inline || rest[rest.indexOf(secArg) + 1];
+        if (!security || security.startsWith('--')) {
+          console.error(`${err('--security 缺少取值。')} ${dim('用法：')}${paint('freedom build --security <none|basic|high>', C.fg.cyan)}`);
+          return 1;
+        }
+      }
+      const { results } = await build(process.cwd(), {
+        platform,
+        noCache: rest.includes('--no-cache'),
+        security,
+      });
       for (const r of results) {
         console.log(`${ok('构建完成')} ${paint(`[${r.plat}]`, C.fg.magenta, C.bold)} ${paint(r.outFile, C.fg.white)}`);
       }
       return 0;
     }
 
+    case 'verify': {
+      const platArg = rest.find((a) => a.startsWith('--platform') || a.startsWith('-p'));
+      let platform;
+      if (platArg) {
+        const inline = platArg.includes('=') ? platArg.split('=')[1] : undefined;
+        platform = inline || rest[rest.indexOf(platArg) + 1];
+        if (!platform || platform.startsWith('--')) {
+          console.error(`${err('--platform 缺少取值。')} ${dim('用法：')}${paint('freedom verify [--platform <p>]', C.fg.cyan)}`);
+          return 1;
+        }
+      }
+      const { verifyProduct, renderTree, formatChecks } = require('./verify');
+      const v = await verifyProduct(process.cwd(), { platform });
+      if (v.error) {
+        console.error(`${err('校验失败：')}${v.error}`);
+        return 1;
+      }
+      if (v.targets.length === 0) {
+        console.error(`${err('未在产物目录发现可执行文件。')} ${dim('请先运行')} ${paint('freedom build', C.fg.cyan)} ${dim('生成产物。')}`);
+        return 1;
+      }
+      let allPass = true;
+      for (const t of v.targets) {
+        console.log(`\n${section(`[${t.plat}] ${t.dir}`)}`);
+        for (const c of t.checks) {
+          console.log(`  ${c.pass ? ok('通过') : err('失败')} ${c.name}：${c.detail}`);
+        }
+        allPass = allPass && t.checks.every((c) => c.pass);
+      }
+      console.log(`\n${dim('产物结构：')}`);
+      for (const line of renderTree(v.targets).split('\n')) {
+        console.log(`  ${line}`);
+      }
+      if (allPass) {
+        console.log(`\n${ok('产物校验全部通过。')}`);
+        return 0;
+      }
+      console.log(`\n${err('产物校验存在失败项，请检查上方输出。')}`);
+      return 1;
+    }
+
     case 'shell':
       return await runShell(rest);
 
@@ -178,6 +251,23 @@ async function run(argv) {
       return 0;
     }
 
+    case 'security': {
+      const mode = rest[0];
+      if (!['none', 'basic', 'high'].includes(mode)) {
+        console.error(`${err('用法：')}${paint('freedom security <none|basic|high>', C.fg.cyan)}`);
+        console.error(`  ${dim('none  = 明文资源（默认，兼容历史产物）')}`);
+        console.error(`  ${dim('basic = 明文资源 + 构建期加固提示')}`);
+        console.error(`  ${dim('high  = resources 加密为 app.bin + .integrity 完整性清单，磁盘无明文，壳内存解密')}`);
+        return 1;
+      }
+      setConfig(process.cwd(), 'security', mode);
+      console.log(`${ok('安全模式已切换为：')}${paint(mode, C.fg.cyan, C.bold)}`);
+      if (mode === 'high') {
+        console.log(`  ${dim('下一次')} ${paint('freedom build', C.fg.cyan)} ${dim('将加密 resources（app.bin），前端源码与配置不会以明文落盘。')}`);
+      }
+      return 0;
+    }
+
     case 'config': {
       const sub = rest[0];
       if (sub === 'get') {

package/lib/config.js

@@ -14,6 +14,7 @@ const KEY_TYPES = {
   center: 'bool',
   debug: 'bool',
   titlebar: 'titlebar',
+  security: 'security',
   icon: 'string',
   outDir: 'string',
 };
@@ -42,6 +43,13 @@ function normalizeValue(key, value) {
     }
     return s;
   }
+  if (t === 'security') {
+    const s = String(value);
+    if (!['none', 'basic', 'high'].includes(s)) {
+      throw new Error('security 取值必须为：none / basic / high。');
+    }
+    return s;
+  }
   // 扩展键（如 backend）：字符串命令简写转 {command,args} 对象，
   // 与 build.js renderConfigJSON 的契约对齐（纯字符串形态不会被打包为后端进程）。
   if (key === 'backend') {
@@ -86,7 +94,9 @@ function setConfig(dir, key, value) {
   const rendered = renderLiteral(norm);
 
   const lines = text.split('\n');
-  const keyRe = new RegExp(`^(\\s*)${key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*:(.*)$`);
+  // 容忍 CRLF 行尾（Windows 编辑器 / git autocrlf 可能产生）：JS 正则的 . 不匹配 \r，
+  // 直接匹配 (.*)$ 会在行尾残留 \r 导致整行失配（历史隐患）。
+  const keyRe = new RegExp(`^(\\s*)${key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*:(.*)\\r?$`);
   let replaced = false;
   for (let i = 0; i < lines.length; i++) {
     if (lines[i].trim().startsWith('//')) continue; // 注释行不参与匹配与改写
@@ -130,6 +140,7 @@ const KNOWN_KEYS = {
   center: true,
   debug: false,
   titlebar: 'frameless',
+  security: 'none',
   icon: undefined,
   outDir: 'dist',
 };

package/lib/init.js

@@ -12,8 +12,16 @@ function init(targetDir, opts = {}) {
     throw new Error(`目标目录 ${abs} 非空，请使用空目录，或加 --force 覆盖。`);
   }
 
+  // 模板选择：'minimal' 极简（无自绘标题栏 / 无演示内容，默认 native 标题栏）；默认完整模板。
+  // 非法值快速失败，避免静默回退成默认模板让用户误以为指定成功。
+  const template = opts.template || 'full';
+  const templateName = template === 'minimal' ? 'project-minimal' : 'project';
+  if (template !== 'full' && template !== 'minimal') {
+    throw new Error(`未知模板：${template}。可选：full（完整模板，含自绘标题栏示例）/ minimal（极简模板，无自绘标题栏）。`);
+  }
+
   fs.mkdirSync(abs, { recursive: true });
-  copyDir(projectTemplateDir(), abs);
+  copyDir(projectTemplateDir(templateName), abs);
 
   // 项目名替换到 package.json 与 freedom.config.js
   const name = opts.name || path.basename(abs);

package/lib/security.js

@@ -0,0 +1,150 @@
+'use strict';
+
+// 安全加固模块（v1.13.10）
+//
+// 为 freedom build 提供两种安全模式：
+//   - basic（简单模式）：资源压缩 + 壳剥离符号建议，阻止"随手打开 resources/
+//     就能看到前端源码"的随手破解，成本低、完全向后兼容。
+//   - high（高危模式）：AES-256-CTR + HMAC-SHA256（Encrypt-then-MAC）加密资源为
+//     单一容器 resources/app.bin，运行时由壳在内存中解密（磁盘无明文）；
+//     配套 HMAC 完整性校验防篡改；密钥不落盘（由 exe 文件名派生），
+//     并强制关闭 WebView2 devtools。
+//
+// 架构说明（重要）：通用壳 = 所有应用共用一份预编译 freedom-shell 二进制，
+// 因此密钥派生所需的"主密钥常量"编译在通用壳内，天然被所有应用共享；
+// high 模式的对抗目标是把攻击者从"直接读明文"抬升到"必须逆向壳二进制、
+// 提取主密钥并复现派生算法"。真正"每应用唯一密钥"需要每应用独立编译壳
+// （破坏通用壳 + 零工具链架构），不在本模式范围内。
+//
+// ⚠️ 跨语言同步点：本文件与 templates/go/pkg/freedom/security.go 必须保持
+//    MASTER_KEY / DERIVE_SALT / PBKDF2_ITER / KEY_LEN / APP_BIN_MAGIC
+//    以及加密算法（aes-256-ctr + hmac-sha256）完全一致。
+//    修改任一侧必须同步另一侧，否则 build 出的加密资源壳无法解密。
+
+const crypto = require('crypto');
+const path = require('path');
+
+const SECURITY_MODES = ['none', 'basic', 'high'];
+
+// ---- 密钥派生参数（必须与 Go security.go 同步）----
+// 固定常量主密钥：参与 PBKDF2 派生，编译进通用壳。此处为 CLI 侧同值。
+const MASTER_KEY = 'freedom-shell::kdf-master::v1::7f4e8c2a9b1d6e3f';
+const DERIVE_SALT = 'freedom:derive:v1';
+const PBKDF2_ITER = 60000;
+const KEY_LEN = 32;
+
+// resources/app.bin 容器头：magic(5B 'FRDM1') + iv(16B) + tag(16B) + ciphertext
+// 算法：AES-256-CTR 加密 + HMAC-SHA256(密文) 截断 16B 认证标签。
+const APP_BIN_MAGIC = 'FRDM1';
+const CTR_IV_LEN = 16;
+const CTR_TAG_LEN = 16;
+
+// ---- 模式解析 ----
+
+// 解析安全模式；非法值抛错。opts.security 优先于 cfg.security，默认 none。
+function parseSecurity(raw) {
+  if (!raw) return 'none';
+  const v = String(raw).trim().toLowerCase();
+  if (!SECURITY_MODES.includes(v)) {
+    throw new Error(`未知安全模式：${raw}。可选：${SECURITY_MODES.join(' / ')}`);
+  }
+  return v;
+}
+
+// 归一化：CLI 显式参数 > 项目配置 > 默认 none
+function resolveSecurity(cliValue, cfgValue) {
+  if (cliValue) return parseSecurity(cliValue);
+  return parseSecurity(cfgValue);
+}
+
+// ---- 密钥派生 ----
+
+// 应用标识：exe 文件名（去扩展名）。
+// CLI build 时 = 目标 exe 名去掉扩展名；壳运行时 = os.Executable() basename 去扩展名。
+// 两侧使用同一派生算法，故 exe 事后被重命名会导致 high 模式无法解密（视为防篡改特性）。
+function appIdentityFor(name) {
+  return String(name).replace(/\.(exe|app)$/i, '');
+}
+
+// 与 Go security.go deriveKey 保持一致的 PBKDF2-HMAC-SHA256 派生。
+// 输入 salt = DERIVE_SALT + ':' + appName（避免仅按 exe 名可枚举碰撞）。
+function deriveKey(appName) {
+  const salt = Buffer.from(DERIVE_SALT + ':' + appIdentityFor(appName), 'utf8');
+  return crypto.pbkdf2Sync(MASTER_KEY, salt, PBKDF2_ITER, KEY_LEN, 'sha256');
+}
+
+// ---- 加密 / 解密（high 模式）----
+
+// 载荷结构：{ html: <string>, config: <string> }（config 为 config.json 原文 JSON 字符串）。
+// 返回 app.bin 完整字节。
+// 算法：AES-256-CTR 加密 → HMAC-SHA256(密文) 截 16B 认证标签（Encrypt-then-MAC）。
+function encryptApp(name, html, configJSON) {
+  const key = deriveKey(name);
+  const payload = Buffer.from(JSON.stringify({ html, config: configJSON }), 'utf8');
+  const iv = crypto.randomBytes(CTR_IV_LEN);
+  const cipher = crypto.createCipheriv('aes-256-ctr', key, iv);
+  const ct = Buffer.concat([cipher.update(payload), cipher.final()]);
+  const tag = crypto.createHmac('sha256', key).update(ct).digest().subarray(0, CTR_TAG_LEN);
+  return Buffer.concat([Buffer.from(APP_BIN_MAGIC, 'ascii'), iv, tag, ct]);
+}
+
+// 解密 app.bin（供单测验证 / 未来壳调试工具复用）。返回 { html, config }。
+function decryptApp(name, buf) {
+  const key = deriveKey(name);
+  const magic = Buffer.from(APP_BIN_MAGIC, 'ascii');
+  if (buf.length < magic.length + CTR_IV_LEN + CTR_TAG_LEN || !buf.subarray(0, magic.length).equals(magic)) {
+    throw new Error('app.bin 头无效：不是 FRDM1 加密容器');
+  }
+  let off = magic.length;
+  const iv = buf.subarray(off, off + CTR_IV_LEN); off += CTR_IV_LEN;
+  const tag = buf.subarray(off, off + CTR_TAG_LEN); off += CTR_TAG_LEN;
+  const ct = buf.subarray(off);
+
+  // 1) 认证：HMAC-SHA256(ct) 前 16 字节与容器头 tag 恒定时间比对。
+  const expect = crypto.createHmac('sha256', key).update(ct).digest().subarray(0, CTR_TAG_LEN);
+  if (!crypto.timingSafeEqual(tag, expect)) {
+    throw new Error('app.bin 认证失败（exe 被重命名或资源被篡改？）');
+  }
+
+  // 2) 解密：AES-256-CTR。
+  const decipher = crypto.createDecipheriv('aes-256-ctr', key, iv);
+  const plain = Buffer.concat([decipher.update(ct), decipher.final()]);
+  const obj = JSON.parse(plain.toString('utf8'));
+  if (typeof obj.html !== 'string' || typeof obj.config !== 'string') {
+    throw new Error('app.bin 载荷结构无效：缺少 html/config 字段');
+  }
+  return obj;
+}
+
+// ---- 完整性清单（high 模式）----
+
+// 生成 resources/.integrity：记录 app.bin 与 backend/ 各文件的 HMAC-SHA256，
+// 壳启动时校验，防止 resources 被整体替换/篡改。
+// 返回 { v, appBin, backend }。
+function buildIntegrity(appName, appBin, backendRelMap) {
+  const key = deriveKey(appName);
+  const hmac = (buf) => crypto.createHmac('sha256', key).update(buf).digest('hex');
+  const backend = {};
+  for (const [rel, buf] of Object.entries(backendRelMap || {})) {
+    backend[rel] = hmac(buf);
+  }
+  return { v: 1, appBin: hmac(appBin), backend };
+}
+
+// 生成 .integrity 文件文本。
+function renderIntegrity(integrity) {
+  return JSON.stringify(integrity, null, 2);
+}
+
+module.exports = {
+  SECURITY_MODES,
+  APP_BIN_MAGIC,
+  parseSecurity,
+  resolveSecurity,
+  appIdentityFor,
+  deriveKey,
+  encryptApp,
+  decryptApp,
+  buildIntegrity,
+  renderIntegrity,
+};