@yufengtadian/freedom-cli 1.12.15 → 1.12.17

package/lib/update.js

@@ -1,21 +1,42 @@
 'use strict';
 
-// 版本检测：零依赖（https 内置），查询 npm registry 最新版本并对比本地版本。
-// - 结果缓存到 ~/.freedom/update-cache.json，24h 内不重复联网（离线不打扰）
-// - compareVersions 手写 semver 比较（仅处理 x.y.z 数字前缀，满足语义版本场景）
-// - 所有联网失败均静默降级，绝不阻塞主流程
+// 版本检测与自动更新：零依赖（https 内置）
+//
+// 版本检测：
+//   - 查询 npm registry 最新版本并对比本地版本，结果缓存 24h（离线不打扰）
+// 自动更新：
+//   - 检测到新版本时自动执行 `npm install -g <pkg>@latest`，无需用户手动升级
+//   - 仅当当前包为 npm 全局安装时自动更新（npm link / 本地目录安装仅提示手动命令）
+//   - 自动更新带 6h 频控（FREEDOM_AUTO_UPDATE_FORCE=1 可强制），失败静默降级不阻塞主流程
+// 开关：
+//   - FREEDOM_AUTO_UPDATE=0 / false / off 可关闭自动更新（仅保留版本提示）
+// 所有联网 / 更新失败均静默降级，绝不阻塞主流程。
+// compareVersions 手写 semver 比较（仅处理 x.y.z 数字前缀，满足语义版本场景）。
 
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const https = require('https');
+const { spawn, execFileSync } = require('child_process');
 const { packageRoot } = require('./utils');
 
 const PKG_NAME = '@yufengtadian/freedom-cli';
 const REGISTRY = `https://registry.npmjs.org/${encodeURIComponent(PKG_NAME)}/latest`;
 const CACHE_FILE = path.join(os.homedir(), '.freedom', 'update-cache.json');
-const CACHE_TTL = 24 * 60 * 60 * 1000; // 24 小时
+const CACHE_TTL = 24 * 60 * 60 * 1000; // 版本检测缓存 24h
+const AUTO_UPDATE_GAP = 6 * 60 * 60 * 1000; // 自动更新尝试频控 6h
 const REQUEST_TIMEOUT = 4000;
+const UPDATE_TIMEOUT = 120000; // npm install 超时 120s
+
+// 实际安装的包名：优先读 package.json（fork / 改名时自动跟随），兜底 PKG_NAME
+function pkgName() {
+  try {
+    const pkg = require(path.join(packageRoot(), 'package.json'));
+    return typeof pkg.name === 'string' && pkg.name ? pkg.name : PKG_NAME;
+  } catch (e) {
+    return PKG_NAME;
+  }
+}
 
 function currentVersion() {
   return require(path.join(packageRoot(), 'package.json')).version;
@@ -34,11 +55,22 @@ function compareVersions(a, b) {
   return 0;
 }
 
-function readCache() {
+// ---- 缓存 ----
+
+// 读取原始缓存（不校验 TTL），供自动更新频控使用；损坏返回 null
+function readRawCache() {
   try {
     const j = JSON.parse(fs.readFileSync(CACHE_FILE, 'utf8'));
-    if (j && j.latest && Date.now() - j.ts < CACHE_TTL) return j;
-  } catch (e) { /* 无缓存或损坏，忽略 */ }
+    return j && typeof j === 'object' ? j : null;
+  } catch (e) {
+    return null;
+  }
+}
+
+// 读取有效缓存：latest 存在且未过期才返回（版本检测用）
+function readCache() {
+  const j = readRawCache();
+  if (j && j.latest && Date.now() - j.ts < CACHE_TTL) return j;
   return null;
 }
 
@@ -49,30 +81,38 @@ function writeCache(data) {
   } catch (e) { /* 写缓存失败静默 */ }
 }
 
-// 从 npm registry 拉取 latest 版本；失败 / 超时返回 null
+function clearCache() {
+  try { fs.unlinkSync(CACHE_FILE); } catch (e) { /* 忽略 */ }
+}
+
+// ---- 联网检测 ----
+// 从 npm registry 拉取 latest 版本；失败 / 超时返回 null。
+// B54：timeout 时显式 settle，避免 https 请求超时后 Promise 永不 resolve（悬空）。
 function fetchLatest(timeout = REQUEST_TIMEOUT) {
   return new Promise((resolve) => {
+    let settled = false;
+    const done = (v) => { if (!settled) { settled = true; resolve(v); } };
     const req = https.get(REGISTRY, {
       headers: { 'user-agent': 'freedom-cli', accept: 'application/json' },
       timeout,
     }, (res) => {
       if (res.statusCode !== 200) {
         res.resume();
-        return resolve(null);
+        return done(null);
       }
       let body = '';
       res.setEncoding('utf8');
       res.on('data', (chunk) => { body += chunk; });
       res.on('end', () => {
         try {
-          resolve(JSON.parse(body).version || null);
+          done(JSON.parse(body).version || null);
         } catch (e) {
-          resolve(null);
+          done(null);
         }
       });
     });
-    req.on('timeout', () => req.destroy());
-    req.on('error', () => resolve(null));
+    req.on('timeout', () => { req.destroy(); done(null); });
+    req.on('error', () => done(null));
   });
 }
 
@@ -89,21 +129,131 @@ async function checkUpdate({ force = false } = {}) {
   return { current, latest, hasUpdate };
 }
 
-// 静默异步通知：仅在检测到新版本时打印一行升级提示，不阻塞调用方
-async function maybeNotifyUpdate() {
+// ---- 全局安装判定 ----
+
+function npmGlobalRoot() {
   try {
-    const r = await checkUpdate();
-    if (r.hasUpdate && r.latest) {
-      const theme = require('./theme');
-      console.log('');
-      console.log(`  ${theme.paint('➜', theme.C.fg.magenta, theme.C.bold)} ${theme.paint(`新版本可用 ${r.latest}（当前 ${r.current}）`, theme.C.fg.yellow)}`);
-      console.log(`    ${theme.dim('运行')} ${theme.paint(`npm install -g ${PKG_NAME}@latest`, theme.C.fg.cyan)} ${theme.dim('升级，或')} ${theme.paint('freedom update', theme.C.fg.cyan)} ${theme.dim('查看详情')}`);
-      console.log('');
-    }
-  } catch (e) { /* 检测失败静默 */ }
+    const cmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+    const out = execFileSync(cmd, ['root', '-g'], {
+      encoding: 'utf8',
+      timeout: 10000,
+      windowsHide: true,
+      shell: process.platform === 'win32',
+    });
+    return out.trim() || null;
+  } catch (e) {
+    return null;
+  }
+}
+
+// target 是否位于 root 目录内（含直接子级）；任一为空返回 false
+function isPathInside(root, target) {
+  if (!root || !target) return false;
+  const rel = path.relative(root, target);
+  return rel !== '' && !rel.startsWith('..') && !path.isAbsolute(rel);
+}
+
+// 当前安装是否为 npm 全局安装。
+// 仅全局安装才允许自动更新；npm link / 本地目录安装时仅提示手动命令，
+// 避免自动安装出一份与当前工作副本无关的全局副本（行为不可预期）。
+function isGlobalInstall() {
+  const root = npmGlobalRoot();
+  if (!root) return false;
+  return isPathInside(root, packageRoot());
+}
+
+// ---- 自动更新执行 ----
+
+// 执行 `npm install -g <pkg>@<latest>`；返回 { ok, detail }
+function performAutoUpdate(latest, { timeoutMs = UPDATE_TIMEOUT } = {}) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const done = (v) => { if (!settled) { settled = true; resolve(v); } };
+    const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+    const child = spawn(
+      npm,
+      ['install', '-g', `${pkgName()}@${latest}`, '--no-audit', '--no-fund', '--loglevel=error'],
+      { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true, shell: process.platform === 'win32' }
+    );
+    let out = '';
+    let err = '';
+    child.stdout.on('data', (d) => { out += d; });
+    child.stderr.on('data', (d) => { err += d; });
+    const timer = setTimeout(() => {
+      try { child.kill(); } catch (e) { /* ignore */ }
+      done({ ok: false, detail: `更新超时（${Math.round(timeoutMs / 1000)}s）` });
+    }, timeoutMs);
+    child.on('error', (e) => { clearTimeout(timer); done({ ok: false, detail: e.message }); });
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      if (code === 0) done({ ok: true, detail: (out.trim() || err.trim() || '') });
+      else done({ ok: false, detail: (err.trim() || out.trim() || `npm 退出码 ${code}`) });
+    });
+  });
+}
+
+// 自动更新频控是否到期：距上次尝试超过 AUTO_UPDATE_GAP 才算到期
+function autoUpdateDue(now = Date.now()) {
+  const raw = readRawCache();
+  if (!raw || !raw.lastAutoAttempt) return true;
+  return now - raw.lastAutoAttempt >= AUTO_UPDATE_GAP;
+}
+
+// 自动更新完整流程。返回结构化结果供调用方打印。
+// r：可传入预取的 checkUpdate 结果，避免重复联网；force：跳过缓存与频控。
+async function maybeAutoUpdate({ force = false, r = null } = {}) {
+  // 开关：FREEDOM_AUTO_UPDATE=0 / false / off 关闭自动更新
+  const flag = (process.env.FREEDOM_AUTO_UPDATE || '').toLowerCase();
+  if (flag === '0' || flag === 'false' || flag === 'off') return { skipped: 'disabled' };
+
+  const info = r || (await checkUpdate({ force }));
+  if (!info.latest) return { offline: true };
+  if (!info.hasUpdate) return { upToDate: true, latest: info.latest };
+  if (!isGlobalInstall()) {
+    return { notGlobal: true, latest: info.latest, current: info.current };
+  }
+
+  const forceFlag = (process.env.FREEDOM_AUTO_UPDATE_FORCE || '').toLowerCase();
+  const skipThrottle = force || forceFlag === '1' || forceFlag === 'true';
+  if (!skipThrottle && !autoUpdateDue()) {
+    return { throttled: true, latest: info.latest, current: info.current };
+  }
+
+  // 先标记尝试再执行，防止多进程并发 / 失败后风暴重试
+  writeCache({ latest: info.latest, lastAutoAttempt: Date.now() });
+  const res = await performAutoUpdate(info.latest);
+  if (res.ok) {
+    clearCache(); // 更新成功后清缓存，下次以新版本为基准重新检测
+    return { updated: true, from: info.current, to: info.latest, detail: res.detail };
+  }
+  return { failed: true, latest: info.latest, current: info.current, detail: res.detail };
+}
+
+// 把自动更新结果渲染为终端提示行（供 CLI 打印；TUI 自行拼装）。
+// upToDate / offline / skipped 不产生提示（静默），返回空数组。
+function formatUpdateResult(res, theme) {
+  const { paint, C, ok, warn, tip, dim } = theme;
+  const lines = [];
+  if (res.updated) {
+    lines.push(`  ${ok(`已自动更新到 v${res.to}（原 v${res.from}）。`)}`);
+    lines.push(`    ${dim('下次运行')} ${paint('freedom', C.fg.cyan)} ${dim('即为新版本。')}`);
+  } else if (res.notGlobal) {
+    lines.push(`  ${warn(`检测到新版本 v${res.latest}（当前 v${res.current}）。`)}`);
+    lines.push(`    ${dim('当前为非全局安装，无法自动更新，请手动执行：')}${paint(`npm install -g ${pkgName()}@latest`, C.fg.cyan, C.bold)}`);
+  } else if (res.failed) {
+    lines.push(`  ${warn('自动更新失败：')}${dim(res.detail || '未知原因')}`);
+    lines.push(`    ${dim('可稍后运行')} ${paint('freedom update', C.fg.cyan)} ${dim('重试，或手动执行：')}${paint(`npm install -g ${pkgName()}@latest`, C.fg.cyan, C.bold)}`);
+  } else if (res.throttled) {
+    lines.push(`  ${tip(`新版本 v${res.latest} 存在，6h 内已尝试过自动更新，本次跳过。`)}`);
+    lines.push(`    ${dim('运行')} ${paint('freedom update', C.fg.cyan)} ${dim('可立即强制更新。')}`);
+  }
+  return lines;
 }
 
 module.exports = {
-  PKG_NAME, REGISTRY, CACHE_FILE, CACHE_TTL,
-  currentVersion, compareVersions, checkUpdate, maybeNotifyUpdate,
+  PKG_NAME, REGISTRY, CACHE_FILE, CACHE_TTL, AUTO_UPDATE_GAP,
+  pkgName, currentVersion, compareVersions, checkUpdate,
+  readRawCache, readCache, writeCache, clearCache,
+  npmGlobalRoot, isPathInside, isGlobalInstall,
+  performAutoUpdate, autoUpdateDue, maybeAutoUpdate, formatUpdateResult,
 };

package/package.json

@@ -1,39 +1,39 @@
-{
-  "name": "@yufengtadian/freedom-cli",
-  "version": "1.12.15",
-  "description": "Freedom WebView desktop shell packaging tool - no Go toolchain required, one command packs three-platform desktop apps",
-  "keywords": [
-    "desktop",
-    "webview",
-    "electron-alternative",
-    "wails",
-    "tauri",
-    "frontend",
-    "cross-platform"
-  ],
-  "license": "MIT",
-  "publishConfig": {
-    "access": "public"
-  },
-  "bin": {
-    "freedom": "bin/freedom.js"
-  },
-  "files": [
-    "bin",
-    "lib",
-    "shell",
-    "templates",
-    "tutorial",
-    "postinstall.js",
-    "README.md"
-  ],
-  "scripts": {
-    "postinstall": "node postinstall.js"
-  },
-  "engines": {
-    "node": ">=18"
-  },
-  "dependencies": {
-    "rcedit": "^4.0.1"
-  }
-}
+{
+  "name": "@yufengtadian/freedom-cli",
+  "version": "1.12.17",
+  "description": "Freedom WebView desktop shell packaging tool - no Go toolchain required, one command packs three-platform desktop apps",
+  "keywords": [
+    "desktop",
+    "webview",
+    "electron-alternative",
+    "wails",
+    "tauri",
+    "frontend",
+    "cross-platform"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "freedom": "bin/freedom.js"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "shell",
+    "templates",
+    "tutorial",
+    "postinstall.js",
+    "README.md"
+  ],
+  "scripts": {
+    "postinstall": "node postinstall.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "rcedit": "^4.0.1"
+  }
+}

package/templates/go/pkg/freedom/anti_debug_other.go

@@ -0,0 +1,8 @@
+//go:build !windows
+
+package freedom
+
+// 反调试（非 Windows 平台空实现）。
+// macOS/Linux 的调试器检测（ptrace / task_for_pid 等）依赖平台特定 API，
+// 本版本不做；如需加强可在对应平台文件扩展。
+func antiDebugCheck() {}

package/templates/go/pkg/freedom/anti_debug_windows.go

@@ -0,0 +1,39 @@
+//go:build windows
+
+package freedom
+
+// 反调试（Windows 实现）：high 安全模式下调用。
+// 检测常见用户态调试器，发现时静默退出，防止攻击者在调试器下
+// 单步追踪资源解密 / 密钥派生逻辑。
+
+import (
+	"os"
+	"syscall"
+	"unsafe"
+)
+
+var (
+	kernel32dbg                      = syscall.NewLazyDLL("kernel32.dll")
+	procIsDebuggerPresent            = kernel32dbg.NewProc("IsDebuggerPresent")
+	procCheckRemoteDebuggerPresent   = kernel32dbg.NewProc("CheckRemoteDebuggerPresent")
+)
+
+// antiDebugCheck 检测调试器；发现则立即退出进程（退出码 77，无提示）。
+// 仅在 high 安全模式启用时由 freedom.go Run() 调用。
+func antiDebugCheck() {
+	if isBeingDebugged() {
+		os.Exit(77)
+	}
+}
+
+// isBeingDebugged 同时检测本地调试器（IsDebuggerPresent）与远程/内核调试器
+// （CheckRemoteDebuggerPresent），任一命中即认为正在被调试。
+func isBeingDebugged() bool {
+	r, _, _ := procIsDebuggerPresent.Call()
+	if r != 0 {
+		return true
+	}
+	var present int32
+	procCheckRemoteDebuggerPresent.Call(uintptr(0), uintptr(unsafe.Pointer(&present)))
+	return present != 0
+}

package/templates/go/pkg/freedom/center_windows.go

@@ -3,18 +3,9 @@
 package freedom
 
 import (
-	"syscall"
 	"unsafe"
 )
 
-var (
-	user32            = syscall.NewLazyDLL("user32.dll")
-	getSystemMetrics  = user32.NewProc("GetSystemMetrics")
-	moveWindow        = user32.NewProc("MoveWindow")
-	monitorFromWindow = user32.NewProc("MonitorFromWindow")
-	getMonitorInfo    = user32.NewProc("GetMonitorInfoW")
-)
-
 const (
 	smCxScreen           = 16
 	smCyScreen           = 17
@@ -38,19 +29,22 @@ type monitorInfo struct {
 // webview_go 未提供 SetPosition，这里通过原生 HWND + MoveWindow 定位。
 // 优先居中到窗口当前所在监视器的工作区（rcWork）：多屏副屏（负坐标 /
 // 不同分辨率 / 任务栏遮挡）下也能正确居中；API 失败时回退主屏全屏居中。
+//
+// user32 过程句柄（procGetSystemMetrics / procMoveWindow / procMonitorFromWindow /
+// procGetMonitorInfo）统一声明在 window_windows.go，避免两套重复 NewProc。
 func (a *App) applyCenter() {
-	if !a.cfg.Center || a.view == nil {
+	if !a.cfg.Center {
 		return
 	}
-	hwnd := uintptr(unsafe.Pointer(a.view.Window()))
+	hwnd := a.WindowHandle()
 	if hwnd == 0 {
 		return
 	}
-	mon, _, _ := monitorFromWindow.Call(hwnd, monitorDefaultToNear)
+	mon, _, _ := procMonitorFromWindow.Call(hwnd, monitorDefaultToNear)
 	if mon != 0 {
 		var mi monitorInfo
 		mi.cbSize = uint32(unsafe.Sizeof(mi))
-		if r1, _, _ := getMonitorInfo.Call(mon, uintptr(unsafe.Pointer(&mi))); r1 != 0 {
+		if r1, _, _ := procGetMonitorInfo.Call(mon, uintptr(unsafe.Pointer(&mi))); r1 != 0 {
 			work := mi.rcWork
 			sw := work.right - work.left
 			sh := work.bottom - work.top
@@ -62,13 +56,13 @@ func (a *App) applyCenter() {
 			if y < 0 {
 				y = 0
 			}
-			moveWindow.Call(hwnd, uintptr(x), uintptr(y), uintptr(a.cfg.Width), uintptr(a.cfg.Height), 1)
+			procMoveWindow.Call(hwnd, uintptr(x), uintptr(y), uintptr(a.cfg.Width), uintptr(a.cfg.Height), 1)
 			return
 		}
 	}
 	// 回退：主屏全屏尺寸居中（原实现）
-	sw, _, _ := getSystemMetrics.Call(smCxScreen)
-	sh, _, _ := getSystemMetrics.Call(smCyScreen)
+	sw, _, _ := procGetSystemMetrics.Call(smCxScreen)
+	sh, _, _ := procGetSystemMetrics.Call(smCyScreen)
 	x := int(sw/2) - a.cfg.Width/2
 	y := int(sh/2) - a.cfg.Height/2
 	if x < 0 {
@@ -77,5 +71,5 @@ func (a *App) applyCenter() {
 	if y < 0 {
 		y = 0
 	}
-	moveWindow.Call(hwnd, uintptr(x), uintptr(y), uintptr(a.cfg.Width), uintptr(a.cfg.Height), 1)
+	procMoveWindow.Call(hwnd, uintptr(x), uintptr(y), uintptr(a.cfg.Width), uintptr(a.cfg.Height), 1)
 }

package/templates/go/pkg/freedom/configfile.go

@@ -18,6 +18,27 @@ import (
 	"path/filepath"
 )
 
+// loadRuntimeConfig 读取 exe 同目录 resources/config.json，将命中的字段覆盖到应用配置。
+// 文件不存在时视为未配置（返回 nil，保持编译期/默认配置不变）；
+// 文件存在但读取/解析失败时返回具体错误，由调用方打印告警，避免用户手改配置出错时无感知。
+func (a *App) loadRuntimeConfig() error {
+	// high 安全模式：配置与页面封装在加密容器 app.bin 内，优先内存解密加载。
+	if p, hit, err := loadSecureResources(); err != nil {
+		return err
+	} else if hit {
+		var rc runtimeConfigFile
+		if err := json.Unmarshal([]byte(p.Config), &rc); err != nil {
+			return fmt.Errorf("parse encrypted config: %w", err)
+		}
+		a.applyRuntimeConfig(&rc)
+		// high 模式强制关闭 WebView 开发者工具，防止前端源码经 devtools 直接查看。
+		a.cfg.Debug = false
+		a.secure = true
+		return nil
+	}
+	return a.loadRuntimeConfigPlain()
+}
+
 // runtimeBackend 描述 config.json 中的后端进程配置（任意语言，经 stdio NDJSON 桥接）。
 type runtimeBackend struct {
 	Command string   `json:"command"`
@@ -48,10 +69,8 @@ func resourcesDir() (string, error) {
 	return filepath.Join(filepath.Dir(exe), "resources"), nil
 }
 
-// loadRuntimeConfig 读取 exe 同目录 resources/config.json，将命中的字段覆盖到应用配置。
-// 文件不存在时视为未配置（返回 nil，保持编译期/默认配置不变）；
-// 文件存在但读取/解析失败时返回具体错误，由调用方打印告警，避免用户手改配置出错时无感知。
-func (a *App) loadRuntimeConfig() error {
+// loadRuntimeConfigPlain 明文配置路径（非 high 模式）：读取 resources/config.json。
+func (a *App) loadRuntimeConfigPlain() error {
 	dir, err := resourcesDir()
 	if err != nil {
 		return err
@@ -68,11 +87,14 @@ func (a *App) loadRuntimeConfig() error {
 	if err := json.Unmarshal(data, &rc); err != nil {
 		return fmt.Errorf("parse %s: %w", cfgPath, err)
 	}
-	if rc.Title != "" {
-		a.cfg.Title = rc.Title
-	} else if rc.Name != "" {
-		a.cfg.Title = rc.Name
+	if err := a.applyRuntimeConfig(&rc); err != nil {
+		return err
 	}
+	return nil
+}
+
+// applyRuntimeConfig 把解析后的运行时配置覆盖到应用配置（明文与加密路径共用）。
+func (a *App) applyRuntimeConfig(rc *runtimeConfigFile) error {
 	switch rc.TitleBar {
 	case "native":
 		a.cfg.TitleBar = TitleBarNative
@@ -112,8 +134,14 @@ func (a *App) loadRuntimeConfig() error {
 	return nil
 }
 
-// loadRuntimeHTML 读取 exe 同目录 resources/index.html；文件不存在时返回空串。
+// loadRuntimeHTML 返回前端页面内容（high 模式：解密 app.bin 内的 html；
+// 否则读取 exe 同目录 resources/index.html）。文件不存在时返回空串。
 func loadRuntimeHTML() (string, error) {
+	if p, hit, err := loadSecureResources(); err != nil {
+		return "", err
+	} else if hit {
+		return p.HTML, nil
+	}
 	dir, err := resourcesDir()
 	if err != nil {
 		return "", err

package/templates/go/pkg/freedom/freedom.go

@@ -69,6 +69,7 @@ type App struct {
 	backend         Backend
 	backendExplicit bool // 调用方是否显式指定了后端（外部 config.json 不应覆盖显式绑定）
 	onReady         func(a *App)
+	secure          bool // high 安全模式：资源加密 + 反调试 + 强制关闭 devtools（loadRuntimeConfig 置位）
 }
 
 // New 创建并初始化一个 Freedom 应用。调用 Run() 之前不会显示窗口。
@@ -110,7 +111,14 @@ func (a *App) Bind(name string, fn interface{}) error {
 	if !ok {
 		return fmt.Errorf("freedom: Bind 仅适用于内嵌 Go 后端；当前后端为 %T，方法请在进程后端中注册", a.backend)
 	}
-	return eb.Bind(name, fn)
+	if err := eb.Bind(name, fn); err != nil {
+		return err
+	}
+	// B56：用户显式绑定方法 = 显式指定内嵌后端。置位后外部 resources/config.json
+	// 的 backend 配置不再覆盖（loadRuntimeConfig 仅当 !backendExplicit 时生效），
+	// 避免"用户 Bind 的方法被 config.json 的进程后端静默替换而全部失效"。
+	a.backendExplicit = true
+	return nil
 }
 
 // Unbind 移除先前 Bind 的方法（内嵌后端）。
@@ -144,6 +152,11 @@ func (a *App) Run() {
 		fmt.Printf("freedom: warning: %v\n", err)
 	}
 
+	// high 安全模式：反调试检测（调试器下静默退出，防止逆向解密逻辑）。
+	if a.secure {
+		antiDebugCheck()
+	}
+
 	html, err := a.resolveHTML()
 	if err != nil {
 		fmt.Printf("freedom: failed to resolve HTML: %v\n", err)
@@ -152,7 +165,11 @@ func (a *App) Run() {
 
 	w := webview.New(a.cfg.Debug)
 	if w == nil {
-		fmt.Println("freedom: failed to create webview")
+		if !webview2Available() {
+			fmt.Println("freedom: failed to create webview: 未检测到 WebView2 Runtime，请安装 Microsoft Edge WebView2 Runtime（https://go.microsoft.com/fwlink/?linkid=2124703）后重试")
+		} else {
+			fmt.Println("freedom: failed to create webview")
+		}
 		return
 	}
 	a.setView(w)